Changeset 3001


Ignore:
Timestamp:
Apr 5, 2013, 10:51:05 PM (5 years ago)
Author:
ksherdy
Message:

Added 'BitFieldType?'. Removed specific integer types.

Location:
proto/pabloj/trunk/src/pabloB
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r2984 r3001  
    1818        public ASTNode visit(BitBlockTypeNode node);
    1919
     20        public ASTNode visit(BitFieldTypeNode node);
     21
    2022        public ASTNode visit(BlockStmtNode node);
    2123
     
    8587
    8688        public ASTNode visit(TypeDeclNode node);
    87 
    88         public ASTNode visit(Uint128TypeNode node);
    89 
    90         public ASTNode visit(Uint16TypeNode node);
    91 
    92         public ASTNode visit(Uint256TypeNode node);
    93 
    94         public ASTNode visit(Uint32TypeNode node);
    95 
    96         public ASTNode visit(Uint64TypeNode node);
    97 
    98         public ASTNode visit(Uint8TypeNode node);
    9989
    10090        public ASTNode visit(VoidTypeNode node);
     
    125115                }
    126116
     117                public ASTNode visit(BitFieldTypeNode node) {
     118                        return defaultVisit(node);
     119                }
     120
    127121                public ASTNode visit(BlockStmtNode node) {
    128122                        return defaultVisit(node);
     
    258252
    259253                public ASTNode visit(TypeDeclNode node) {
    260                         return defaultVisit(node);
    261                 }
    262 
    263                 public ASTNode visit(Uint128TypeNode node) {
    264                         return defaultVisit(node);
    265                 }
    266 
    267                 public ASTNode visit(Uint16TypeNode node) {
    268                         return defaultVisit(node);
    269                 }
    270 
    271                 public ASTNode visit(Uint256TypeNode node) {
    272                         return defaultVisit(node);
    273                 }
    274 
    275                 public ASTNode visit(Uint32TypeNode node) {
    276                         return defaultVisit(node);
    277                 }
    278 
    279                 public ASTNode visit(Uint64TypeNode node) {
    280                         return defaultVisit(node);
    281                 }
    282 
    283                 public ASTNode visit(Uint8TypeNode node) {
    284254                        return defaultVisit(node);
    285255                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r2984 r3001  
    2323        public T visitLeave(BitBlockTypeNode node, List<T> childResults);
    2424
     25        public void visitEnter(BitFieldTypeNode node);
     26        public T visitLeave(BitFieldTypeNode node, List<T> childResults);
     27
    2528        public void visitEnter(BlockStmtNode node);
    2629        public T visitLeave(BlockStmtNode node, List<T> childResults);
     
    124127        public void visitEnter(TypeDeclNode node);
    125128        public T visitLeave(TypeDeclNode node, List<T> childResults);
    126 
    127         public void visitEnter(Uint128TypeNode node);
    128         public T visitLeave(Uint128TypeNode node, List<T> childResults);
    129 
    130         public void visitEnter(Uint16TypeNode node);
    131         public T visitLeave(Uint16TypeNode node, List<T> childResults);
    132 
    133         public void visitEnter(Uint256TypeNode node);
    134         public T visitLeave(Uint256TypeNode node, List<T> childResults);
    135 
    136         public void visitEnter(Uint32TypeNode node);
    137         public T visitLeave(Uint32TypeNode node, List<T> childResults);
    138 
    139         public void visitEnter(Uint64TypeNode node);
    140         public T visitLeave(Uint64TypeNode node, List<T> childResults);
    141 
    142         public void visitEnter(Uint8TypeNode node);
    143         public T visitLeave(Uint8TypeNode node, List<T> childResults);
    144129
    145130        public void visitEnter(VoidTypeNode node);
     
    194179                }
    195180
     181                public void visitEnter(BitFieldTypeNode node) {
     182                        defaultVisitEnter(node);
     183                }
     184                public T visitLeave(BitFieldTypeNode node, List<T> childResults) {
     185                        return defaultVisitLeave(node);
     186                }
     187
    196188                public void visitEnter(BlockStmtNode node) {
    197189                        defaultVisitEnter(node);
     
    429421                }
    430422                public T visitLeave(TypeDeclNode node, List<T> childResults) {
    431                         return defaultVisitLeave(node);
    432                 }
    433 
    434                 public void visitEnter(Uint128TypeNode node) {
    435                         defaultVisitEnter(node);
    436                 }
    437                 public T visitLeave(Uint128TypeNode node, List<T> childResults) {
    438                         return defaultVisitLeave(node);
    439                 }
    440 
    441                 public void visitEnter(Uint16TypeNode node) {
    442                         defaultVisitEnter(node);
    443                 }
    444                 public T visitLeave(Uint16TypeNode node, List<T> childResults) {
    445                         return defaultVisitLeave(node);
    446                 }
    447 
    448                 public void visitEnter(Uint256TypeNode node) {
    449                         defaultVisitEnter(node);
    450                 }
    451                 public T visitLeave(Uint256TypeNode node, List<T> childResults) {
    452                         return defaultVisitLeave(node);
    453                 }
    454 
    455                 public void visitEnter(Uint32TypeNode node) {
    456                         defaultVisitEnter(node);
    457                 }
    458                 public T visitLeave(Uint32TypeNode node, List<T> childResults) {
    459                         return defaultVisitLeave(node);
    460                 }
    461 
    462                 public void visitEnter(Uint64TypeNode node) {
    463                         defaultVisitEnter(node);
    464                 }
    465                 public T visitLeave(Uint64TypeNode node, List<T> childResults) {
    466                         return defaultVisitLeave(node);
    467                 }
    468 
    469                 public void visitEnter(Uint8TypeNode node) {
    470                         defaultVisitEnter(node);
    471                 }
    472                 public T visitLeave(Uint8TypeNode node, List<T> childResults) {
    473423                        return defaultVisitLeave(node);
    474424                }
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r2984 r3001  
    1919        public void visit(BitBlockTypeNode node);
    2020
     21        public void visit(BitFieldTypeNode node);
     22
    2123        public void visit(BlockStmtNode node);
    2224
     
    8688
    8789        public void visit(TypeDeclNode node);
    88 
    89         public void visit(Uint128TypeNode node);
    90 
    91         public void visit(Uint16TypeNode node);
    92 
    93         public void visit(Uint256TypeNode node);
    94 
    95         public void visit(Uint32TypeNode node);
    96 
    97         public void visit(Uint64TypeNode node);
    98 
    99         public void visit(Uint8TypeNode node);
    10090
    10191        public void visit(VoidTypeNode node);
     
    126116                }
    127117
     118                public void visit(BitFieldTypeNode node) {
     119                        defaultVisit(node);
     120                }
     121
    128122                public void visit(BlockStmtNode node) {
    129123                        defaultVisit(node);
     
    259253
    260254                public void visit(TypeDeclNode node) {
    261                         defaultVisit(node);
    262                 }
    263 
    264                 public void visit(Uint128TypeNode node) {
    265                         defaultVisit(node);
    266                 }
    267 
    268                 public void visit(Uint16TypeNode node) {
    269                         defaultVisit(node);
    270                 }
    271 
    272                 public void visit(Uint256TypeNode node) {
    273                         defaultVisit(node);
    274                 }
    275 
    276                 public void visit(Uint32TypeNode node) {
    277                         defaultVisit(node);
    278                 }
    279 
    280                 public void visit(Uint64TypeNode node) {
    281                         defaultVisit(node);
    282                 }
    283 
    284                 public void visit(Uint8TypeNode node) {
    285255                        defaultVisit(node);
    286256                }
  • proto/pabloj/trunk/src/pabloB/ast/VoidVisitor.java

    r2984 r3001  
    2121        public void visitLeave(BitBlockTypeNode node);
    2222
     23        public void visitEnter(BitFieldTypeNode node);
     24        public void visitLeave(BitFieldTypeNode node);
     25
    2326        public void visitEnter(BlockStmtNode node);
    2427        public void visitLeave(BlockStmtNode node);
     
    122125        public void visitEnter(TypeDeclNode node);
    123126        public void visitLeave(TypeDeclNode node);
    124 
    125         public void visitEnter(Uint128TypeNode node);
    126         public void visitLeave(Uint128TypeNode node);
    127 
    128         public void visitEnter(Uint16TypeNode node);
    129         public void visitLeave(Uint16TypeNode node);
    130 
    131         public void visitEnter(Uint256TypeNode node);
    132         public void visitLeave(Uint256TypeNode node);
    133 
    134         public void visitEnter(Uint32TypeNode node);
    135         public void visitLeave(Uint32TypeNode node);
    136 
    137         public void visitEnter(Uint64TypeNode node);
    138         public void visitLeave(Uint64TypeNode node);
    139 
    140         public void visitEnter(Uint8TypeNode node);
    141         public void visitLeave(Uint8TypeNode node);
    142127
    143128        public void visitEnter(VoidTypeNode node);
     
    191176                }
    192177
     178                public void visitEnter(BitFieldTypeNode node) {
     179                        defaultVisitEnter(node);
     180                }
     181                public void visitLeave(BitFieldTypeNode node) {
     182                        defaultVisitLeave(node);
     183                }
     184
    193185                public void visitEnter(BlockStmtNode node) {
    194186                        defaultVisitEnter(node);
     
    426418                }
    427419                public void visitLeave(TypeDeclNode node) {
    428                         defaultVisitLeave(node);
    429                 }
    430 
    431                 public void visitEnter(Uint128TypeNode node) {
    432                         defaultVisitEnter(node);
    433                 }
    434                 public void visitLeave(Uint128TypeNode node) {
    435                         defaultVisitLeave(node);
    436                 }
    437 
    438                 public void visitEnter(Uint16TypeNode node) {
    439                         defaultVisitEnter(node);
    440                 }
    441                 public void visitLeave(Uint16TypeNode node) {
    442                         defaultVisitLeave(node);
    443                 }
    444 
    445                 public void visitEnter(Uint256TypeNode node) {
    446                         defaultVisitEnter(node);
    447                 }
    448                 public void visitLeave(Uint256TypeNode node) {
    449                         defaultVisitLeave(node);
    450                 }
    451 
    452                 public void visitEnter(Uint32TypeNode node) {
    453                         defaultVisitEnter(node);
    454                 }
    455                 public void visitLeave(Uint32TypeNode node) {
    456                         defaultVisitLeave(node);
    457                 }
    458 
    459                 public void visitEnter(Uint64TypeNode node) {
    460                         defaultVisitEnter(node);
    461                 }
    462                 public void visitLeave(Uint64TypeNode node) {
    463                         defaultVisitLeave(node);
    464                 }
    465 
    466                 public void visitEnter(Uint8TypeNode node) {
    467                         defaultVisitEnter(node);
    468                 }
    469                 public void visitLeave(Uint8TypeNode node) {
    470420                        defaultVisitLeave(node);
    471421                }
  • proto/pabloj/trunk/src/pabloB/lexicalAnalyzer/Lextant.java

    r2984 r3001  
    2121        DOT(".", "main"),
    2222        LROUND("(", "main"),
    23         UINT32("uint32", "main"),
    24         UINT64("uint64", "main"),
     23        BITFIELD("BitField", "main"),
    2524        RSQUARE("]", "main"),
    2625        INIT("init", "main"),
    2726        LANGLE("<", "main"),
    28         UINT128("uint128", "main"),
    2927        BITBLOCK("BitBlock", "main"),
    3028        VOID("void", "main"),
     
    3432        WHILE("while", "main"),
    3533        RETURN("return", "main"),
    36         UINT256("uint256", "main"),
    3734        ELSE("else", "main"),
    3835        FUNCTION("function", "main"),
    3936        LCURLY("{", "main"),
    40         UINT16("uint16", "main"),
    4137        LSQUARE("[", "main"),
    4238        RROUND(")", "main"),
    4339        RCURLY("}", "main"),
    4440        RANGLE(">", "main"),
    45         UINT8("uint8", "main"),
    4641        KERNEL("kernel", "main"),
    4742        VAR("var", "main"),
  • proto/pabloj/trunk/src/pabloB/parser/Parser.java

    r2988 r3001  
    4848                result.setProductionTag(1);
    4949                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    50                 while( nowReading.isLextant(Lextant.BITBLOCK, Lextant.KERNEL, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    51                         if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     50                while( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.KERNEL, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     51                        if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    5252                                {
    5353                                        ASTNode child = parseTypeDecl();
     
    7171         
    7272        public ASTNode parseTypeDecl() {
    73                 if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    74                         return syntaxErrorNode("typeDecl² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
     73                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     74                        return syntaxErrorNode("typeDecl² [BITBLOCK¹, BITFIELD¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    7575                }
    7676       
     
    348348                }
    349349                expect(Lextant.LROUND);
    350                 if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     350                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    351351                        {
    352352                                ASTNode child = parseParameterList();
     
    371371         
    372372        public ASTNode parseReturnType() {
    373                 if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    374                         return syntaxErrorNode("returnType² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
     373                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     374                        return syntaxErrorNode("returnType² [BITBLOCK¹, BITFIELD¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    375375                }
    376376       
     
    391391         
    392392        public ASTNode parseParameterList() {
    393                 if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    394                         return syntaxErrorNode("parameterList² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
     393                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     394                        return syntaxErrorNode("parameterList² [BITBLOCK¹, BITFIELD¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    395395                }
    396396       
     
    439439         
    440440        public ASTNode parseParameter() {
    441                 if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    442                         return syntaxErrorNode("parameter² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
     441                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     442                        return syntaxErrorNode("parameter² [BITBLOCK¹, BITFIELD¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    443443                }
    444444       
     
    11381138         
    11391139        public ASTNode parseType() {
    1140                 if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    1141                         return syntaxErrorNode("type² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
     1140                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     1141                        return syntaxErrorNode("type² [BITBLOCK¹, BITFIELD¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    11421142                }
    11431143       
     
    11741174                        }
    11751175                }
    1176                 else if( nowReading.isLextant(Lextant.UINT8) ) {
    1177                         {
    1178                                 ASTNode child = parseUint8Type();
    1179                                 result.appendChild(child);
    1180                                 allChildren.add(child);
    1181                         }
    1182                 }
    1183                 else if( nowReading.isLextant(Lextant.UINT16) ) {
    1184                         {
    1185                                 ASTNode child = parseUint16Type();
    1186                                 result.appendChild(child);
    1187                                 allChildren.add(child);
    1188                         }
    1189                 }
    1190                 else if( nowReading.isLextant(Lextant.UINT32) ) {
    1191                         {
    1192                                 ASTNode child = parseUint32Type();
    1193                                 result.appendChild(child);
    1194                                 allChildren.add(child);
    1195                         }
    1196                 }
    1197                 else if( nowReading.isLextant(Lextant.UINT64) ) {
    1198                         {
    1199                                 ASTNode child = parseUint64Type();
    1200                                 result.appendChild(child);
    1201                                 allChildren.add(child);
    1202                         }
    1203                 }
    1204                 else if( nowReading.isLextant(Lextant.UINT128) ) {
    1205                         {
    1206                                 ASTNode child = parseUint128Type();
    1207                                 result.appendChild(child);
    1208                                 allChildren.add(child);
    1209                         }
    1210                 }
    1211                 else if( nowReading.isLextant(Lextant.UINT256) ) {
    1212                         {
    1213                                 ASTNode child = parseUint256Type();
     1176                else if( nowReading.isLextant(Lextant.BITFIELD) ) {
     1177                        {
     1178                                ASTNode child = parseBitFieldType();
    12141179                                result.appendChild(child);
    12151180                                allChildren.add(child);
     
    12921257        }
    12931258         
    1294         public ASTNode parseUint8Type() {
    1295                 if( !(nowReading.isLextant(Lextant.UINT8)) ) {
    1296                         return syntaxErrorNode("uint8Type² [UINT8¹]");
    1297                 }
    1298        
    1299                 boolean allowCompression = true;
    1300                 ASTNode result = new Uint8TypeNode(nowReading);
     1259        public ASTNode parseBitFieldType() {
     1260                if( !(nowReading.isLextant(Lextant.BITFIELD)) ) {
     1261                        return syntaxErrorNode("bitFieldType² [BITFIELD¹]");
     1262                }
     1263       
     1264                boolean allowCompression = true;
     1265                ASTNode result = new BitFieldTypeNode(nowReading);
    13011266                result.setProductionTag(44);
    13021267                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1303                 expect(Lextant.UINT8);
    1304                 if(allowCompression) {
    1305                         return result;
    1306                 }
    1307                 return result;
    1308         }
    1309          
    1310         public ASTNode parseUint16Type() {
    1311                 if( !(nowReading.isLextant(Lextant.UINT16)) ) {
    1312                         return syntaxErrorNode("uint16Type² [UINT16¹]");
    1313                 }
    1314        
    1315                 boolean allowCompression = true;
    1316                 ASTNode result = new Uint16TypeNode(nowReading);
    1317                 result.setProductionTag(45);
    1318                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1319                 expect(Lextant.UINT16);
    1320                 if(allowCompression) {
    1321                         return result;
    1322                 }
    1323                 return result;
    1324         }
    1325          
    1326         public ASTNode parseUint32Type() {
    1327                 if( !(nowReading.isLextant(Lextant.UINT32)) ) {
    1328                         return syntaxErrorNode("uint32Type² [UINT32¹]");
    1329                 }
    1330        
    1331                 boolean allowCompression = true;
    1332                 ASTNode result = new Uint32TypeNode(nowReading);
    1333                 result.setProductionTag(46);
    1334                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1335                 expect(Lextant.UINT32);
    1336                 if(allowCompression) {
    1337                         return result;
    1338                 }
    1339                 return result;
    1340         }
    1341          
    1342         public ASTNode parseUint64Type() {
    1343                 if( !(nowReading.isLextant(Lextant.UINT64)) ) {
    1344                         return syntaxErrorNode("uint64Type² [UINT64¹]");
    1345                 }
    1346        
    1347                 boolean allowCompression = true;
    1348                 ASTNode result = new Uint64TypeNode(nowReading);
    1349                 result.setProductionTag(47);
    1350                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1351                 expect(Lextant.UINT64);
    1352                 if(allowCompression) {
    1353                         return result;
    1354                 }
    1355                 return result;
    1356         }
    1357          
    1358         public ASTNode parseUint128Type() {
    1359                 if( !(nowReading.isLextant(Lextant.UINT128)) ) {
    1360                         return syntaxErrorNode("uint128Type² [UINT128¹]");
    1361                 }
    1362        
    1363                 boolean allowCompression = true;
    1364                 ASTNode result = new Uint128TypeNode(nowReading);
    1365                 result.setProductionTag(48);
    1366                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1367                 expect(Lextant.UINT128);
    1368                 if(allowCompression) {
    1369                         return result;
    1370                 }
    1371                 return result;
    1372         }
    1373          
    1374         public ASTNode parseUint256Type() {
    1375                 if( !(nowReading.isLextant(Lextant.UINT256)) ) {
    1376                         return syntaxErrorNode("uint256Type² [UINT256¹]");
    1377                 }
    1378        
    1379                 boolean allowCompression = true;
    1380                 ASTNode result = new Uint256TypeNode(nowReading);
    1381                 result.setProductionTag(49);
    1382                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1383                 expect(Lextant.UINT256);
     1268                expect(Lextant.BITFIELD);
    13841269                if(allowCompression) {
    13851270                        return result;
     
    13951280                boolean allowCompression = true;
    13961281                ASTNode result = new BitBlockTypeNode(nowReading);
    1397                 result.setProductionTag(50);
     1282                result.setProductionTag(45);
    13981283                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13991284                expect(Lextant.BITBLOCK);
     
    14111296                boolean allowCompression = true;
    14121297                ASTNode result = new StructTypeNode(nowReading);
    1413                 result.setProductionTag(51);
     1298                result.setProductionTag(46);
    14141299                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14151300                expect(Lextant.STRUCT);
     
    14391324                boolean allowCompression = true;
    14401325                ASTNode result = new ASTNode(nowReading);
    1441                 result.setProductionTag(52);
     1326                result.setProductionTag(47);
    14421327                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14431328                {
     
    14591344                boolean allowCompression = true;
    14601345                ASTNode result = new StructTypeBodyNode(nowReading);
    1461                 result.setProductionTag(53);
     1346                result.setProductionTag(48);
    14621347                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14631348                expect(Lextant.LCURLY);
     
    14681353                }
    14691354                expect(Lextant.TERMINATOR);
    1470                 while( nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     1355                while( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    14711356                        {
    14721357                                ASTNode child = parseStructMember();
     
    14841369         
    14851370        public ASTNode parseStructMember() {
    1486                 if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    1487                         return syntaxErrorNode("structMember² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
     1371                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     1372                        return syntaxErrorNode("structMember² [BITBLOCK¹, BITFIELD¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    14881373                }
    14891374       
    14901375                boolean allowCompression = true;
    14911376                ASTNode result = new StructMemberNode(nowReading);
    1492                 result.setProductionTag(54);
     1377                result.setProductionTag(49);
    14931378                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14941379                {
     
    15151400                boolean allowCompression = true;
    15161401                ASTNode result = new ASTNode(nowReading);
    1517                 result.setProductionTag(55);
     1402                result.setProductionTag(50);
    15181403                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    15191404                {
     
    15351420                boolean allowCompression = true;
    15361421                ASTNode result = new VoidTypeNode(nowReading);
    1537                 result.setProductionTag(56);
     1422                result.setProductionTag(51);
    15381423                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    15391424                expect(Lextant.VOID);
Note: See TracChangeset for help on using the changeset viewer.