Example #1
0
        internal static NamespaceDecl Namespace(IdentNode name, ListNode usings, ListNode members, Symbol s)
        {
            NamespaceDecl res = new NamespaceDecl();

            res.kind    = Kind.Namespace;
            res.start   = s.pos;
            res.end     = s.endpos;
            res.name    = name;
            res.usings  = usings;
            res.members = members;
            return(res);
        }
Example #2
0
 private void FillNamespace( UmlNamespace curr, NamespaceDecl nsnode, UsingBlock usings )
 {
     if( nsnode != null && nsnode.members != null ) {
         usings = create_Usings( nsnode, usings, curr );
         foreach( Node n in nsnode.members.nodes ) {
             switch( n.kind ) {
                 case Kind.Interface:
                 case Kind.Struct:
                 case Kind.Class:
                     LoadClass( curr, (ClassDecl)n, usings );
                     break;
                 case Kind.Delegate:
                     LoadDelegate( curr, (DelegateNode)n, usings );
                     break;
                 case Kind.Enum:
                     LoadEnum( curr, (EnumDecl)n, usings );
                     break;
                 case Kind.Namespace:
                     NamespaceDecl nsdecl = (NamespaceDecl)n;
                     FillNamespace( EnsureNamespaceCreated( curr, nsdecl.name.identifier ), nsdecl, usings );
                     break;
             }
         }
     }
 }
Example #3
0
 private UsingBlock create_Usings( NamespaceDecl node, UsingBlock prev, UmlNamespace assoc_with )
 {
     if( node.usings != null && node.usings.nodes.Count > 0 ) {
         UsingBlock newblock = new UsingBlock();
         newblock.parent = prev;
         newblock.list = new ArrayList();
         newblock.aliases = new Hashtable();
         newblock.related = assoc_with;
         foreach( UsingNode un in node.usings.nodes ) {
             if( un.alias_id != null )
                 newblock.aliases[un.alias_id.identifier] = un.type_name.identifier;
             else
                 newblock.list.Add( un.type_name.identifier );
         }
         return newblock;
     }
     return prev;
 }
Example #4
0
 internal static NamespaceDecl Namespace( IdentNode name, ListNode usings, ListNode members, Symbol s )
 {
     NamespaceDecl res = new NamespaceDecl();
     res.kind = Kind.Namespace;
     res.start = s.pos;
     res.end = s.endpos;
     res.name = name;
     res.usings = usings;
     res.members = members;
     return res;
 }
Example #5
0
        public bool parse()
        {
            byte[]        token = new byte[4096];
            int           lapg_head = 0, group = 0, lapg_i, lapg_size, chr;
            lapg_symbol[] lapg_m = new lapg_symbol[1024];
            lapg_symbol   lapg_n;
            System.Text.ASCIIEncoding AE = new System.Text.ASCIIEncoding();
            lapg_place    lapg_current;

            lapg_current.offset = 0;
            lapg_current.line = 1;
            lapg_m[0].state = 0; lapg_n.lexem = lapg_n.state = 0;
            chr = buff[l++];

            do {
            lapg_n.pos = lapg_current;
            for( lapg_size = 0, lapg_i = group; lapg_i >= 0; ) {
                if( lapg_size < 4096-1 ) token[lapg_size++] = (byte)chr;
                lapg_i = lapg_lexem[lapg_i,lapg_char2no[chr]];
                if( lapg_i >= -1 && chr != 0 ) {
                    lapg_current.offset++;
                    if( chr == '\n' ) lapg_current.line++;
                    chr = buff[l++];
                }
            }
            lapg_n.endpos = lapg_current;
            token[lapg_size] = 0;

            if( lapg_i == -1 ) {
                error( System.String.Format( "invalid lexem at line {0}: `{1}`, skipped", lapg_n.pos.line, new System.String(AE.GetChars(token,0,lapg_size)) ) );
                continue;
            }

            token[lapg_size-1] = 0;
            lapg_n.lexem = -lapg_i-2;
            lapg_n.sym = null;

            switch( lapg_n.lexem ) {
                case 1:
                    #line 22 "syntax"
                     lapg_n.sym = new System.String(AE.GetChars(token,0,lapg_size-1)); break;
                case 2:
                    #line 26 "syntax"
                     lapg_n.sym = new System.String(AE.GetChars(token,0,lapg_size-1)); break;
                case 3:
                    #line 30 "syntax"
                     lapg_n.sym = new System.String(AE.GetChars(token,0,lapg_size-1)); break;
                case 4:
                    #line 33 "syntax"
                     lapg_n.sym = new System.String(AE.GetChars(token,0,lapg_size-1)); break;
                case 5:
                    #line 34 "syntax"
                     lapg_n.sym = new System.String(AE.GetChars(token,0,lapg_size-1)); break;
                case 6:
                    #line 38 "syntax"
                     lapg_n.sym = "abstract"; break;
                case 7:
                    #line 39 "syntax"
                     lapg_n.sym = "as"; break;
                case 8:
                    #line 40 "syntax"
                     lapg_n.sym = "base"; break;
                case 9:
                    #line 41 "syntax"
                     lapg_n.sym = "bool"; break;
                case 10:
                    #line 42 "syntax"
                     lapg_n.sym = "break"; break;
                case 11:
                    #line 43 "syntax"
                     lapg_n.sym = "byte"; break;
                case 12:
                    #line 44 "syntax"
                     lapg_n.sym = "case"; break;
                case 13:
                    #line 45 "syntax"
                     lapg_n.sym = "catch"; break;
                case 14:
                    #line 46 "syntax"
                     lapg_n.sym = "char"; break;
                case 15:
                    #line 47 "syntax"
                     lapg_n.sym = "checked"; break;
                case 16:
                    #line 48 "syntax"
                     lapg_n.sym = "class"; break;
                case 17:
                    #line 49 "syntax"
                     lapg_n.sym = "const"; break;
                case 18:
                    #line 50 "syntax"
                     lapg_n.sym = "continue"; break;
                case 19:
                    #line 51 "syntax"
                     lapg_n.sym = "decimal"; break;
                case 20:
                    #line 52 "syntax"
                     lapg_n.sym = "default"; break;
                case 21:
                    #line 53 "syntax"
                     lapg_n.sym = "delegate"; break;
                case 22:
                    #line 54 "syntax"
                     lapg_n.sym = "do"; break;
                case 23:
                    #line 55 "syntax"
                     lapg_n.sym = "double"; break;
                case 24:
                    #line 56 "syntax"
                     lapg_n.sym = "else"; break;
                case 25:
                    #line 57 "syntax"
                     lapg_n.sym = "enum"; break;
                case 26:
                    #line 58 "syntax"
                     lapg_n.sym = "event"; break;
                case 27:
                    #line 59 "syntax"
                     lapg_n.sym = "explicit"; break;
                case 28:
                    #line 60 "syntax"
                     lapg_n.sym = "extern"; break;
                case 29:
                    #line 61 "syntax"
                     lapg_n.sym = "false"; break;
                case 30:
                    #line 62 "syntax"
                     lapg_n.sym = "finally"; break;
                case 31:
                    #line 63 "syntax"
                     lapg_n.sym = "fixed"; break;
                case 32:
                    #line 64 "syntax"
                     lapg_n.sym = "float"; break;
                case 33:
                    #line 65 "syntax"
                     lapg_n.sym = "for"; break;
                case 34:
                    #line 66 "syntax"
                     lapg_n.sym = "foreach"; break;
                case 35:
                    #line 67 "syntax"
                     lapg_n.sym = "goto"; break;
                case 36:
                    #line 68 "syntax"
                     lapg_n.sym = "if"; break;
                case 37:
                    #line 69 "syntax"
                     lapg_n.sym = "implicit"; break;
                case 38:
                    #line 70 "syntax"
                     lapg_n.sym = "in"; break;
                case 39:
                    #line 71 "syntax"
                     lapg_n.sym = "int"; break;
                case 40:
                    #line 72 "syntax"
                     lapg_n.sym = "interface"; break;
                case 41:
                    #line 73 "syntax"
                     lapg_n.sym = "internal"; break;
                case 42:
                    #line 74 "syntax"
                     lapg_n.sym = "is"; break;
                case 43:
                    #line 75 "syntax"
                     lapg_n.sym = "lock"; break;
                case 44:
                    #line 76 "syntax"
                     lapg_n.sym = "long"; break;
                case 45:
                    #line 77 "syntax"
                     lapg_n.sym = "namespace"; break;
                case 46:
                    #line 78 "syntax"
                     lapg_n.sym = "new"; break;
                case 47:
                    #line 79 "syntax"
                     lapg_n.sym = "null"; break;
                case 48:
                    #line 80 "syntax"
                     lapg_n.sym = "object"; break;
                case 49:
                    #line 81 "syntax"
                     lapg_n.sym = "operator"; break;
                case 50:
                    #line 82 "syntax"
                     lapg_n.sym = "out"; break;
                case 51:
                    #line 83 "syntax"
                     lapg_n.sym = "override"; break;
                case 52:
                    #line 84 "syntax"
                     lapg_n.sym = "params"; break;
                case 53:
                    #line 85 "syntax"
                     lapg_n.sym = "private"; break;
                case 54:
                    #line 86 "syntax"
                     lapg_n.sym = "protected"; break;
                case 55:
                    #line 87 "syntax"
                     lapg_n.sym = "public"; break;
                case 56:
                    #line 88 "syntax"
                     lapg_n.sym = "readonly"; break;
                case 57:
                    #line 89 "syntax"
                     lapg_n.sym = "ref"; break;
                case 58:
                    #line 90 "syntax"
                     lapg_n.sym = "return"; break;
                case 59:
                    #line 91 "syntax"
                     lapg_n.sym = "sbyte"; break;
                case 60:
                    #line 92 "syntax"
                     lapg_n.sym = "sealed"; break;
                case 61:
                    #line 93 "syntax"
                     lapg_n.sym = "short"; break;
                case 62:
                    #line 94 "syntax"
                     lapg_n.sym = "sizeof"; break;
                case 63:
                    #line 95 "syntax"
                     lapg_n.sym = "stackalloc"; break;
                case 64:
                    #line 96 "syntax"
                     lapg_n.sym = "static"; break;
                case 65:
                    #line 97 "syntax"
                     lapg_n.sym = "string"; break;
                case 66:
                    #line 98 "syntax"
                     lapg_n.sym = "struct"; break;
                case 67:
                    #line 99 "syntax"
                     lapg_n.sym = "switch"; break;
                case 68:
                    #line 100 "syntax"
                     lapg_n.sym = "this"; break;
                case 69:
                    #line 101 "syntax"
                     lapg_n.sym = "throw"; break;
                case 70:
                    #line 102 "syntax"
                     lapg_n.sym = "true"; break;
                case 71:
                    #line 103 "syntax"
                     lapg_n.sym = "try"; break;
                case 72:
                    #line 104 "syntax"
                     lapg_n.sym = "typeof"; break;
                case 73:
                    #line 105 "syntax"
                     lapg_n.sym = "uint"; break;
                case 74:
                    #line 106 "syntax"
                     lapg_n.sym = "ulong"; break;
                case 75:
                    #line 107 "syntax"
                     lapg_n.sym = "unchecked"; break;
                case 76:
                    #line 108 "syntax"
                     lapg_n.sym = "unsafe"; break;
                case 77:
                    #line 109 "syntax"
                     lapg_n.sym = "ushort"; break;
                case 78:
                    #line 110 "syntax"
                     lapg_n.sym = "using"; break;
                case 79:
                    #line 111 "syntax"
                     lapg_n.sym = "virtual"; break;
                case 80:
                    #line 112 "syntax"
                     lapg_n.sym = "void"; break;
                case 81:
                    #line 113 "syntax"
                     lapg_n.sym = "volatile"; break;
                case 82:
                    #line 114 "syntax"
                     lapg_n.sym = "while"; break;
                case 83:
                    #line 118 "syntax"
                     lapg_n.sym = "{"; break;
                case 84:
                    #line 119 "syntax"
                     lapg_n.sym = "}"; break;
                case 85:
                    #line 120 "syntax"
                     lapg_n.sym = "["; break;
                case 86:
                    #line 121 "syntax"
                     lapg_n.sym = "]"; break;
                case 87:
                    #line 122 "syntax"
                     lapg_n.sym = "("; break;
                case 88:
                    #line 123 "syntax"
                     lapg_n.sym = ")"; break;
                case 89:
                    #line 124 "syntax"
                     lapg_n.sym = "."; break;
                case 90:
                    #line 125 "syntax"
                     lapg_n.sym = ","; break;
                case 91:
                    #line 126 "syntax"
                     lapg_n.sym = ":"; break;
                case 92:
                    #line 127 "syntax"
                     lapg_n.sym = ";"; break;
                case 93:
                    #line 128 "syntax"
                     lapg_n.sym = "+"; break;
                case 94:
                    #line 129 "syntax"
                     lapg_n.sym = "-"; break;
                case 95:
                    #line 130 "syntax"
                     lapg_n.sym = "*"; break;
                case 96:
                    #line 131 "syntax"
                     lapg_n.sym = "/"; break;
                case 97:
                    #line 132 "syntax"
                     lapg_n.sym = "%"; break;
                case 98:
                    #line 133 "syntax"
                     lapg_n.sym = "&"; break;
                case 99:
                    #line 134 "syntax"
                     lapg_n.sym = "|"; break;
                case 100:
                    #line 135 "syntax"
                     lapg_n.sym = "^"; break;
                case 101:
                    #line 136 "syntax"
                     lapg_n.sym = "!"; break;
                case 102:
                    #line 137 "syntax"
                     lapg_n.sym = "~"; break;
                case 103:
                    #line 138 "syntax"
                     lapg_n.sym = "="; break;
                case 104:
                    #line 139 "syntax"
                     lapg_n.sym = "<"; break;
                case 105:
                    #line 140 "syntax"
                     lapg_n.sym = ">"; break;
                case 106:
                    #line 141 "syntax"
                     lapg_n.sym = "?"; break;
                case 107:
                    #line 142 "syntax"
                     lapg_n.sym = "++"; break;
                case 108:
                    #line 143 "syntax"
                     lapg_n.sym = "--"; break;
                case 109:
                    #line 144 "syntax"
                     lapg_n.sym = "&&"; break;
                case 110:
                    #line 145 "syntax"
                     lapg_n.sym = "||"; break;
                case 111:
                    #line 146 "syntax"
                     lapg_n.sym = "<<"; break;
                case 112:
                    #line 147 "syntax"
                     lapg_n.sym = ">>"; break;
                case 113:
                    #line 148 "syntax"
                     lapg_n.sym = "=="; break;
                case 114:
                    #line 149 "syntax"
                     lapg_n.sym = "!="; break;
                case 115:
                    #line 150 "syntax"
                     lapg_n.sym = "<="; break;
                case 116:
                    #line 151 "syntax"
                     lapg_n.sym = ">="; break;
                case 117:
                    #line 152 "syntax"
                     lapg_n.sym = "+="; break;
                case 118:
                    #line 153 "syntax"
                     lapg_n.sym = "-="; break;
                case 119:
                    #line 154 "syntax"
                     lapg_n.sym = "*="; break;
                case 120:
                    #line 155 "syntax"
                     lapg_n.sym = "/="; break;
                case 121:
                    #line 156 "syntax"
                     lapg_n.sym = "%="; break;
                case 122:
                    #line 157 "syntax"
                     lapg_n.sym = "&="; break;
                case 123:
                    #line 158 "syntax"
                     lapg_n.sym = "|="; break;
                case 124:
                    #line 159 "syntax"
                     lapg_n.sym = "^="; break;
                case 125:
                    #line 160 "syntax"
                     lapg_n.sym = "<<="; break;
                case 126:
                    #line 161 "syntax"
                     lapg_n.sym = ">>="; break;
                case 127:
                    #line 162 "syntax"
                     lapg_n.sym = "->"; break;
                case 129:
                    #line 168 "syntax"
                     Make.Comment( new System.String(AE.GetChars(token,3,lapg_size-1)), lapg_n); continue;
                case 130:
                    #line 172 "syntax"
                     continue;
                case 131:
                    #line 174 "syntax"
                     group = 1;continue;
                case 132:
                    #line 176 "syntax"
                     continue;
                case 133:
                    #line 178 "syntax"
                     group = 0;continue;
            }

            skip_symbols:
            do {
                lapg_i = lapg_next( lapg_m[lapg_head].state, lapg_n.lexem );

                if( lapg_i >= 0 ) {
                    lapg_symbol lapg_gg;
                    lapg_gg.sym = (lapg_rlen[lapg_i]!=0)?lapg_m[lapg_head+1-lapg_rlen[lapg_i]].sym:null;
                    lapg_gg.lexem = lapg_rlex[lapg_i];
                    lapg_gg.state = 0;
                    #if DEBUG_syntax
                        System.Console.WriteLine( "reduce to {0}", lapg_syms[lapg_rlex[lapg_i]] );
                    #endif
                    lapg_gg.pos = (lapg_rlen[lapg_i]!=0)?lapg_m[lapg_head+1-lapg_rlen[lapg_i]].pos:lapg_n.pos;
                    lapg_gg.endpos = (lapg_rlen[lapg_i]!=0)?lapg_m[lapg_head].endpos:lapg_n.pos;
                    switch( lapg_i ) {
                        case 4:
                            #line 188 "syntax"
                            lapg_gg.sym = rootns = Make.Namespace( null, ((ListNode)lapg_m[lapg_head-1].sym), ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 6:
                            #line 196 "syntax"
                             lapg_gg.sym = Modifiers.New; break;
                        case 7:
                            #line 197 "syntax"
                             lapg_gg.sym = Modifiers.Public; break;
                        case 8:
                            #line 198 "syntax"
                             lapg_gg.sym = Modifiers.Protected; break;
                        case 9:
                            #line 199 "syntax"
                             lapg_gg.sym = Modifiers.Internal; break;
                        case 10:
                            #line 200 "syntax"
                             lapg_gg.sym = Modifiers.Private; break;
                        case 11:
                            #line 201 "syntax"
                             lapg_gg.sym = Modifiers.Abstract; break;
                        case 12:
                            #line 202 "syntax"
                             lapg_gg.sym = Modifiers.Sealed; break;
                        case 13:
                            #line 203 "syntax"
                             lapg_gg.sym = Modifiers.Static; break;
                        case 14:
                            #line 204 "syntax"
                             lapg_gg.sym = Modifiers.Readonly; break;
                        case 15:
                            #line 205 "syntax"
                             lapg_gg.sym = Modifiers.Virtual; break;
                        case 16:
                            #line 206 "syntax"
                             lapg_gg.sym = Modifiers.Override; break;
                        case 17:
                            #line 207 "syntax"
                             lapg_gg.sym = Modifiers.Extern; break;
                        case 18:
                            #line 208 "syntax"
                             lapg_gg.sym = Modifiers.Volatile; break;
                        case 19:
                            #line 209 "syntax"
                             lapg_gg.sym = Modifiers.Unsafe; break;
                        case 20:
                            #line 213 "syntax"
                             lapg_gg.sym = Make.Modifiers( ((int)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 21:
                            #line 214 "syntax"
                             Make.AddModifier( ((ModifiersNode)lapg_gg.sym), ((int)lapg_m[lapg_head-0].sym), lapg_m[lapg_head-0].pos.offset, lapg_gg );break;
                        case 24:
                            #line 222 "syntax"
                             lapg_gg.sym = Make.Literal( LiteralNode.Type.Integer, (string)lapg_m[lapg_head-0].sym, lapg_gg ); break;
                        case 25:
                            #line 223 "syntax"
                             lapg_gg.sym = Make.Literal( LiteralNode.Type.Float, (string)lapg_m[lapg_head-0].sym, lapg_gg ); break;
                        case 26:
                            #line 224 "syntax"
                             lapg_gg.sym = Make.Literal( LiteralNode.Type.Char, (string)lapg_m[lapg_head-0].sym, lapg_gg ); break;
                        case 27:
                            #line 225 "syntax"
                             lapg_gg.sym = Make.Literal( LiteralNode.Type.String, (string)lapg_m[lapg_head-0].sym, lapg_gg ); break;
                        case 28:
                            #line 226 "syntax"
                             lapg_gg.sym = Make.Literal( LiteralNode.Type.Boolean, (string)lapg_m[lapg_head-0].sym, lapg_gg ); break;
                        case 29:
                            #line 227 "syntax"
                             lapg_gg.sym = Make.Literal( LiteralNode.Type.Boolean, (string)lapg_m[lapg_head-0].sym, lapg_gg ); break;
                        case 30:
                            #line 228 "syntax"
                             lapg_gg.sym = Make.Literal( LiteralNode.Type.Null, (string)lapg_m[lapg_head-0].sym, lapg_gg ); break;
                        case 31:
                            #line 236 "syntax"
                             lapg_gg.sym = Make.Ident( ((string)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 32:
                            #line 237 "syntax"
                             Make.AddIdent( ((IdentNode)lapg_gg.sym), "."+((string)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 33:
                            #line 241 "syntax"
                             lapg_gg.sym = Make.Ident( ((string)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 34:
                            #line 248 "syntax"
                             lapg_gg.sym = Make.TypeName( ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 42:
                            #line 265 "syntax"
                             lapg_gg.sym = Util.type_from_expr( ((ExprNode)lapg_m[lapg_head-0].sym) ); break;
                        case 44:
                            #line 267 "syntax"
                             lapg_gg.sym = Make.ListArrayType( ((TypeNode)lapg_m[lapg_head-1].sym), ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 46:
                            #line 272 "syntax"
                             lapg_gg.sym = Make.PointerType( ((TypeNode)lapg_gg.sym), lapg_gg );break;
                        case 47:
                            #line 273 "syntax"
                             lapg_gg.sym = Make.OneArrayType( ((TypeNode)lapg_gg.sym), ((DimSpecNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 48:
                            #line 277 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._object, lapg_gg );break;
                        case 49:
                            #line 278 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._string, lapg_gg );break;
                        case 50:
                            #line 279 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._bool, lapg_gg );break;
                        case 51:
                            #line 280 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._decimal, lapg_gg );break;
                        case 52:
                            #line 281 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._float, lapg_gg );break;
                        case 53:
                            #line 282 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._double, lapg_gg );break;
                        case 55:
                            #line 284 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._void, lapg_gg );break;
                        case 56:
                            #line 288 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._sbyte, lapg_gg );break;
                        case 57:
                            #line 289 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._byte, lapg_gg );break;
                        case 58:
                            #line 290 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._short, lapg_gg );break;
                        case 59:
                            #line 291 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._ushort, lapg_gg );break;
                        case 60:
                            #line 292 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._int, lapg_gg );break;
                        case 61:
                            #line 293 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._uint, lapg_gg );break;
                        case 62:
                            #line 294 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._long, lapg_gg );break;
                        case 63:
                            #line 295 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._ulong, lapg_gg );break;
                        case 64:
                            #line 296 "syntax"
                             lapg_gg.sym = Make.BaseType( BaseTypes._char, lapg_gg );break;
                        case 65:
                            #line 300 "syntax"
                             lapg_gg.sym = Make.PointerType( ((TypeNode)lapg_m[lapg_head-1].sym), lapg_gg );break;
                        case 66:
                            #line 306 "syntax"
                             lapg_gg.sym = Make.List( ((Node)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 67:
                            #line 307 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((Node)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 69:
                            #line 312 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.Ref, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 70:
                            #line 313 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.Out, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 76:
                            #line 325 "syntax"
                             lapg_gg.sym = Make.Expr( Kind.This, lapg_gg ); break;
                        case 77:
                            #line 326 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.BaseDot, ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 78:
                            #line 327 "syntax"
                             lapg_gg.sym = Make.ExprAndList( Kind.BaseIndex, null, ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 79:
                            #line 328 "syntax"
                             lapg_gg.sym = Make.TypeAndList( Kind.TypeOf, ((TypeNode)lapg_m[lapg_head-1].sym), null, lapg_gg ); break;
                        case 80:
                            #line 329 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.Checked, ((ExprNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 81:
                            #line 330 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.Unchecked, ((ExprNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 82:
                            #line 331 "syntax"
                             lapg_gg.sym = Make.TypeAndList( Kind.SizeOf, ((TypeNode)lapg_m[lapg_head-1].sym), null, lapg_gg ); break;
                        case 83:
                            #line 332 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.PostInc, ((ExprNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 84:
                            #line 333 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.PostDec, ((ExprNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 85:
                            #line 334 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Arrow, ((ExprNode)lapg_m[lapg_head-2].sym), ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 86:
                            #line 335 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Dot, ((ExprNode)lapg_m[lapg_head-2].sym), ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 87:
                            #line 336 "syntax"
                             lapg_gg.sym = Make.ExprAndType( Kind.TypeDot, ((IdentNode)lapg_m[lapg_head-0].sym), ((TypeNode)lapg_m[lapg_head-2].sym), lapg_gg ); break;
                        case 90:
                            #line 337 "syntax"
                             lapg_gg.sym = Make.ExprAndList( Kind.Call, ((ExprNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 91:
                            #line 338 "syntax"
                             lapg_gg.sym = Make.ExprAndList( Kind.Index, ((ExprNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 92:
                            #line 339 "syntax"
                             lapg_gg.sym = Make.TypeExpr( ((ExprNode)lapg_gg.sym), ((DimSpecNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 98:
                            #line 344 "syntax"
                             lapg_gg.sym = Make.NewArray( ((TypeNode)lapg_m[lapg_head-5].sym), ((ListNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 99:
                            #line 345 "syntax"
                             lapg_gg.sym = Make.NewArray( ((TypeNode)lapg_m[lapg_head-1].sym), null, null, ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 100:
                            #line 349 "syntax"
                             lapg_gg.sym = Make.TypeAndList( Kind.obj_or_deleg_creation, ((TypeNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 102:
                            #line 354 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.UnPlus, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 103:
                            #line 355 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.UnMinus, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 104:
                            #line 356 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.Not, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 105:
                            #line 357 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.BitNot, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 106:
                            #line 358 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.PreInc, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 107:
                            #line 359 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.PreDec, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 109:
                            #line 365 "syntax"
                            lapg_gg.sym = lapg_m[lapg_head-1].sym;
                            // HACK
                            if( CastExpr(((ExprNode)lapg_m[lapg_head-1].sym),lapg_n) ) {
                                // perform reduce
                                for( int e = lapg_rlen[lapg_i]; e > 0; e-- ) lapg_m[lapg_head--].sym = null;
                                lapg_m[++lapg_head] = lapg_gg;
                                lapg_m[lapg_head].state = lapg_state_sym( lapg_m[lapg_head-1].state, lapg_gg.lexem );
                                if( lapg_m[lapg_head].state != -1 ) {
                                    // shift cast_token (if possible)
                                    lapg_gg.lexem = (int)Tokens.cast_token;
                                    lapg_gg.sym = null;
                                    lapg_gg.state = lapg_state_sym( lapg_m[lapg_head].state, lapg_gg.lexem );
                                    lapg_gg.pos = lapg_gg.endpos = lapg_n.pos;
                                    if( lapg_gg.state != -1 )
                                        lapg_m[++lapg_head] = lapg_gg;
                                }
                                // skip default reduce code
                                continue;
                            }
                            break;
                        case 110:
                            #line 388 "syntax"
                             lapg_gg.sym = Make.ExprAndType( Kind.Cast, ((ExprNode)lapg_m[lapg_head-0].sym), Util.type_from_expr(((ExprNode)lapg_m[lapg_head-2].sym)), lapg_gg ); break;
                        case 111:
                            #line 389 "syntax"
                             lapg_gg.sym = Make.ExprAndType( Kind.Cast, ((ExprNode)lapg_m[lapg_head-0].sym), ((TypeNode)lapg_m[lapg_head-2].sym), lapg_gg ); break;
                        case 113:
                            #line 394 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Mult, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 114:
                            #line 395 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Div, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 115:
                            #line 396 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Mod, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 117:
                            #line 401 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Plus, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 118:
                            #line 402 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Minus, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 120:
                            #line 407 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Shl, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 121:
                            #line 408 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Shr, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 123:
                            #line 413 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Less, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 124:
                            #line 414 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Greater, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 125:
                            #line 415 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.LessEq, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 126:
                            #line 416 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.GreaterEq, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 127:
                            #line 417 "syntax"
                             lapg_gg.sym = Make.ExprAndType( Kind.Is, ((ExprNode)lapg_m[lapg_head-2].sym), ((TypeNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 128:
                            #line 418 "syntax"
                             lapg_gg.sym = Make.ExprAndType( Kind.As, ((ExprNode)lapg_m[lapg_head-2].sym), ((TypeNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 130:
                            #line 423 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Equal, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 131:
                            #line 424 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.NotEqual, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 133:
                            #line 429 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.And, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 135:
                            #line 434 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Xor, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 137:
                            #line 439 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.Or, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 139:
                            #line 444 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.AndAnd, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 141:
                            #line 449 "syntax"
                             lapg_gg.sym = Make.Binary( Kind.OrOr, ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 143:
                            #line 454 "syntax"
                             lapg_gg.sym = Make.Triplex( ((ExprNode)lapg_m[lapg_head-4].sym), ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 144:
                            #line 458 "syntax"
                             lapg_gg.sym = Make.Assign( ((Kind)lapg_m[lapg_head-1].sym), ((ExprNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 145:
                            #line 462 "syntax"
                             lapg_gg.sym = (int)Kind.Assign; break;
                        case 146:
                            #line 463 "syntax"
                             lapg_gg.sym = (int)Kind.PlusEq; break;
                        case 147:
                            #line 464 "syntax"
                             lapg_gg.sym = (int)Kind.MinusEq; break;
                        case 148:
                            #line 465 "syntax"
                             lapg_gg.sym = (int)Kind.MultEq; break;
                        case 149:
                            #line 466 "syntax"
                             lapg_gg.sym = (int)Kind.DivEq; break;
                        case 150:
                            #line 467 "syntax"
                             lapg_gg.sym = (int)Kind.ModEq; break;
                        case 151:
                            #line 468 "syntax"
                             lapg_gg.sym = (int)Kind.AndEq; break;
                        case 152:
                            #line 469 "syntax"
                             lapg_gg.sym = (int)Kind.OrEq; break;
                        case 153:
                            #line 470 "syntax"
                             lapg_gg.sym = (int)Kind.XorEq; break;
                        case 154:
                            #line 471 "syntax"
                             lapg_gg.sym = (int)Kind.ShlEq; break;
                        case 155:
                            #line 472 "syntax"
                             lapg_gg.sym = (int)Kind.ShrEq; break;
                        case 156:
                            #line 476 "syntax"
                             lapg_gg.sym = Make.List( ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 157:
                            #line 477 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 161:
                            #line 492 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Label, null, ((IdentNode)lapg_m[lapg_head-2].sym), ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 166:
                            #line 500 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Expr, ((ExprNode)lapg_m[lapg_head-1].sym), null, null, null, null, lapg_gg ); break;
                        case 167:
                            #line 501 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Empty, null, null, null, null, null, lapg_gg ); break;
                        case 168:
                            #line 503 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.If, ((ExprNode)lapg_m[lapg_head-2].sym), null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 169:
                            #line 504 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.If, ((ExprNode)lapg_m[lapg_head-4].sym), null, ((StatementNode)lapg_m[lapg_head-2].sym), ((StatementNode)lapg_m[lapg_head-0].sym), null, lapg_gg ); break;
                        case 170:
                            #line 505 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Switch, ((ExprNode)lapg_m[lapg_head-2].sym), null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 171:
                            #line 506 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.While, ((ExprNode)lapg_m[lapg_head-2].sym), null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 172:
                            #line 507 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.DoWhile, ((ExprNode)lapg_m[lapg_head-2].sym), null, ((StatementNode)lapg_m[lapg_head-5].sym), null, null, lapg_gg ); break;
                        case 179:
                            #line 510 "syntax"
                                                                            { lapg_gg.sym = Make.Statement( Kind.For, ((ExprNode)lapg_m[lapg_head-4].sym), null, ((StatementNode)lapg_m[lapg_head-6].sym), ((StatementNode)lapg_m[lapg_head-0].sym), ((ListNode)lapg_m[lapg_head-2].sym), lapg_gg ); break; }
                        case 180:
                            #line 513 "syntax"
                                                                            { lapg_gg.sym = Make.TypedStatement( Kind.ForEach, ((ExprNode)lapg_m[lapg_head-2].sym), ((IdentNode)lapg_m[lapg_head-4].sym), ((StatementNode)lapg_m[lapg_head-0].sym), null, null, ((TypeNode)lapg_m[lapg_head-5].sym), lapg_gg ); break; }
                        case 181:
                            #line 515 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Break, null, null, null, null, null, lapg_gg ); break;
                        case 182:
                            #line 516 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Continue, null, null, null, null, null, lapg_gg ); break;
                        case 183:
                            #line 517 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Goto, null, ((IdentNode)lapg_m[lapg_head-1].sym), null, null, null, lapg_gg ); break;
                        case 184:
                            #line 518 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.GotoCase, ((ExprNode)lapg_m[lapg_head-1].sym), null, null, null, null, lapg_gg ); break;
                        case 185:
                            #line 519 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.GotoDefault, null, null, null, null, null, lapg_gg ); break;
                        case 186:
                            #line 520 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Return, ((ExprNode)lapg_m[lapg_head-1].sym), null, null, null, null, lapg_gg ); break;
                        case 187:
                            #line 521 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Throw, ((ExprNode)lapg_m[lapg_head-1].sym), null, null, null, null, lapg_gg ); break;
                        case 189:
                            #line 524 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Lock, ((ExprNode)lapg_m[lapg_head-2].sym), null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 190:
                            #line 526 "syntax"
                                                                            { lapg_gg.sym = Make.Statement( Kind.UsingSt, null, null, ((StatementNode)lapg_m[lapg_head-2].sym), ((StatementNode)lapg_m[lapg_head-0].sym), null, lapg_gg ); break; }
                        case 191:
                            #line 527 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Unsafe, null, null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 192:
                            #line 528 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.CheckedSt, null, null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 193:
                            #line 529 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.UncheckedSt, null, null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 196:
                            #line 533 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Block, null, null, null, null, ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 197:
                            #line 537 "syntax"
                             lapg_gg.sym = Make.List( ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 198:
                            #line 538 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 199:
                            #line 542 "syntax"
                             lapg_gg.sym = Make.TypedStatement( Kind.VarDecl, null, null, null, null, ((ListNode)lapg_m[lapg_head-0].sym), ((TypeNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 200:
                            #line 546 "syntax"
                             lapg_gg.sym = Make.TypedStatement( Kind.ConstDecl, null, null, null, null, ((ListNode)lapg_m[lapg_head-0].sym), ((TypeNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 201:
                            #line 550 "syntax"
                             lapg_gg.sym = Make.List( ((ConstantNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 202:
                            #line 551 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((ConstantNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 203:
                            #line 555 "syntax"
                             lapg_gg.sym = Make.Constant( ((IdentNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 204:
                            #line 559 "syntax"
                             lapg_gg.sym = Make.ExprAndList( Kind.Call, ((ExprNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 207:
                            #line 562 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.PostInc, ((ExprNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 208:
                            #line 563 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.PostDec, ((ExprNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 209:
                            #line 564 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.PreInc, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 210:
                            #line 565 "syntax"
                             lapg_gg.sym = Make.Unary( Kind.PreDec, ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 213:
                            #line 569 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Block, null, null, null, null, ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 214:
                            #line 573 "syntax"
                             lapg_gg.sym = Make.List( ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 215:
                            #line 574 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 216:
                            #line 578 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.SwitchSect, null, null, ((StatementNode)lapg_m[lapg_head-0].sym), null, ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 217:
                            #line 582 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.StmtList, null, null, null, null, ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 218:
                            #line 586 "syntax"
                             lapg_gg.sym = Make.List( ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 219:
                            #line 587 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 220:
                            #line 591 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.CaseLabel, ((ExprNode)lapg_m[lapg_head-1].sym), null, null, null, null, lapg_gg ); break;
                        case 221:
                            #line 592 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Default, null, null, null, null, null, lapg_gg ); break;
                        case 223:
                            #line 597 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.ExprList, null, null, null, null, ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 224:
                            #line 601 "syntax"
                             lapg_gg.sym = Make.List( ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 225:
                            #line 602 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 226:
                            #line 606 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Try, null, null, ((StatementNode)lapg_m[lapg_head-1].sym), null, ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 228:
                            #line 611 "syntax"
                             lapg_gg.sym = Make.List( ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 229:
                            #line 612 "syntax"
                             Make.AddList( ((ListNode)lapg_m[lapg_head-1].sym), ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 231:
                            #line 617 "syntax"
                             Make.AddList( ((ListNode)lapg_m[lapg_head-1].sym), ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 232:
                            #line 618 "syntax"
                             lapg_gg.sym = Make.List( ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 233:
                            #line 622 "syntax"
                             lapg_gg.sym = Make.List( ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 234:
                            #line 623 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 237:
                            #line 628 "syntax"
                                                                            { lapg_gg.sym = Make.TypedStatement( Kind.Catch, null, ((IdentNode)lapg_m[lapg_head-2].sym), ((StatementNode)lapg_m[lapg_head-0].sym), null, null, ((TypeNode)lapg_m[lapg_head-3].sym), lapg_gg ); break; }
                        case 238:
                            #line 632 "syntax"
                             lapg_gg.sym = Make.TypedStatement( Kind.Catch, null, null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, null, lapg_gg ); break;
                        case 239:
                            #line 636 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Finally, null, null, ((StatementNode)lapg_m[lapg_head-0].sym), null, null, lapg_gg ); break;
                        case 241:
                            #line 641 "syntax"
                             lapg_gg.sym = Make.Statement( Kind.Expr, ((ExprNode)lapg_m[lapg_head-0].sym), null, null, null, null, lapg_gg ); break;
                        case 242:
                            #line 650 "syntax"
                            lapg_gg.sym = Make.Namespace( ((IdentNode)lapg_m[lapg_head-5].sym), ((ListNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-2].sym), lapg_gg ); break;
                        case 243:
                            #line 654 "syntax"
                             lapg_gg.sym = Make.List( ((Node)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 244:
                            #line 655 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((Node)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 245:
                            #line 659 "syntax"
                             lapg_gg.sym = Make.Using( Kind.UsingAlias, ((IdentNode)lapg_m[lapg_head-3].sym), ((IdentNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 246:
                            #line 660 "syntax"
                             lapg_gg.sym = Make.Using( Kind.UsingDir, null, ((IdentNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 247:
                            #line 664 "syntax"
                             lapg_gg.sym = Make.List( ((Node)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 248:
                            #line 665 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((Node)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 262:
                            #line 685 "syntax"
                            lapg_gg.sym = Make.Class( Kind.Class, ((ListNode)lapg_m[lapg_head-6].sym), ((ModifiersNode)lapg_m[lapg_head-5].sym), ((IdentNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-2].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 263:
                            #line 689 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-0].sym; Make.Pos( ref lapg_gg ); break;
                        case 264:
                            #line 693 "syntax"
                             lapg_gg.sym = Make.List( ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 265:
                            #line 694 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 268:
                            #line 698 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-1].sym; Make.Pos( ref lapg_gg ); break;
                        case 269:
                            #line 702 "syntax"
                             lapg_gg.sym = Make.List( ((DeclNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 270:
                            #line 703 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((DeclNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 281:
                            #line 723 "syntax"
                            lapg_gg.sym = Make.Fields( Kind.Const, ((ListNode)lapg_m[lapg_head-4].sym), ((ModifiersNode)lapg_m[lapg_head-3].sym), ((TypeNode)lapg_m[lapg_head-2].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 282:
                            #line 727 "syntax"
                             lapg_gg.sym = Make.Modifiers( (int)Modifiers.Const, lapg_gg );break;
                        case 283:
                            #line 728 "syntax"
                             Make.AddModifier( ((ModifiersNode)lapg_m[lapg_head-1].sym), (int)Modifiers.Const, lapg_m[lapg_head-0].pos.offset, lapg_gg );break;
                        case 284:
                            #line 733 "syntax"
                            lapg_gg.sym = Make.Fields( Kind.Fields, ((ListNode)lapg_m[lapg_head-4].sym), ((ModifiersNode)lapg_m[lapg_head-3].sym), ((TypeNode)lapg_m[lapg_head-2].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 285:
                            #line 737 "syntax"
                             lapg_gg.sym = Make.List( ((VariableNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 286:
                            #line 738 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((VariableNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 287:
                            #line 742 "syntax"
                             lapg_gg.sym = Make.Variable( ((IdentNode)lapg_m[lapg_head-0].sym), null, lapg_gg ); break;
                        case 288:
                            #line 743 "syntax"
                             lapg_gg.sym = Make.Variable( ((IdentNode)lapg_m[lapg_head-2].sym), ((InitializerNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 289:
                            #line 747 "syntax"
                             lapg_gg.sym = Make.Initializer( Kind.ExprInit, ((ExprNode)lapg_m[lapg_head-0].sym), null, lapg_gg ); break;
                        case 290:
                            #line 748 "syntax"
                             lapg_gg.sym = Make.Initializer( Kind.ArrayInit, null, ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 293:
                            #line 755 "syntax"
                            lapg_gg.sym = Make.Method( Kind.Method, ((ListNode)lapg_m[lapg_head-7].sym), ((ModifiersNode)lapg_m[lapg_head-6].sym), ((IdentNode)lapg_m[lapg_head-4].sym), ((TypeNode)lapg_m[lapg_head-5].sym), ((ListNode)lapg_m[lapg_head-2].sym), ((StatementNode)lapg_m[lapg_head-0].sym), null, lapg_gg );break;
                        case 294:
                            #line 759 "syntax"
                             lapg_gg.sym = Make.Ident( ((string)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 295:
                            #line 760 "syntax"
                             Make.AddIdent( ((IdentNode)lapg_m[lapg_head-2].sym), "."+((string)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 297:
                            #line 765 "syntax"
                             Make.AddList( ((ListNode)lapg_m[lapg_head-2].sym), ((ParameterNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 298:
                            #line 766 "syntax"
                             lapg_gg.sym = Make.List( ((ParameterNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 299:
                            #line 770 "syntax"
                             lapg_gg.sym = Make.List( ((ParameterNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 300:
                            #line 771 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((ParameterNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 303:
                            #line 776 "syntax"
                            lapg_gg.sym = Make.Parameter( ((ListNode)lapg_m[lapg_head-3].sym), ((ModifiersNode)lapg_m[lapg_head-2].sym), ((TypeNode)lapg_m[lapg_head-1].sym), ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 304:
                            #line 780 "syntax"
                             lapg_gg.sym = Make.Modifiers( (int)Modifiers.Ref, lapg_gg );break;
                        case 305:
                            #line 781 "syntax"
                             lapg_gg.sym = Make.Modifiers( (int)Modifiers.Out, lapg_gg );break;
                        case 306:
                            #line 785 "syntax"
                             lapg_gg.sym = Make.Modifiers( (int)Modifiers.Params, lapg_gg );break;
                        case 307:
                            #line 790 "syntax"
                            lapg_gg.sym = Make.Parameter( ((ListNode)lapg_m[lapg_head-3].sym), ((ModifiersNode)lapg_m[lapg_head-2].sym), ((TypeNode)lapg_m[lapg_head-1].sym), ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 308:
                            #line 797 "syntax"
                            lapg_gg.sym = Make.Property( ((ListNode)lapg_m[lapg_head-6].sym), ((ModifiersNode)lapg_m[lapg_head-5].sym), ((TypeNode)lapg_m[lapg_head-4].sym), ((IdentNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 311:
                            #line 802 "syntax"
                            lapg_gg.sym = Make.List( ((AccessorNode)lapg_m[lapg_head-1].sym), lapg_gg );
                            if( ((AccessorNode)lapg_m[lapg_head-0].sym) != null )
                                Make.AddList( ((ListNode)lapg_gg.sym), ((AccessorNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 312:
                            #line 808 "syntax"
                             lapg_gg.sym = Make.Accessor( ((ListNode)lapg_m[lapg_head-2].sym), ((IdentNode)lapg_m[lapg_head-1].sym), ((StatementNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 314:
                            #line 813 "syntax"
                             lapg_gg.sym = null; break;
                        case 315:
                            #line 818 "syntax"
                            lapg_gg.sym = Make.Event( Kind.EventVars, ((ListNode)lapg_m[lapg_head-5].sym), ((ModifiersNode)lapg_m[lapg_head-4].sym), ((TypeNode)lapg_m[lapg_head-2].sym), null, null, ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 316:
                            #line 821 "syntax"
                            lapg_gg.sym = Make.Event( Kind.EventWithAccessors, ((ListNode)lapg_m[lapg_head-7].sym), ((ModifiersNode)lapg_m[lapg_head-6].sym), ((TypeNode)lapg_m[lapg_head-4].sym), ((IdentNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), null, lapg_gg ); break;
                        case 317:
                            #line 826 "syntax"
                            lapg_gg.sym = Make.Indexer( ((ListNode)lapg_m[lapg_head-9].sym), ((ModifiersNode)lapg_m[lapg_head-8].sym), ((TypeNode)lapg_m[lapg_head-7].sym), ((IdentNode)lapg_m[lapg_head-6].sym), ((ListNode)lapg_m[lapg_head-4].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 318:
                            #line 830 "syntax"
                             lapg_gg.sym = Make.Ident( "this", lapg_gg ); break;
                        case 319:
                            #line 831 "syntax"
                             Make.AddIdent( ((IdentNode)lapg_m[lapg_head-2].sym), ".this", lapg_gg ); break;
                        case 320:
                            #line 838 "syntax"
                            lapg_gg.sym = ((MethodDecl)lapg_m[lapg_head-1].sym);
                            ((MethodDecl)lapg_m[lapg_head-1].sym).attributes = ((ListNode)lapg_m[lapg_head-3].sym);
                            if( ((MethodDecl)lapg_m[lapg_head-1].sym).modifiers == null )
                                ((MethodDecl)lapg_m[lapg_head-1].sym).modifiers = ((ModifiersNode)lapg_m[lapg_head-2].sym);
                            else if( ((ModifiersNode)lapg_m[lapg_head-2].sym) != null ) {
                                ((MethodDecl)lapg_m[lapg_head-1].sym).modifiers = Make.SumModifiers( ((ModifiersNode)lapg_m[lapg_head-2].sym), ((MethodDecl)lapg_m[lapg_head-1].sym).modifiers );
                            }
                            ((MethodDecl)lapg_m[lapg_head-1].sym).body = ((StatementNode)lapg_m[lapg_head-0].sym);
                            Make.Pos( ref lapg_gg ); break;
                        case 323:
                            #line 855 "syntax"
                             lapg_gg.sym = Make.Parameter( null, null, ((TypeNode)lapg_m[lapg_head-1].sym), ((IdentNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 324:
                            #line 860 "syntax"
                            lapg_gg.sym = Make.Operator( null, ((TypeNode)lapg_m[lapg_head-4].sym), ((IdentNode)lapg_m[lapg_head-3].sym), ((ParameterNode)lapg_m[lapg_head-1].sym), null, lapg_gg ); break;
                        case 325:
                            #line 863 "syntax"
                            lapg_gg.sym = Make.Operator( null, ((TypeNode)lapg_m[lapg_head-6].sym), ((IdentNode)lapg_m[lapg_head-5].sym), ((ParameterNode)lapg_m[lapg_head-3].sym), ((ParameterNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 326:
                            #line 867 "syntax"
                             lapg_gg.sym = Make.Ident( "operator " + ((string)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 349:
                            #line 876 "syntax"
                            lapg_gg.sym = Make.Operator( ((ModifiersNode)lapg_m[lapg_head-5].sym), ((TypeNode)lapg_m[lapg_head-3].sym), null, ((ParameterNode)lapg_m[lapg_head-1].sym), null, lapg_gg ); break;
                        case 350:
                            #line 880 "syntax"
                             lapg_gg.sym = Make.Modifiers( (int)Modifiers.Implicit, lapg_gg );break;
                        case 351:
                            #line 881 "syntax"
                             lapg_gg.sym = Make.Modifiers( (int)Modifiers.Explicit, lapg_gg );break;
                        case 354:
                            #line 888 "syntax"
                            lapg_gg.sym = Make.Method( Kind.Constructor, ((ListNode)lapg_m[lapg_head-7].sym), ((ModifiersNode)lapg_m[lapg_head-6].sym), ((IdentNode)lapg_m[lapg_head-5].sym), null, ((ListNode)lapg_m[lapg_head-3].sym), ((StatementNode)lapg_m[lapg_head-0].sym), ((ConstructorInitializerNode)lapg_m[lapg_head-1].sym), lapg_gg );break;
                        case 355:
                            #line 892 "syntax"
                             lapg_gg.sym = Make.ConstructorInitializer( Kind.ThisConstructorInit, ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 356:
                            #line 893 "syntax"
                             lapg_gg.sym = Make.ConstructorInitializer( Kind.BaseConstructorInit, ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 357:
                            #line 897 "syntax"
                             lapg_gg.sym = Make.Modifiers( (int)Modifiers.Extern, lapg_gg );break;
                        case 360:
                            #line 902 "syntax"
                            lapg_gg.sym = Make.Method( Kind.Destructor, ((ListNode)lapg_m[lapg_head-6].sym), ((ModifiersNode)lapg_m[lapg_head-5].sym), ((IdentNode)lapg_m[lapg_head-3].sym), null, null, ((StatementNode)lapg_m[lapg_head-0].sym), null, lapg_gg );break;
                        case 363:
                            #line 909 "syntax"
                            lapg_gg.sym = Make.Class( Kind.Struct, ((ListNode)lapg_m[lapg_head-6].sym), ((ModifiersNode)lapg_m[lapg_head-5].sym), ((IdentNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-2].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 364:
                            #line 913 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-0].sym; Make.Pos( ref lapg_gg ); break;
                        case 365:
                            #line 917 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-1].sym; Make.Pos( ref lapg_gg ); break;
                        case 366:
                            #line 923 "syntax"
                             lapg_gg.sym = Make.ListArrayType( ((TypeNode)lapg_m[lapg_head-1].sym), ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 367:
                            #line 927 "syntax"
                             lapg_gg.sym = Make.List( ((DimSpecNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 368:
                            #line 928 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((DimSpecNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 371:
                            #line 932 "syntax"
                             lapg_gg.sym = Make.DimSpec( ( lapg_m[lapg_head-1].sym == null ) ? 1 : ((int)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 372:
                            #line 935 "syntax"
                             lapg_gg.sym = 2; break;
                        case 373:
                            #line 936 "syntax"
                             lapg_gg.sym = ((int)lapg_gg.sym) + 1; break;
                        case 376:
                            #line 940 "syntax"
                             lapg_gg.sym = ((ListNode)lapg_m[lapg_head-1].sym); break;
                        case 377:
                            #line 941 "syntax"
                             lapg_gg.sym = ((ListNode)lapg_m[lapg_head-2].sym); break;
                        case 378:
                            #line 945 "syntax"
                             lapg_gg.sym = Make.List( ((InitializerNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 379:
                            #line 946 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((InitializerNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 382:
                            #line 953 "syntax"
                            lapg_gg.sym = Make.Class( Kind.Interface, ((ListNode)lapg_m[lapg_head-6].sym), ((ModifiersNode)lapg_m[lapg_head-5].sym), ((IdentNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-2].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 383:
                            #line 957 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-0].sym; Make.Pos( ref lapg_gg ); break;
                        case 386:
                            #line 961 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-1].sym; Make.Pos( ref lapg_gg ); break;
                        case 387:
                            #line 965 "syntax"
                             lapg_gg.sym = Make.List( ((Node)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 388:
                            #line 966 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((Node)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 391:
                            #line 971 "syntax"
                            lapg_gg.sym = Make.Method( Kind.Method, ((ListNode)lapg_m[lapg_head-7].sym), ((ModifiersNode)lapg_m[lapg_head-6].sym), ((IdentNode)lapg_m[lapg_head-4].sym), ((TypeNode)lapg_m[lapg_head-5].sym), ((ListNode)lapg_m[lapg_head-2].sym), null, null, lapg_gg );break;
                        case 392:
                            #line 974 "syntax"
                            lapg_gg.sym = Make.Property( ((ListNode)lapg_m[lapg_head-6].sym), ((ModifiersNode)lapg_m[lapg_head-5].sym), ((TypeNode)lapg_m[lapg_head-4].sym), ((IdentNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 393:
                            #line 977 "syntax"
                            lapg_gg.sym = Make.Event( Kind.EventWithAccessors, ((ListNode)lapg_m[lapg_head-5].sym), ((ModifiersNode)lapg_m[lapg_head-4].sym), ((TypeNode)lapg_m[lapg_head-2].sym), ((IdentNode)lapg_m[lapg_head-1].sym), null, null, lapg_gg ); break;
                        case 394:
                            #line 980 "syntax"
                            lapg_gg.sym = Make.Indexer( ((ListNode)lapg_m[lapg_head-9].sym), ((ModifiersNode)lapg_m[lapg_head-8].sym), ((TypeNode)lapg_m[lapg_head-7].sym), ((IdentNode)lapg_m[lapg_head-6].sym), ((ListNode)lapg_m[lapg_head-4].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 395:
                            #line 984 "syntax"
                             lapg_gg.sym = Make.Ident( "this", lapg_gg ); break;
                        case 396:
                            #line 988 "syntax"
                             lapg_gg.sym = Make.Modifiers( (int)Modifiers.New, lapg_gg );break;
                        case 399:
                            #line 993 "syntax"
                            lapg_gg.sym = Make.List( ((AccessorNode)lapg_m[lapg_head-1].sym), lapg_gg );
                            if( ((AccessorNode)lapg_m[lapg_head-0].sym) != null )
                                Make.AddList( ((ListNode)lapg_gg.sym), ((AccessorNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 400:
                            #line 999 "syntax"
                             lapg_gg.sym = Make.Accessor( ((ListNode)lapg_m[lapg_head-2].sym), ((IdentNode)lapg_m[lapg_head-1].sym), null, lapg_gg ); break;
                        case 403:
                            #line 1006 "syntax"
                            lapg_gg.sym = Make.Enum( ((ListNode)lapg_m[lapg_head-6].sym), ((ModifiersNode)lapg_m[lapg_head-5].sym), ((IdentNode)lapg_m[lapg_head-3].sym), ((TypeNode)lapg_m[lapg_head-2].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 404:
                            #line 1010 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-0].sym; Make.Pos( ref lapg_gg ); break;
                        case 407:
                            #line 1014 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-1].sym; Make.Pos( ref lapg_gg ); break;
                        case 408:
                            #line 1015 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-2].sym; Make.Pos( ref lapg_gg ); break;
                        case 409:
                            #line 1019 "syntax"
                             lapg_gg.sym = Make.List( ((EnumValueNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 410:
                            #line 1020 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((EnumValueNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 411:
                            #line 1024 "syntax"
                             lapg_gg.sym = Make.EnumValue( ((ListNode)lapg_m[lapg_head-1].sym), ((IdentNode)lapg_m[lapg_head-0].sym), null, lapg_gg ); break;
                        case 412:
                            #line 1025 "syntax"
                             lapg_gg.sym = Make.EnumValue( ((ListNode)lapg_m[lapg_head-3].sym), ((IdentNode)lapg_m[lapg_head-2].sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 413:
                            #line 1032 "syntax"
                            lapg_gg.sym = Make.Delegate( ((ListNode)lapg_m[lapg_head-8].sym), ((ModifiersNode)lapg_m[lapg_head-7].sym), ((IdentNode)lapg_m[lapg_head-4].sym), ((TypeNode)lapg_m[lapg_head-5].sym), ((ListNode)lapg_m[lapg_head-2].sym), lapg_gg ); break;
                        case 414:
                            #line 1038 "syntax"
                             lapg_gg.sym = Make.List( ((AttributeSectionNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 415:
                            #line 1039 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((AttributeSectionNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 416:
                            #line 1043 "syntax"
                             lapg_gg.sym = Make.AttributeSection( ((IdentNode)lapg_m[lapg_head-4].sym), ((ListNode)lapg_m[lapg_head-2].sym), lapg_gg ); break;
                        case 417:
                            #line 1044 "syntax"
                             lapg_gg.sym = Make.AttributeSection( ((IdentNode)lapg_m[lapg_head-3].sym), ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 418:
                            #line 1045 "syntax"
                             lapg_gg.sym = Make.AttributeSection( null, ((ListNode)lapg_m[lapg_head-2].sym), lapg_gg ); break;
                        case 419:
                            #line 1046 "syntax"
                             lapg_gg.sym = Make.AttributeSection( null, ((ListNode)lapg_m[lapg_head-1].sym), lapg_gg ); break;
                        case 420:
                            #line 1050 "syntax"
                             lapg_gg.sym = Make.Ident( ((string)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 421:
                            #line 1051 "syntax"
                             lapg_gg.sym = Make.Ident( "event", lapg_gg ); break;
                        case 422:
                            #line 1052 "syntax"
                             lapg_gg.sym = Make.Ident( "return", lapg_gg ); break;
                        case 423:
                            #line 1056 "syntax"
                             lapg_gg.sym = Make.List( ((AttributeNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 424:
                            #line 1057 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((AttributeNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                        case 427:
                            #line 1061 "syntax"
                             lapg_gg.sym = Make.Attribute( ((IdentNode)lapg_m[lapg_head-1].sym), ((ListNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 431:
                            #line 1069 "syntax"
                             lapg_gg.sym = lapg_m[lapg_head-1].sym; Make.Pos( ref lapg_gg ); break;
                        case 432:
                            #line 1073 "syntax"
                             lapg_gg.sym = Make.List( ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg ); break;
                        case 433:
                            #line 1074 "syntax"
                             Make.AddList( ((ListNode)lapg_gg.sym), ((ExprNode)lapg_m[lapg_head-0].sym), lapg_gg );break;
                    }
                    for( int e = lapg_rlen[lapg_i]; e > 0; e-- ) lapg_m[lapg_head--].sym = null;
                    lapg_m[++lapg_head] = lapg_gg;
                    lapg_m[lapg_head].state = lapg_state_sym( lapg_m[lapg_head-1].state, lapg_gg.lexem );
                } else if( lapg_i == -1 ) {
                    lapg_m[++lapg_head] = lapg_n;
                    lapg_m[lapg_head].state = lapg_state_sym( lapg_m[lapg_head-1].state, lapg_n.lexem );
                    #if DEBUG_syntax
                        System.Console.WriteLine( "shift: {0} ({1})", lapg_syms[lapg_n.lexem], new System.String(AE.GetChars(token,0,lapg_size-1)) );
                    #endif
                }

            } while( lapg_i >= 0 && lapg_m[lapg_head].state != -1 );

            if( (lapg_i == -2 || lapg_m[lapg_head].state == -1) && lapg_n.lexem != 0 ) {
                break;
            }

            } while( lapg_n.lexem != 0 );

            if( lapg_m[lapg_head].state != 731-1 ) {
            error( System.String.Format( "syntax error before line {0}", lapg_n.pos.line ) );
            return false;
            };
            return true;
        }