Changeset 3764


Ignore:
Timestamp:
Mar 29, 2014, 12:38:41 AM (3 years ago)
Author:
ksherdy
Message:

Removed void return type on s2k stream filters / b2k kernel functions.

Location:
proto/s2k/trunk/framework
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/output/cpplang/parabix2/parabix2_definitions.hpp

    r3761 r3764  
    725725        }
    726726       
     727        void clear()
     728        {
     729               
     730        }
     731       
    727732        CarryDeclare(carry_set_0,10,0);
    728733};
     
    11661171                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    11671172                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     1173        }
     1174       
     1175        void clear()
     1176        {
     1177                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    11681178        }
    11691179       
     
    14921502        }
    14931503       
     1504        void clear()
     1505        {
     1506               
     1507        }
     1508       
    14941509        CarryDeclare(carry_set_0,13,0);
    14951510};
     
    15901605                        carry_set_0.carryDequeueEnqueue(0,6);
    15911606                }
     1607        }
     1608       
     1609        void clear()
     1610        {
     1611               
    15921612        }
    15931613       
     
    16981718        }
    16991719       
     1720        void clear()
     1721        {
     1722               
     1723        }
     1724       
    17001725        CarryDeclare(carry_set_0,9,0);
    17011726};
     
    17271752                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
    17281753                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
     1754        }
     1755       
     1756        void clear()
     1757        {
     1758               
    17291759        }
    17301760       
  • proto/s2k/trunk/framework/src/b2k/parser/Parser.java

    r3761 r3764  
    390390                expect(Lextant.FUNCTION);
    391391                {
    392                         ASTNode child = parseReturnType();
    393                         result.appendChild(child);
    394                         allChildren.add(child);
    395                 }
    396                 {
    397392                        ASTNode child = parseFuncName();
    398393                        result.appendChild(child);
     
    418413                if(allowCompression) {
    419414                        return result;
    420                 }
    421                 return result;
    422         }
    423          
    424         public ASTNode parseReturnType() {
    425                 if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.BOOL, Lextant.INT, Lextant.STRUCT, Lextant.VOID)) ) {
    426                         return syntaxErrorNode("returnType² [BITBLOCK¹, BITFIELD¹, BOOL¹, INT¹, STRUCT¹, VOID¹]");
    427                 }
    428        
    429                 boolean allowCompression = true;
    430                 ASTNode result = new ASTNode(nowReading);
    431                 result.setProductionTag(14);
    432                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    433                 {
    434                         ASTNode child = parseType();
    435                         result.appendChild(child);
    436                         allChildren.add(child);
    437                 }
    438                 if(allowCompression) {
    439                         return compressIfPossible(result);
    440415                }
    441416                return result;
     
    449424                boolean allowCompression = true;
    450425                ASTNode result = new ParameterListNode(nowReading);
    451                 result.setProductionTag(15);
     426                result.setProductionTag(14);
    452427                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    453428                {
     
    477452                boolean allowCompression = true;
    478453                ASTNode result = new ASTNode(nowReading);
    479                 result.setProductionTag(16);
     454                result.setProductionTag(15);
    480455                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    481456                {
     
    497472                boolean allowCompression = true;
    498473                ASTNode result = new ParameterNode(nowReading);
    499                 result.setProductionTag(17);
     474                result.setProductionTag(16);
    500475                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    501476                {
     
    522497                boolean allowCompression = true;
    523498                ASTNode result = new ASTNode(nowReading);
    524                 result.setProductionTag(18);
     499                result.setProductionTag(17);
    525500                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    526501                {
     
    542517                boolean allowCompression = true;
    543518                ASTNode result = new ASTNode(nowReading);
    544                 result.setProductionTag(19);
     519                result.setProductionTag(18);
    545520                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    546521                {
     
    562537                boolean allowCompression = true;
    563538                ASTNode result = new ASTNode(nowReading);
    564                 result.setProductionTag(20);
     539                result.setProductionTag(19);
    565540                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    566541                {
     
    582557                boolean allowCompression = true;
    583558                ASTNode result = new ASTNode(nowReading);
    584                 result.setProductionTag(21);
     559                result.setProductionTag(20);
    585560                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    586561                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.BOOL, Lextant.INT, Lextant.STRUCT, Lextant.VOID) ) {
     
    635610                boolean allowCompression = true;
    636611                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    637                 result.setProductionTag(22);
     612                result.setProductionTag(21);
    638613                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    639614                {
     
    661636                boolean allowCompression = true;
    662637                ASTNode result = new IdisaFuncCallArgListNode(nowReading);
    663                 result.setProductionTag(23);
     638                result.setProductionTag(22);
    664639                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    665640                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    691666                boolean allowCompression = true;
    692667                ASTNode result = new AssignOperatorNode(nowReading);
    693                 result.setProductionTag(24);
     668                result.setProductionTag(23);
    694669                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    695670                expect(Lextant.ASSIGN);
     
    707682                boolean allowCompression = true;
    708683                ASTNode result = new AssignNode(nowReading);
    709                 result.setProductionTag(25);
     684                result.setProductionTag(24);
    710685                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    711686                {
     
    733708                boolean allowCompression = true;
    734709                ASTNode result = new IfStmtNode(nowReading);
    735                 result.setProductionTag(26);
     710                result.setProductionTag(25);
    736711                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    737712                expect(Lextant.IF);
     
    769744                boolean allowCompression = true;
    770745                ASTNode result = new WhileStmtNode(nowReading);
    771                 result.setProductionTag(27);
     746                result.setProductionTag(26);
    772747                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    773748                expect(Lextant.WHILE);
     
    797772                boolean allowCompression = true;
    798773                ASTNode result = new ReturnStmtNode(nowReading);
    799                 result.setProductionTag(28);
     774                result.setProductionTag(27);
    800775                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    801776                expect(Lextant.RETURN);
     
    821796                boolean allowCompression = true;
    822797                ASTNode result = new VarDeclNode(nowReading);
    823                 result.setProductionTag(29);
     798                result.setProductionTag(28);
    824799                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    825800                {
     
    847822                boolean allowCompression = true;
    848823                ASTNode result = new ASTNode(nowReading);
    849                 result.setProductionTag(30);
     824                result.setProductionTag(29);
    850825                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    851826                {
     
    867842                boolean allowCompression = true;
    868843                ASTNode result = new BlockStmtNode(nowReading);
    869                 result.setProductionTag(31);
     844                result.setProductionTag(30);
    870845                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    871846                expect(Lextant.LCURLY);
     
    891866                boolean allowCompression = true;
    892867                ASTNode result = new ASTNode(nowReading);
    893                 result.setProductionTag(32);
     868                result.setProductionTag(31);
    894869                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    895870                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    955930                boolean allowCompression = true;
    956931                ASTNode result = new ASTNode(nowReading);
    957                 result.setProductionTag(33);
     932                result.setProductionTag(32);
    958933                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    959934                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    987962                boolean allowCompression = true;
    988963                ASTNode result = new IntegerConstantNode(nowReading);
    989                 result.setProductionTag(34);
     964                result.setProductionTag(33);
    990965                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    991966                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    1013988                boolean allowCompression = true;
    1014989                ASTNode result = new StringConstantNode(nowReading);
    1015                 result.setProductionTag(35);
     990                result.setProductionTag(34);
    1016991                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1017992                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    10431018                boolean allowCompression = true;
    10441019                ASTNode result = new CompoundIdentifierNode(nowReading);
    1045                 result.setProductionTag(36);
     1020                result.setProductionTag(35);
    10461021                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10471022                {
     
    10721047                boolean allowCompression = true;
    10731048                ASTNode result = new IdentifierNode(nowReading);
    1074                 result.setProductionTag(37);
     1049                result.setProductionTag(36);
    10751050                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10761051                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    10911066                boolean allowCompression = true;
    10921067                ASTNode result = new FuncCallNode(nowReading);
    1093                 result.setProductionTag(38);
     1068                result.setProductionTag(37);
    10941069                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10951070                result.setToken(nowReading);
     
    11101085                boolean allowCompression = true;
    11111086                ASTNode result = new FuncCallArgListNode(nowReading);
    1112                 result.setProductionTag(39);
     1087                result.setProductionTag(38);
    11131088                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11141089                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    11401115                boolean allowCompression = true;
    11411116                ASTNode result = new IdisaFuncCallNode(nowReading);
    1142                 result.setProductionTag(40);
     1117                result.setProductionTag(39);
    11431118                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11441119                result.setToken(nowReading);
     
    11701145                boolean allowCompression = true;
    11711146                ASTNode result = new FieldWidthNode(nowReading);
    1172                 result.setProductionTag(41);
     1147                result.setProductionTag(40);
    11731148                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11741149                {
     
    11901165                boolean allowCompression = true;
    11911166                ASTNode result = new ASTNode(nowReading);
    1192                 result.setProductionTag(42);
     1167                result.setProductionTag(41);
    11931168                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11941169                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BOOL, Lextant.INT, Lextant.VOID) ) {
     
    12291204                boolean allowCompression = true;
    12301205                ASTNode result = new ASTNode(nowReading);
    1231                 result.setProductionTag(43);
     1206                result.setProductionTag(42);
    12321207                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12331208                if( nowReading.isLextant(Lextant.INT) ) {
     
    12751250                boolean allowCompression = true;
    12761251                ASTNode result = new IntTypeNode(nowReading);
    1277                 result.setProductionTag(44);
     1252                result.setProductionTag(43);
    12781253                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12791254                expect(Lextant.INT);
     
    12911266                boolean allowCompression = true;
    12921267                ASTNode result = new VoidTypeNode(nowReading);
    1293                 result.setProductionTag(45);
     1268                result.setProductionTag(44);
    12941269                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12951270                expect(Lextant.VOID);
     
    13071282                boolean allowCompression = true;
    13081283                ASTNode result = new BoolTypeNode(nowReading);
    1309                 result.setProductionTag(46);
     1284                result.setProductionTag(45);
    13101285                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13111286                expect(Lextant.BOOL);
     
    13231298                boolean allowCompression = true;
    13241299                ASTNode result = new BitBlockTypeNode(nowReading);
    1325                 result.setProductionTag(47);
     1300                result.setProductionTag(46);
    13261301                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13271302                expect(Lextant.BITBLOCK);
     
    13391314                boolean allowCompression = true;
    13401315                ASTNode result = new BitFieldTypeNode(nowReading);
    1341                 result.setProductionTag(48);
     1316                result.setProductionTag(47);
    13421317                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13431318                expect(Lextant.BITFIELD);
     
    13641339                boolean allowCompression = true;
    13651340                ASTNode result = new IntegerConstantNode(nowReading);
    1366                 result.setProductionTag(49);
     1341                result.setProductionTag(48);
    13671342                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13681343                if( nowReading.isLextant(Lextant.LANGLE) ) {
     
    14001375                boolean allowCompression = true;
    14011376                ASTNode result = new StructTypeNode(nowReading);
    1402                 result.setProductionTag(50);
     1377                result.setProductionTag(49);
    14031378                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14041379                expect(Lextant.STRUCT);
     
    14211396                boolean allowCompression = true;
    14221397                ASTNode result = new ASTNode(nowReading);
    1423                 result.setProductionTag(51);
     1398                result.setProductionTag(50);
    14241399                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14251400                {
  • proto/s2k/trunk/framework/src/s2k/ast/ASTTransformer.java

    r3726 r3764  
    6363
    6464        public ASTNode visit(VarDeclNode node);
    65 
    66         public ASTNode visit(VoidTypeNode node);
    6765
    6866        public ASTNode visit(WhileStmtNode node);
     
    183181                }
    184182
    185                 public ASTNode visit(VoidTypeNode node) {
    186                         return defaultVisit(node);
    187                 }
    188 
    189183                public ASTNode visit(WhileStmtNode node) {
    190184                        return defaultVisit(node);
  • proto/s2k/trunk/framework/src/s2k/ast/ASTVisitor.java

    r3726 r3764  
    9292        public T visitLeave(VarDeclNode node, List<T> childResults);
    9393
    94         public void visitEnter(VoidTypeNode node);
    95         public T visitLeave(VoidTypeNode node, List<T> childResults);
    96 
    9794        public void visitEnter(WhileStmtNode node);
    9895        public T visitLeave(WhileStmtNode node, List<T> childResults);
     
    304301                }
    305302
    306                 public void visitEnter(VoidTypeNode node) {
    307                         defaultVisitEnter(node);
    308                 }
    309                 public T visitLeave(VoidTypeNode node, List<T> childResults) {
    310                         return defaultVisitLeave(node, childResults);
    311                 }
    312 
    313303                public void visitEnter(WhileStmtNode node) {
    314304                        defaultVisitEnter(node);
  • proto/s2k/trunk/framework/src/s2k/ast/SimpleVisitor.java

    r3726 r3764  
    6464
    6565        public void visit(VarDeclNode node);
    66 
    67         public void visit(VoidTypeNode node);
    6866
    6967        public void visit(WhileStmtNode node);
     
    184182                }
    185183
    186                 public void visit(VoidTypeNode node) {
    187                         defaultVisit(node);
    188                 }
    189 
    190184                public void visit(WhileStmtNode node) {
    191185                        defaultVisit(node);
  • proto/s2k/trunk/framework/src/s2k/ast/VoidVisitor.java

    r3726 r3764  
    9090        public void visitLeave(VarDeclNode node);
    9191
    92         public void visitEnter(VoidTypeNode node);
    93         public void visitLeave(VoidTypeNode node);
    94 
    9592        public void visitEnter(WhileStmtNode node);
    9693        public void visitLeave(WhileStmtNode node);
     
    301298                }
    302299
    303                 public void visitEnter(VoidTypeNode node) {
    304                         defaultVisitEnter(node);
    305                 }
    306                 public void visitLeave(VoidTypeNode node) {
    307                         defaultVisitLeave(node);
    308                 }
    309 
    310300                public void visitEnter(WhileStmtNode node) {
    311301                        defaultVisitEnter(node);
  • proto/s2k/trunk/framework/src/s2k/lexicalAnalyzer/Lextant.java

    r3726 r3764  
    2929        MULTIPLY_ASSIGN("*=", "main"),
    3030        LANGLE("<", "main"),
    31         VOID("void", "main"),
    3231        SUBTRACT("-", "main"),
    3332        ASSIGN("=", "main"),
  • proto/s2k/trunk/framework/src/s2k/parser/Parser.java

    r3726 r3764  
    210210                expect(Lextant.FUNCTION);
    211211                {
    212                         ASTNode child = parseReturnType();
    213                         result.appendChild(child);
    214                         allChildren.add(child);
    215                 }
    216                 {
    217212                        ASTNode child = parseFuncName();
    218213                        result.appendChild(child);
     
    220215                }
    221216                expect(Lextant.LROUND);
    222                 if( nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) ) {
     217                if( nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT) ) {
    223218                        {
    224219                                ASTNode child = parseParameterList();
     
    242237        }
    243238         
    244         public ASTNode parseReturnType() {
    245                 if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
    246                         return syntaxErrorNode("returnType² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
    247                 }
    248        
    249                 boolean allowCompression = true;
    250                 ASTNode result = new ASTNode(nowReading);
     239        public ASTNode parseParameterList() {
     240                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT)) ) {
     241                        return syntaxErrorNode("parameterList² [INT¹, STREAM¹, STRUCT¹]");
     242                }
     243       
     244                boolean allowCompression = true;
     245                ASTNode result = new ParameterListNode(nowReading);
    251246                result.setProductionTag(8);
    252                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    253                 {
    254                         ASTNode child = parseType();
    255                         result.appendChild(child);
    256                         allChildren.add(child);
    257                 }
    258                 if(allowCompression) {
    259                         return compressIfPossible(result);
    260                 }
    261                 return result;
    262         }
    263          
    264         public ASTNode parseParameterList() {
    265                 if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
    266                         return syntaxErrorNode("parameterList² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
    267                 }
    268        
    269                 boolean allowCompression = true;
    270                 ASTNode result = new ParameterListNode(nowReading);
    271                 result.setProductionTag(9);
    272247                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    273248                {
     
    297272                boolean allowCompression = true;
    298273                ASTNode result = new ASTNode(nowReading);
     274                result.setProductionTag(9);
     275                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     276                {
     277                        ASTNode child = parseIdentifier();
     278                        result.appendChild(child);
     279                        allChildren.add(child);
     280                }
     281                if(allowCompression) {
     282                        return compressIfPossible(result);
     283                }
     284                return result;
     285        }
     286         
     287        public ASTNode parseParameter() {
     288                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT)) ) {
     289                        return syntaxErrorNode("parameter² [INT¹, STREAM¹, STRUCT¹]");
     290                }
     291       
     292                boolean allowCompression = true;
     293                ASTNode result = new ParameterNode(nowReading);
    299294                result.setProductionTag(10);
    300                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    301                 {
    302                         ASTNode child = parseIdentifier();
    303                         result.appendChild(child);
    304                         allChildren.add(child);
    305                 }
    306                 if(allowCompression) {
    307                         return compressIfPossible(result);
    308                 }
    309                 return result;
    310         }
    311          
    312         public ASTNode parseParameter() {
    313                 if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
    314                         return syntaxErrorNode("parameter² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
    315                 }
    316        
    317                 boolean allowCompression = true;
    318                 ASTNode result = new ParameterNode(nowReading);
    319                 result.setProductionTag(11);
    320295                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    321296                {
     
    342317                boolean allowCompression = true;
    343318                ASTNode result = new ASTNode(nowReading);
     319                result.setProductionTag(11);
     320                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     321                {
     322                        ASTNode child = parseIdentifier();
     323                        result.appendChild(child);
     324                        allChildren.add(child);
     325                }
     326                if(allowCompression) {
     327                        return compressIfPossible(result);
     328                }
     329                return result;
     330        }
     331         
     332        public ASTNode parseStmt() {
     333                if( !(nowReading.isLextant(Lextant.IF, Lextant.INT, Lextant.LROUND, Lextant.NOT, Lextant.RETURN, Lextant.STREAM, Lextant.STRUCT, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     334                        return syntaxErrorNode("stmt² [IDENTIFIER¹, IF¹, INT¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STREAM¹, STRING¹, STRUCT¹, WHILE¹]");
     335                }
     336       
     337                boolean allowCompression = true;
     338                ASTNode result = new ASTNode(nowReading);
    344339                result.setProductionTag(12);
    345340                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    346                 {
    347                         ASTNode child = parseIdentifier();
    348                         result.appendChild(child);
    349                         allChildren.add(child);
    350                 }
    351                 if(allowCompression) {
    352                         return compressIfPossible(result);
    353                 }
    354                 return result;
    355         }
    356          
    357         public ASTNode parseStmt() {
    358                 if( !(nowReading.isLextant(Lextant.IF, Lextant.INT, Lextant.LROUND, Lextant.NOT, Lextant.RETURN, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    359                         return syntaxErrorNode("stmt² [IDENTIFIER¹, IF¹, INT¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STREAM¹, STRING¹, STRUCT¹, VOID¹, WHILE¹]");
    360                 }
    361        
    362                 boolean allowCompression = true;
    363                 ASTNode result = new ASTNode(nowReading);
    364                 result.setProductionTag(13);
    365                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    366                 if( nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) ) {
     341                if( nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT) ) {
    367342                        {
    368343                                ASTNode child = parseVarDecl();
     
    400375                }
    401376                else {
    402                         return syntaxErrorNode("[IDENTIFIER¹, IF¹, INT¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STREAM¹, STRING¹, STRUCT¹, VOID¹, WHILE¹]");
     377                        return syntaxErrorNode("[IDENTIFIER¹, IF¹, INT¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STREAM¹, STRING¹, STRUCT¹, WHILE¹]");
    403378                }
    404379                if(allowCompression) {
     
    415390                boolean allowCompression = true;
    416391                ASTNode result = new BlockStmtNode(nowReading);
     392                result.setProductionTag(13);
     393                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     394                expect(Lextant.LCURLY);
     395                while( nowReading.isLextant(Lextant.IF, Lextant.INT, Lextant.LROUND, Lextant.NOT, Lextant.RETURN, Lextant.STREAM, Lextant.STRUCT, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     396                        {
     397                                ASTNode child = parseStmt();
     398                                result.appendChild(child);
     399                                allChildren.add(child);
     400                        }
     401                }
     402                expect(Lextant.RCURLY);
     403                if(allowCompression) {
     404                        return result;
     405                }
     406                return result;
     407        }
     408         
     409        public ASTNode parseVarDecl() {
     410                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT)) ) {
     411                        return syntaxErrorNode("varDecl² [INT¹, STREAM¹, STRUCT¹]");
     412                }
     413       
     414                boolean allowCompression = true;
     415                ASTNode result = new VarDeclNode(nowReading);
    417416                result.setProductionTag(14);
    418                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    419                 expect(Lextant.LCURLY);
    420                 while( nowReading.isLextant(Lextant.IF, Lextant.INT, Lextant.LROUND, Lextant.NOT, Lextant.RETURN, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    421                         {
    422                                 ASTNode child = parseStmt();
    423                                 result.appendChild(child);
    424                                 allChildren.add(child);
    425                         }
    426                 }
    427                 expect(Lextant.RCURLY);
    428                 if(allowCompression) {
    429                         return result;
    430                 }
    431                 return result;
    432         }
    433          
    434         public ASTNode parseVarDecl() {
    435                 if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
    436                         return syntaxErrorNode("varDecl² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
    437                 }
    438        
    439                 boolean allowCompression = true;
    440                 ASTNode result = new VarDeclNode(nowReading);
    441                 result.setProductionTag(15);
    442417                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    443418                {
     
    474449                boolean allowCompression = true;
    475450                ASTNode result = new ASTNode(nowReading);
    476                 result.setProductionTag(16);
     451                result.setProductionTag(15);
    477452                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    478453                {
     
    494469                boolean allowCompression = true;
    495470                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    496                 result.setProductionTag(17);
     471                result.setProductionTag(16);
    497472                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    498473                {
     
    524499                boolean allowCompression = true;
    525500                ASTNode result = new AssignNode(nowReading);
    526                 result.setProductionTag(18);
     501                result.setProductionTag(17);
    527502                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    528503                {
     
    550525                boolean allowCompression = true;
    551526                ASTNode result = new ASTNode(nowReading);
    552                 result.setProductionTag(19);
     527                result.setProductionTag(18);
    553528                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    554529                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     
    592567                boolean allowCompression = true;
    593568                ASTNode result = new IfStmtNode(nowReading);
    594                 result.setProductionTag(20);
     569                result.setProductionTag(19);
    595570                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    596571                expect(Lextant.IF);
     
    628603                boolean allowCompression = true;
    629604                ASTNode result = new WhileStmtNode(nowReading);
    630                 result.setProductionTag(21);
     605                result.setProductionTag(20);
    631606                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    632607                expect(Lextant.WHILE);
     
    656631                boolean allowCompression = true;
    657632                ASTNode result = new ReturnStmtNode(nowReading);
    658                 result.setProductionTag(22);
     633                result.setProductionTag(21);
    659634                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    660635                expect(Lextant.RETURN);
     
    680655                boolean allowCompression = true;
    681656                ASTNode result = new BinaryOperatorNode(nowReading);
    682                 result.setProductionTag(23);
     657                result.setProductionTag(22);
    683658                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    684659                {
     
    719694                boolean allowCompression = true;
    720695                ASTNode result = new BinaryOperatorNode(nowReading);
    721                 result.setProductionTag(24);
     696                result.setProductionTag(23);
    722697                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    723698                {
     
    749724                boolean allowCompression = true;
    750725                ASTNode result = new UnaryOperatorNode(nowReading);
    751                 result.setProductionTag(25);
     726                result.setProductionTag(24);
    752727                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    753728                if( nowReading.isLextant(Lextant.NOT) ) {
     
    774749                boolean allowCompression = true;
    775750                ASTNode result = new BinaryOperatorNode(nowReading);
    776                 result.setProductionTag(26);
     751                result.setProductionTag(25);
    777752                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    778753                {
     
    813788                boolean allowCompression = true;
    814789                ASTNode result = new BinaryOperatorNode(nowReading);
    815                 result.setProductionTag(27);
     790                result.setProductionTag(26);
    816791                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    817792                {
     
    852827                boolean allowCompression = true;
    853828                ASTNode result = new ASTNode(nowReading);
    854                 result.setProductionTag(28);
     829                result.setProductionTag(27);
    855830                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    856831                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    902877                boolean allowCompression = true;
    903878                ASTNode result = new ASTNode(nowReading);
    904                 result.setProductionTag(29);
     879                result.setProductionTag(28);
    905880                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    906881                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    934909                boolean allowCompression = true;
    935910                ASTNode result = new IntegerConstantNode(nowReading);
    936                 result.setProductionTag(30);
     911                result.setProductionTag(29);
    937912                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    938913                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    960935                boolean allowCompression = true;
    961936                ASTNode result = new StringConstantNode(nowReading);
    962                 result.setProductionTag(31);
     937                result.setProductionTag(30);
    963938                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    964939                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    990965                boolean allowCompression = true;
    991966                ASTNode result = new CompoundIdentifierNode(nowReading);
    992                 result.setProductionTag(32);
     967                result.setProductionTag(31);
    993968                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    994969                {
     
    1019994                boolean allowCompression = true;
    1020995                ASTNode result = new IdentifierNode(nowReading);
    1021                 result.setProductionTag(33);
     996                result.setProductionTag(32);
    1022997                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1023998                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    10381013                boolean allowCompression = true;
    10391014                ASTNode result = new FuncCallNode(nowReading);
    1040                 result.setProductionTag(34);
     1015                result.setProductionTag(33);
    10411016                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10421017                result.setToken(nowReading);
     
    10571032                boolean allowCompression = true;
    10581033                ASTNode result = new FuncCallArgListNode(nowReading);
    1059                 result.setProductionTag(35);
     1034                result.setProductionTag(34);
    10601035                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10611036                if( nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    10811056         
    10821057        public ASTNode parseType() {
    1083                 if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
    1084                         return syntaxErrorNode("type² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
     1058                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT)) ) {
     1059                        return syntaxErrorNode("type² [INT¹, STREAM¹, STRUCT¹]");
     1060                }
     1061       
     1062                boolean allowCompression = true;
     1063                ASTNode result = new ASTNode(nowReading);
     1064                result.setProductionTag(35);
     1065                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1066                if( nowReading.isLextant(Lextant.INT) ) {
     1067                        {
     1068                                ASTNode child = parsePrimitiveType();
     1069                                result.appendChild(child);
     1070                                allChildren.add(child);
     1071                        }
     1072                }
     1073                else if( nowReading.isLextant(Lextant.STREAM) ) {
     1074                        {
     1075                                ASTNode child = parseStreamType();
     1076                                result.appendChild(child);
     1077                                allChildren.add(child);
     1078                        }
     1079                }
     1080                else if( nowReading.isLextant(Lextant.STRUCT) ) {
     1081                        {
     1082                                ASTNode child = parseStructType();
     1083                                result.appendChild(child);
     1084                                allChildren.add(child);
     1085                        }
     1086                }
     1087                else {
     1088                        return syntaxErrorNode("[INT¹, STREAM¹, STRUCT¹]");
     1089                }
     1090                if(allowCompression) {
     1091                        return compressIfPossible(result);
     1092                }
     1093                return result;
     1094        }
     1095         
     1096        public ASTNode parsePrimitiveType() {
     1097                if( !(nowReading.isLextant(Lextant.INT)) ) {
     1098                        return syntaxErrorNode("primitiveType² [INT¹]");
    10851099                }
    10861100       
     
    10891103                result.setProductionTag(36);
    10901104                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1091                 if( nowReading.isLextant(Lextant.INT, Lextant.VOID) ) {
    1092                         {
    1093                                 ASTNode child = parsePrimitiveType();
    1094                                 result.appendChild(child);
    1095                                 allChildren.add(child);
    1096                         }
    1097                 }
    1098                 else if( nowReading.isLextant(Lextant.STREAM) ) {
    1099                         {
    1100                                 ASTNode child = parseStreamType();
    1101                                 result.appendChild(child);
    1102                                 allChildren.add(child);
    1103                         }
    1104                 }
    1105                 else if( nowReading.isLextant(Lextant.STRUCT) ) {
    1106                         {
    1107                                 ASTNode child = parseStructType();
    1108                                 result.appendChild(child);
    1109                                 allChildren.add(child);
    1110                         }
    1111                 }
    1112                 else {
    1113                         return syntaxErrorNode("[INT¹, STREAM¹, STRUCT¹, VOID¹]");
    1114                 }
    1115                 if(allowCompression) {
    1116                         return compressIfPossible(result);
    1117                 }
    1118                 return result;
    1119         }
    1120          
    1121         public ASTNode parsePrimitiveType() {
    1122                 if( !(nowReading.isLextant(Lextant.INT, Lextant.VOID)) ) {
    1123                         return syntaxErrorNode("primitiveType² [INT¹, VOID¹]");
    1124                 }
    1125        
    1126                 boolean allowCompression = true;
    1127                 ASTNode result = new ASTNode(nowReading);
    1128                 result.setProductionTag(37);
    1129                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1130                 if( nowReading.isLextant(Lextant.INT) ) {
    1131                         {
    1132                                 ASTNode child = parseIntType();
    1133                                 result.appendChild(child);
    1134                                 allChildren.add(child);
    1135                         }
    1136                 }
    1137                 else if( nowReading.isLextant(Lextant.VOID) ) {
    1138                         {
    1139                                 ASTNode child = parseVoidType();
    1140                                 result.appendChild(child);
    1141                                 allChildren.add(child);
    1142                         }
    1143                 }
    1144                 else {
    1145                         return syntaxErrorNode("[INT¹, VOID¹]");
     1105                {
     1106                        ASTNode child = parseIntType();
     1107                        result.appendChild(child);
     1108                        allChildren.add(child);
    11461109                }
    11471110                if(allowCompression) {
     
    11581121                boolean allowCompression = true;
    11591122                ASTNode result = new IntTypeNode(nowReading);
    1160                 result.setProductionTag(38);
     1123                result.setProductionTag(37);
    11611124                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11621125                expect(Lextant.INT);
     
    11721135        }
    11731136         
    1174         public ASTNode parseVoidType() {
    1175                 if( !(nowReading.isLextant(Lextant.VOID)) ) {
    1176                         return syntaxErrorNode("voidType² [VOID¹]");
    1177                 }
    1178        
    1179                 boolean allowCompression = true;
    1180                 ASTNode result = new VoidTypeNode(nowReading);
    1181                 result.setProductionTag(39);
    1182                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1183                 expect(Lextant.VOID);
    1184                 {
    1185                         ASTNode temp_10 = result;
    1186                         ASTNode temp_12 = (ASTNode)temp_10;
    1187                         temp_12.setType( PrimitiveType.VOID );
    1188                 }
    1189                 if(allowCompression) {
    1190                         return result;
    1191                 }
    1192                 return result;
    1193         }
    1194          
    11951137        public ASTNode parseStreamType() {
    11961138                if( !(nowReading.isLextant(Lextant.STREAM)) ) {
     
    12001142                boolean allowCompression = true;
    12011143                ASTNode result = new StreamTypeNode(nowReading);
    1202                 result.setProductionTag(40);
     1144                result.setProductionTag(38);
    12031145                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12041146                expect(Lextant.STREAM);
     
    12091151                }
    12101152                {
    1211                         ASTNode temp_13 = result;
    1212                         HasFieldWidthNodeType temp_15 = (HasFieldWidthNodeType)temp_13;
    1213                         ASTNode temp_16 = allChildren.revGet(0);
    1214                         IntValuedNodeType temp_18 = (IntValuedNodeType)temp_16;
    1215                         int temp_17 = temp_18.getValue();
    1216                         temp_15.setFieldWidth( temp_17 );
    1217                 }
    1218                 {
     1153                        ASTNode temp_10 = result;
     1154                        HasFieldWidthNodeType temp_12 = (HasFieldWidthNodeType)temp_10;
     1155                        ASTNode temp_13 = allChildren.revGet(0);
     1156                        IntValuedNodeType temp_15 = (IntValuedNodeType)temp_13;
     1157                        int temp_14 = temp_15.getValue();
     1158                        temp_12.setFieldWidth( temp_14 );
     1159                }
     1160                {
     1161                        ASTNode temp_16 = result;
     1162                        ASTNode temp_18 = (ASTNode)temp_16;
    12191163                        ASTNode temp_19 = result;
    1220                         ASTNode temp_21 = (ASTNode)temp_19;
    1221                         ASTNode temp_22 = result;
    1222                         HasFieldWidthNodeType temp_24 = (HasFieldWidthNodeType)temp_22;
    1223                         int temp_23 = temp_24.getFieldWidth();
    1224                         temp_21.setType(  StreamType.STREAM(temp_23)  );
     1164                        HasFieldWidthNodeType temp_21 = (HasFieldWidthNodeType)temp_19;
     1165                        int temp_20 = temp_21.getFieldWidth();
     1166                        temp_18.setType(  StreamType.STREAM(temp_20)  );
    12251167                }
    12261168                if(allowCompression) {
     
    12331175                boolean allowCompression = true;
    12341176                ASTNode result = new IntegerConstantNode(nowReading);
    1235                 result.setProductionTag(41);
     1177                result.setProductionTag(39);
    12361178                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12371179                if( nowReading.isLextant(Lextant.LANGLE) ) {
     
    12471189                        // epsilon
    12481190                        {
    1249                                 ASTNode temp_25 = result;
    1250                                 IntValuedNodeType temp_27 = (IntValuedNodeType)temp_25;
    1251                                 int temp_28 = 1;
    1252                                 temp_27.setValue( temp_28 );
     1191                                ASTNode temp_22 = result;
     1192                                IntValuedNodeType temp_24 = (IntValuedNodeType)temp_22;
     1193                                int temp_25 = 1;
     1194                                temp_24.setValue( temp_25 );
    12531195                        }
    12541196                }
     
    12691211                boolean allowCompression = true;
    12701212                ASTNode result = new StructTypeNode(nowReading);
    1271                 result.setProductionTag(42);
     1213                result.setProductionTag(40);
    12721214                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12731215                expect(Lextant.STRUCT);
     
    12901232                boolean allowCompression = true;
    12911233                ASTNode result = new ASTNode(nowReading);
    1292                 result.setProductionTag(43);
     1234                result.setProductionTag(41);
    12931235                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12941236                {
Note: See TracChangeset for help on using the changeset viewer.