singrdk/base/Kernel/Singularity.Security/AccessControl/AclParser.sg

// ----------------------------------------------------------------------------
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ----------------------------------------------------------------------------

namespace Microsoft.Singularity.Security.AccessControl
{
using System;
using Microsoft.Contracts;
// test   


internal class AclParser
{
private const int YY_BUFFER_SIZE = 512;
private const int YY_F = -1;
private const int YY_NO_STATE = -1;
private const int YY_NOT_ACCEPT = 0;
private const int YY_START = 1;
private const int YY_END = 2;
private const int YY_NO_ANCHOR = 4;
delegate AclToken AcceptMethod();
AcceptMethod[]! accept_dispatch;
private const int YY_BOL = 128;
private const int YY_EOF = 129;
private StringReader! yy_reader;
private int yy_buffer_index;
private int yy_buffer_read;
private int yy_buffer_start;
private int yy_buffer_end;
private char[]! yy_buffer;
private int yychar;
private int yyline;
private bool yy_at_bol;
private int yy_lexical_state;

    //        [NotDelayed]
   internal AclParser(string data)
   {
       yy_reader = new StringReader(data);
  yy_buffer = new char[YY_BUFFER_SIZE];
  yy_buffer_read = 0;
  yy_buffer_index = 0;
  yy_buffer_start = 0;
  yy_buffer_end = 0;
  yychar = 0;
  yyline = 0;
  yy_at_bol = true;
  yy_lexical_state = YYINITIAL;
  base();

  accept_dispatch = new[Delayed] AcceptMethod[]
 {
  null,
  null,
  new AcceptMethod(this.Accept_2),
  new AcceptMethod(this.Accept_3),
  new AcceptMethod(this.Accept_4),
  new AcceptMethod(this.Accept_5),
  new AcceptMethod(this.Accept_6),
  new AcceptMethod(this.Accept_7),
  null,
  new AcceptMethod(this.Accept_9),
  };
  }

AclToken Accept_2()
    { // begin accept action #2
{
  String! str = (!)yytext().Substring(0, yytext().Length);
  if (str.Equals("!")) {
      return (new AclToken(AclTokenType.Any, str, yychar, yychar + 1));
    }
  else {
      return (new AclToken(AclTokenType.Arc, str, yychar, yychar + str.Length));
    }
}
    } // end accept action #2

AclToken Accept_3()
    { // begin accept action #3
{yybegin(GROUPNAME); return null;}
    } // end accept action #3

AclToken Accept_4()
    { // begin accept action #4
{ return (new AclToken(AclTokenType.Escape, yytext(), yychar, yychar+1)); }
    } // end accept action #4

AclToken Accept_5()
    { // begin accept action #5
{ return (new AclToken(AclTokenType.Literal, yytext(), yychar, yychar+1)); }
    } // end accept action #5

AclToken Accept_6()
    { // begin accept action #6
{yybegin(YYINITIAL); return null;}
    } // end accept action #6

AclToken Accept_7()
    { // begin accept action #7
{
  String! str =  (!)yytext().Substring(0, yytext().Length);
  return (new AclToken(AclTokenType.GroupName, str, yychar, yychar + str.Length));
}
    } // end accept action #7

AclToken Accept_9()
    { // begin accept action #9
{
  String! str = (!)yytext().Substring(0, yytext().Length);
  if (str.Equals("!")) {
      return (new AclToken(AclTokenType.Any, str, yychar, yychar + 1));
    }
  else {
      return (new AclToken(AclTokenType.Arc, str, yychar, yychar + str.Length));
    }
}
    } // end accept action #9

private const int YYINITIAL = 0;
private const int GROUPNAME = 1;
private static int[]! yy_state_dtrans = new int[]
  {   0,
  8
  };
private void yybegin (int mystate)
  {
  yy_lexical_state = mystate;
  }

private char yy_advance ()
  {
  int next_read;
  int i;
  int j;

  if (yy_buffer_index < yy_buffer_read) {
    return yy_buffer[yy_buffer_index++];
    }

  if (0 != yy_buffer_start) {
    i = yy_buffer_start;
    j = 0;
    while (i < yy_buffer_read) {
      yy_buffer[j] = yy_buffer[i];
      i++;
      j++;
      }
    yy_buffer_end = yy_buffer_end - yy_buffer_start;
    yy_buffer_start = 0;
    yy_buffer_read = j;
    yy_buffer_index = j;
    next_read = yy_reader.Read(yy_buffer,yy_buffer_read,
                  yy_buffer.Length - yy_buffer_read);
    if (next_read <= 0) {
      return (char) YY_EOF;
      }
    yy_buffer_read = yy_buffer_read + next_read;
    }
  while (yy_buffer_index >= yy_buffer_read) {
    if (yy_buffer_index >= yy_buffer.Length) {
      yy_buffer = yy_double(yy_buffer);
      }
    next_read = yy_reader.Read(yy_buffer,yy_buffer_read,
                  yy_buffer.Length - yy_buffer_read);
    if (next_read <= 0) {
      return (char) YY_EOF;
      }
    yy_buffer_read = yy_buffer_read + next_read;
    }
  return yy_buffer[yy_buffer_index++];
  }
private void yy_move_end ()
  {
  if (yy_buffer_end > yy_buffer_start &&
      '\n' == yy_buffer[yy_buffer_end-1])
    yy_buffer_end--;
  if (yy_buffer_end > yy_buffer_start &&
      '\r' == yy_buffer[yy_buffer_end-1])
    yy_buffer_end--;
  }
private bool yy_last_was_cr=false;
private void yy_mark_start ()
  {
  int i;
  for (i = yy_buffer_start; i < yy_buffer_index; i++) {
    if (yy_buffer[i] == '\n' && !yy_last_was_cr) {
      yyline++;
      }
    if (yy_buffer[i] == '\r') {
      yyline++;
      yy_last_was_cr=true;
      }
    else {
      yy_last_was_cr=false;
      }
    }
  yychar = yychar + yy_buffer_index - yy_buffer_start;
  yy_buffer_start = yy_buffer_index;
  }
private void yy_mark_end ()
  {
  yy_buffer_end = yy_buffer_index;
  }
private void yy_to_mark ()
  {
  yy_buffer_index = yy_buffer_end;
  yy_at_bol = (yy_buffer_end > yy_buffer_start) &&
    (yy_buffer[yy_buffer_end-1] == '\r' ||
    yy_buffer[yy_buffer_end-1] == '\n');
  }
internal string! yytext()
  {
  return (new string(yy_buffer,
                yy_buffer_start,
                yy_buffer_end - yy_buffer_start)
         );
  }
private int yylength ()
  {
  return yy_buffer_end - yy_buffer_start;
  }
private char[]! yy_double (char[]! buf)
  {
  int i;
  char[] newbuf;
  newbuf = new char[2*buf.Length];
  for (i = 0; i < buf.Length; i++) {
    newbuf[i] = buf[i];
    }
  return newbuf;
  }
private const int YY_E_INTERNAL = 0;
private const int YY_E_MATCH = 1;
private static string[]! yy_error_string = new string[]
  {
  "Error: Internal error.\n",
  "Error: Unmatched input.\n"
  };
private void yy_error (int code,bool fatal)
  {
  DebugStub.WriteLine("AclParser: {0}", __arglist(yy_error_string[code]));
  if (fatal) {
    throw new System.ApplicationException("An error occurred while parsing an ACL: " 
      + yy_error_string[code]);
    }
  }
private static int[]! yy_acpt = new int[]
  {
  /* 0 */   YY_NOT_ACCEPT,
  /* 1 */   YY_NO_ANCHOR,
  /* 2 */   YY_NO_ANCHOR,
  /* 3 */   YY_NO_ANCHOR,
  /* 4 */   YY_NO_ANCHOR,
  /* 5 */   YY_NO_ANCHOR,
  /* 6 */   YY_NO_ANCHOR,
  /* 7 */   YY_NO_ANCHOR,
  /* 8 */   YY_NOT_ACCEPT,
  /* 9 */   YY_NO_ANCHOR
  };
private static int[]! yy_cmap = new int[]
  {
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 2, 4, 4, 4, 4, 4, 4,
  6, 6, 6, 5, 4, 4, 5, 6,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  6, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 4, 4, 4, 4, 4,
  4, 4, 4, 3, 6, 1, 4, 4,
  0, 0
  };
private static int[]! yy_rmap = new int[]
  {
  0, 1, 2, 1, 1, 1, 1, 3,
  4, 1
  };
private static int[,]! yy_nxt = new int[,]
  {
  { 1, 2, 9, 3, 2, 4, 5 },
  { -1, -1, -1, -1, -1, -1, -1 },
  { -1, 2, -1, -1, 2, -1, -1 },
  { -1, -1, 7, 7, 7, 7, 7 },
  { 1, 6, 7, 7, 7, 7, 7 }
  };
public AclToken NextToken()
  {
  char yy_lookahead;
  int yy_anchor = YY_NO_ANCHOR;
  int yy_state = yy_state_dtrans[yy_lexical_state];
  int yy_next_state = YY_NO_STATE;
  int yy_last_accept_state = YY_NO_STATE;
  bool yy_initial = true;
  int yy_this_accept;

  yy_mark_start();
  yy_this_accept = yy_acpt[yy_state];
  if (YY_NOT_ACCEPT != yy_this_accept) {
    yy_last_accept_state = yy_state;
    yy_mark_end();
    }
  while (true) {
    if (yy_initial && yy_at_bol)
      yy_lookahead = (char) YY_BOL;
    else {
      yy_lookahead = yy_advance();
      }
    yy_next_state = yy_nxt[yy_rmap[yy_state],yy_cmap[yy_lookahead]];
    if (YY_EOF == yy_lookahead && yy_initial) {
        return null;
      }
    if (YY_F != yy_next_state) {
      yy_state = yy_next_state;
      yy_initial = false;
      yy_this_accept = yy_acpt[yy_state];
      if (YY_NOT_ACCEPT != yy_this_accept) {
        yy_last_accept_state = yy_state;
        yy_mark_end();
        }
      }
    else {
      if (YY_NO_STATE == yy_last_accept_state) {
        throw new System.ApplicationException("Lexical Error: Unmatched Input.");
        }
      else {
        yy_anchor = yy_acpt[yy_last_accept_state];
        if (0 != (YY_END & yy_anchor)) {
          yy_move_end();
          }
        yy_to_mark();
        if (yy_last_accept_state < 0) {
          if (yy_last_accept_state < 10)
            yy_error(YY_E_INTERNAL, false);
          }
        else {
          AcceptMethod m = accept_dispatch[yy_last_accept_state];
          if (m != null) {
            AclToken tmp = m();
            if (tmp != null)
              return tmp;
            }
          }
        yy_initial = true;
        yy_state = yy_state_dtrans[yy_lexical_state];
        yy_next_state = YY_NO_STATE;
        yy_last_accept_state = YY_NO_STATE;
        yy_mark_start();
        yy_this_accept = yy_acpt[yy_state];
        if (YY_NOT_ACCEPT != yy_this_accept) {
          yy_last_accept_state = yy_state;
          yy_mark_end();
          }
        }
      }
    }
  }
}

}