source: proto/pabloj/trunk/src/pabloS/parser/Parser.java @ 3254

Last change on this file since 3254 was 3254, checked in by shermer, 6 years ago

beginning to implement typechecking.

File size: 41.4 KB
Line 
1// DO NOT MODIFY
2//
3// This code is generated by the scatter parser-generator
4// Any modifications will be lost next time scatter is run.
5//
6
7package pabloS.parser;
8
9import java.util.Arrays;
10import java.util.List;
11import java.util.ArrayList;
12
13import pabloS.logging.ScatterLogger;
14
15import pabloS.ast.*;
16import pabloS.tokens.*;
17
18import pabloS.lexicalAnalyzer.LexicalController;
19import pabloS.lexicalAnalyzer.LexicalType;
20import pabloS.lexicalAnalyzer.Lextant;
21
22import toolchain.pabloS.lang.type.StreamType;
23import toolchain.pabloS.semanticAnalyzer.Binding;
24import toolchain.pabloS.semanticAnalyzer.SymbolTable;
25import toolchain.pabloS.lang.type.PrimitiveType;
26import toolchain.pabloS.lang.type.Type;
27
28
29@SuppressWarnings("unused")
30public class Parser {
31        private LexicalController lexController;
32        private Token nowReading;
33        private Token previouslyRead;
34        private int unusedField;                // keeps @SuppressWarnings from generating its own warning
35       
36        public static ASTNode parse(LexicalController lexController) {
37                Parser parser = new Parser(lexController);
38                return parser.parse();
39        }
40        public Parser(LexicalController lexController) {
41                super();
42                this.lexController = lexController;
43        }
44       
45        // start of generated portion
46
47        public ASTNode parse() {
48                readToken();
49                return parseProgram();
50        }
51        public ASTNode parseProgram() {
52                boolean allowCompression = true;
53                ASTNode result = new ProgramNode(nowReading);
54                result.setProductionTag(1);
55                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
56                while( nowReading.isLextant(Lextant.FUNCTION, Lextant.STRUCT) ) {
57                        if( nowReading.isLextant(Lextant.STRUCT) ) {
58                                {
59                                        ASTNode child = parseStructDecl();
60                                        result.appendChild(child);
61                                        allChildren.add(child);
62                                }
63                        }
64                        else if( nowReading.isLextant(Lextant.FUNCTION) ) {
65                                {
66                                        ASTNode child = parseFuncDef();
67                                        result.appendChild(child);
68                                        allChildren.add(child);
69                                }
70                        }
71                        else {
72                                return syntaxErrorNode("[FUNCTION¹, STRUCT¹]");
73                        }
74                }
75                if(allowCompression) {
76                        return result;
77                }
78                return result;
79        }
80         
81        public ASTNode parseStructDecl() {
82                if( !(nowReading.isLextant(Lextant.STRUCT)) ) {
83                        return syntaxErrorNode("structDecl² [STRUCT¹]");
84                }
85       
86                boolean allowCompression = true;
87                ASTNode result = new StructDeclNode(nowReading);
88                result.setProductionTag(2);
89                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
90                expect(Lextant.STRUCT);
91                {
92                        ASTNode child = parseStructName();
93                        result.appendChild(child);
94                        allChildren.add(child);
95                }
96                {
97                        ASTNode child = parseStructDeclBody();
98                        result.appendChild(child);
99                        allChildren.add(child);
100                }
101                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
102                        expect(Lextant.TERMINATOR);
103                }
104                if(allowCompression) {
105                        return result;
106                }
107                return result;
108        }
109         
110        public ASTNode parseStructDeclBody() {
111                if( !(nowReading.isLextant(Lextant.LCURLY)) ) {
112                        return syntaxErrorNode("structDeclBody² [LCURLY¹]");
113                }
114       
115                boolean allowCompression = true;
116                ASTNode result = new StructDeclBodyNode(nowReading);
117                result.setProductionTag(3);
118                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
119                expect(Lextant.LCURLY);
120                do {
121                        {
122                                ASTNode child = parseStructMember();
123                                result.appendChild(child);
124                                allChildren.add(child);
125                        }
126                        expect(Lextant.TERMINATOR);
127                } while( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT) );
128                expect(Lextant.RCURLY);
129                if(allowCompression) {
130                        return result;
131                }
132                return result;
133        }
134         
135        public ASTNode parseStructMember() {
136                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT)) ) {
137                        return syntaxErrorNode("structMember² [STREAM¹, STRUCT¹]");
138                }
139       
140                boolean allowCompression = true;
141                ASTNode result = new StructMemberNode(nowReading);
142                result.setProductionTag(4);
143                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
144                {
145                        ASTNode child = parseStructMemberType();
146                        result.appendChild(child);
147                        allChildren.add(child);
148                }
149                {
150                        ASTNode child = parseStructMemberName();
151                        result.appendChild(child);
152                        allChildren.add(child);
153                }
154                if(allowCompression) {
155                        return result;
156                }
157                return result;
158        }
159         
160        public ASTNode parseStructMemberType() {
161                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT)) ) {
162                        return syntaxErrorNode("structMemberType² [STREAM¹, STRUCT¹]");
163                }
164       
165                boolean allowCompression = true;
166                ASTNode result = new ASTNode(nowReading);
167                result.setProductionTag(5);
168                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
169                if( nowReading.isLextant(Lextant.STRUCT) ) {
170                        {
171                                ASTNode child = parseStructType();
172                                result.appendChild(child);
173                                allChildren.add(child);
174                        }
175                }
176                else if( nowReading.isLextant(Lextant.STREAM) ) {
177                        {
178                                ASTNode child = parseStreamType();
179                                result.appendChild(child);
180                                allChildren.add(child);
181                        }
182                }
183                else {
184                        return syntaxErrorNode("[STREAM¹, STRUCT¹]");
185                }
186                if(allowCompression) {
187                        return compressIfPossible(result);
188                }
189                return result;
190        }
191         
192        public ASTNode parseStructMemberName() {
193                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
194                        return syntaxErrorNode("structMemberName² [IDENTIFIER¹]");
195                }
196       
197                boolean allowCompression = true;
198                ASTNode result = new ASTNode(nowReading);
199                result.setProductionTag(6);
200                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
201                {
202                        ASTNode child = parseIdentifier();
203                        result.appendChild(child);
204                        allChildren.add(child);
205                }
206                if(allowCompression) {
207                        return compressIfPossible(result);
208                }
209                return result;
210        }
211         
212        public ASTNode parseFuncDef() {
213                if( !(nowReading.isLextant(Lextant.FUNCTION)) ) {
214                        return syntaxErrorNode("funcDef² [FUNCTION¹]");
215                }
216       
217                boolean allowCompression = true;
218                ASTNode result = new FuncDefNode(nowReading);
219                result.setProductionTag(7);
220                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
221                expect(Lextant.FUNCTION);
222                {
223                        ASTNode child = parseReturnType();
224                        result.appendChild(child);
225                        allChildren.add(child);
226                }
227                {
228                        ASTNode child = parseFuncName();
229                        result.appendChild(child);
230                        allChildren.add(child);
231                }
232                expect(Lextant.LROUND);
233                if( nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) ) {
234                        {
235                                ASTNode child = parseParameterList();
236                                result.appendChild(child);
237                                allChildren.add(child);
238                        }
239                }
240                expect(Lextant.RROUND);
241                {
242                        ASTNode child = parseBlockStmt();
243                        result.appendChild(child);
244                        allChildren.add(child);
245                }
246                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
247                        expect(Lextant.TERMINATOR);
248                }
249                if(allowCompression) {
250                        return result;
251                }
252                return result;
253        }
254         
255        public ASTNode parseReturnType() {
256                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
257                        return syntaxErrorNode("returnType² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
258                }
259       
260                boolean allowCompression = true;
261                ASTNode result = new ASTNode(nowReading);
262                result.setProductionTag(8);
263                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
264                {
265                        ASTNode child = parseType();
266                        result.appendChild(child);
267                        allChildren.add(child);
268                }
269                if(allowCompression) {
270                        return compressIfPossible(result);
271                }
272                return result;
273        }
274         
275        public ASTNode parseParameterList() {
276                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
277                        return syntaxErrorNode("parameterList² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
278                }
279       
280                boolean allowCompression = true;
281                ASTNode result = new ParameterListNode(nowReading);
282                result.setProductionTag(9);
283                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
284                {
285                        ASTNode child = parseParameter();
286                        result.appendChild(child);
287                        allChildren.add(child);
288                }
289                while( nowReading.isLextant(Lextant.COMMA) ) {
290                        expect(Lextant.COMMA);
291                        {
292                                ASTNode child = parseParameter();
293                                result.appendChild(child);
294                                allChildren.add(child);
295                        }
296                }
297                if(allowCompression) {
298                        return result;
299                }
300                return result;
301        }
302         
303        public ASTNode parseFuncName() {
304                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
305                        return syntaxErrorNode("funcName² [IDENTIFIER¹]");
306                }
307       
308                boolean allowCompression = true;
309                ASTNode result = new ASTNode(nowReading);
310                result.setProductionTag(10);
311                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
312                {
313                        ASTNode child = parseIdentifier();
314                        result.appendChild(child);
315                        allChildren.add(child);
316                }
317                if(allowCompression) {
318                        return compressIfPossible(result);
319                }
320                return result;
321        }
322         
323        public ASTNode parseParameter() {
324                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
325                        return syntaxErrorNode("parameter² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
326                }
327       
328                boolean allowCompression = true;
329                ASTNode result = new ParameterNode(nowReading);
330                result.setProductionTag(11);
331                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
332                {
333                        ASTNode child = parseType();
334                        result.appendChild(child);
335                        allChildren.add(child);
336                }
337                {
338                        ASTNode child = parseParameterName();
339                        result.appendChild(child);
340                        allChildren.add(child);
341                }
342                if(allowCompression) {
343                        return result;
344                }
345                return result;
346        }
347         
348        public ASTNode parseParameterName() {
349                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
350                        return syntaxErrorNode("parameterName² [IDENTIFIER¹]");
351                }
352       
353                boolean allowCompression = true;
354                ASTNode result = new ASTNode(nowReading);
355                result.setProductionTag(12);
356                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
357                {
358                        ASTNode child = parseIdentifier();
359                        result.appendChild(child);
360                        allChildren.add(child);
361                }
362                if(allowCompression) {
363                        return compressIfPossible(result);
364                }
365                return result;
366        }
367         
368        public ASTNode parseStmt() {
369                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))) ) {
370                        return syntaxErrorNode("stmt² [IDENTIFIER¹, IF¹, INT¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STREAM¹, STRING¹, STRUCT¹, VOID¹, WHILE¹]");
371                }
372       
373                boolean allowCompression = true;
374                ASTNode result = new ASTNode(nowReading);
375                result.setProductionTag(13);
376                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
377                if( nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) ) {
378                        {
379                                ASTNode child = parseLocalVarDecl();
380                                result.appendChild(child);
381                                allChildren.add(child);
382                        }
383                }
384                else 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)) ) {
385                        {
386                                ASTNode child = parseFuncCallOrAssignStmt();
387                                result.appendChild(child);
388                                allChildren.add(child);
389                        }
390                }
391                else if( nowReading.isLextant(Lextant.IF) ) {
392                        {
393                                ASTNode child = parseIfStmt();
394                                result.appendChild(child);
395                                allChildren.add(child);
396                        }
397                }
398                else if( nowReading.isLextant(Lextant.WHILE) ) {
399                        {
400                                ASTNode child = parseWhileStmt();
401                                result.appendChild(child);
402                                allChildren.add(child);
403                        }
404                }
405                else if( nowReading.isLextant(Lextant.RETURN) ) {
406                        {
407                                ASTNode child = parseReturnStmt();
408                                result.appendChild(child);
409                                allChildren.add(child);
410                        }
411                }
412                else {
413                        return syntaxErrorNode("[IDENTIFIER¹, IF¹, INT¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STREAM¹, STRING¹, STRUCT¹, VOID¹, WHILE¹]");
414                }
415                if(allowCompression) {
416                        return compressIfPossible(result);
417                }
418                return result;
419        }
420         
421        public ASTNode parseBlockStmt() {
422                if( !(nowReading.isLextant(Lextant.LCURLY)) ) {
423                        return syntaxErrorNode("blockStmt² [LCURLY¹]");
424                }
425       
426                boolean allowCompression = true;
427                ASTNode result = new BlockStmtNode(nowReading);
428                result.setProductionTag(14);
429                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
430                expect(Lextant.LCURLY);
431                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)) ) {
432                        {
433                                ASTNode child = parseStmt();
434                                result.appendChild(child);
435                                allChildren.add(child);
436                        }
437                }
438                expect(Lextant.RCURLY);
439                if(allowCompression) {
440                        return result;
441                }
442                return result;
443        }
444         
445        public ASTNode parseLocalVarDecl() {
446                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
447                        return syntaxErrorNode("localVarDecl² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
448                }
449       
450                boolean allowCompression = true;
451                ASTNode result = new LocalVarDeclNode(nowReading);
452                result.setProductionTag(15);
453                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
454                {
455                        ASTNode child = parseType();
456                        result.appendChild(child);
457                        allChildren.add(child);
458                }
459                {
460                        ASTNode child = parseVarName();
461                        result.appendChild(child);
462                        allChildren.add(child);
463                }
464                if( nowReading.isLextant(Lextant.ASSIGN) ) {
465                        result.setToken(nowReading);
466                        expect(Lextant.ASSIGN);
467                        {
468                                ASTNode child = parseExpr();
469                                result.appendChild(child);
470                                allChildren.add(child);
471                        }
472                }
473                expect(Lextant.TERMINATOR);
474                if(allowCompression) {
475                        return result;
476                }
477                return result;
478        }
479         
480        public ASTNode parseVarName() {
481                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
482                        return syntaxErrorNode("varName² [IDENTIFIER¹]");
483                }
484       
485                boolean allowCompression = true;
486                ASTNode result = new ASTNode(nowReading);
487                result.setProductionTag(16);
488                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
489                {
490                        ASTNode child = parseCompoundIdentifier();
491                        result.appendChild(child);
492                        allChildren.add(child);
493                }
494                if(allowCompression) {
495                        return compressIfPossible(result);
496                }
497                return result;
498        }
499         
500        public ASTNode parseFuncCallOrAssignStmt() {
501                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))) ) {
502                        return syntaxErrorNode("funcCallOrAssignStmt² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
503                }
504       
505                boolean allowCompression = true;
506                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
507                result.setProductionTag(17);
508                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
509                {
510                        ASTNode child = parseExpr();
511                        result.appendChild(child);
512                        allChildren.add(child);
513                }
514                if( nowReading.isLextant(Lextant.ADD_ASSIGN, Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.DIVIDE_ASSIGN, Lextant.MULTIPLY_ASSIGN, Lextant.OR_ASSIGN, Lextant.SUBTRACT_ASSIGN, Lextant.XOR_ASSIGN) ) {
515                        {
516                                ASTNode child = parseAssignRest();
517                                result.appendChild(child);
518                                allChildren.add(child);
519                        }
520                        result = promoteLastChild(result);
521                        allowCompression = false;
522                }
523                expect(Lextant.TERMINATOR);
524                if(allowCompression) {
525                        return compressIfPossible(result);
526                }
527                return result;
528        }
529         
530        public ASTNode parseAssignRest() {
531                if( !(nowReading.isLextant(Lextant.ADD_ASSIGN, Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.DIVIDE_ASSIGN, Lextant.MULTIPLY_ASSIGN, Lextant.OR_ASSIGN, Lextant.SUBTRACT_ASSIGN, Lextant.XOR_ASSIGN)) ) {
532                        return syntaxErrorNode("assignRest² [ADD_ASSIGN¹, AND_ASSIGN¹, ASSIGN¹, DIVIDE_ASSIGN¹, MULTIPLY_ASSIGN¹, OR_ASSIGN¹, SUBTRACT_ASSIGN¹, XOR_ASSIGN¹]");
533                }
534       
535                boolean allowCompression = true;
536                ASTNode result = new AssignNode(nowReading);
537                result.setProductionTag(18);
538                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
539                {
540                        ASTNode child = parseAssignOperator();
541                        // node omitted - no result.appendChild(child);
542                        allChildren.add(child);
543                        result.setToken( child.getToken() );
544                }
545                {
546                        ASTNode child = parseExpr();
547                        result.appendChild(child);
548                        allChildren.add(child);
549                }
550                if(allowCompression) {
551                        return result;
552                }
553                return result;
554        }
555         
556        public ASTNode parseAssignOperator() {
557                if( !(nowReading.isLextant(Lextant.ADD_ASSIGN, Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.DIVIDE_ASSIGN, Lextant.MULTIPLY_ASSIGN, Lextant.OR_ASSIGN, Lextant.SUBTRACT_ASSIGN, Lextant.XOR_ASSIGN)) ) {
558                        return syntaxErrorNode("assignOperator² [ADD_ASSIGN¹, AND_ASSIGN¹, ASSIGN¹, DIVIDE_ASSIGN¹, MULTIPLY_ASSIGN¹, OR_ASSIGN¹, SUBTRACT_ASSIGN¹, XOR_ASSIGN¹]");
559                }
560       
561                boolean allowCompression = true;
562                ASTNode result = new ASTNode(nowReading);
563                result.setProductionTag(19);
564                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
565                if( nowReading.isLextant(Lextant.ASSIGN) ) {
566                        expect(Lextant.ASSIGN);
567                }
568                else if( nowReading.isLextant(Lextant.AND_ASSIGN) ) {
569                        expect(Lextant.AND_ASSIGN);
570                }
571                else if( nowReading.isLextant(Lextant.OR_ASSIGN) ) {
572                        expect(Lextant.OR_ASSIGN);
573                }
574                else if( nowReading.isLextant(Lextant.XOR_ASSIGN) ) {
575                        expect(Lextant.XOR_ASSIGN);
576                }
577                else if( nowReading.isLextant(Lextant.MULTIPLY_ASSIGN) ) {
578                        expect(Lextant.MULTIPLY_ASSIGN);
579                }
580                else if( nowReading.isLextant(Lextant.DIVIDE_ASSIGN) ) {
581                        expect(Lextant.DIVIDE_ASSIGN);
582                }
583                else if( nowReading.isLextant(Lextant.ADD_ASSIGN) ) {
584                        expect(Lextant.ADD_ASSIGN);
585                }
586                else if( nowReading.isLextant(Lextant.SUBTRACT_ASSIGN) ) {
587                        expect(Lextant.SUBTRACT_ASSIGN);
588                }
589                else {
590                        return syntaxErrorNode("[ADD_ASSIGN¹, AND_ASSIGN¹, ASSIGN¹, DIVIDE_ASSIGN¹, MULTIPLY_ASSIGN¹, OR_ASSIGN¹, SUBTRACT_ASSIGN¹, XOR_ASSIGN¹]");
591                }
592                if(allowCompression) {
593                        return result;
594                }
595                return result;
596        }
597         
598        public ASTNode parseIfStmt() {
599                if( !(nowReading.isLextant(Lextant.IF)) ) {
600                        return syntaxErrorNode("ifStmt² [IF¹]");
601                }
602       
603                boolean allowCompression = true;
604                ASTNode result = new IfStmtNode(nowReading);
605                result.setProductionTag(20);
606                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
607                expect(Lextant.IF);
608                expect(Lextant.LROUND);
609                {
610                        ASTNode child = parseExpr();
611                        result.appendChild(child);
612                        allChildren.add(child);
613                }
614                expect(Lextant.RROUND);
615                {
616                        ASTNode child = parseBlockStmt();
617                        result.appendChild(child);
618                        allChildren.add(child);
619                }
620                if( nowReading.isLextant(Lextant.ELSE) ) {
621                        expect(Lextant.ELSE);
622                        {
623                                ASTNode child = parseBlockStmt();
624                                result.appendChild(child);
625                                allChildren.add(child);
626                        }
627                }
628                if(allowCompression) {
629                        return result;
630                }
631                return result;
632        }
633         
634        public ASTNode parseWhileStmt() {
635                if( !(nowReading.isLextant(Lextant.WHILE)) ) {
636                        return syntaxErrorNode("whileStmt² [WHILE¹]");
637                }
638       
639                boolean allowCompression = true;
640                ASTNode result = new WhileStmtNode(nowReading);
641                result.setProductionTag(21);
642                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
643                expect(Lextant.WHILE);
644                expect(Lextant.LROUND);
645                {
646                        ASTNode child = parseExpr();
647                        result.appendChild(child);
648                        allChildren.add(child);
649                }
650                expect(Lextant.RROUND);
651                {
652                        ASTNode child = parseBlockStmt();
653                        result.appendChild(child);
654                        allChildren.add(child);
655                }
656                if(allowCompression) {
657                        return result;
658                }
659                return result;
660        }
661         
662        public ASTNode parseReturnStmt() {
663                if( !(nowReading.isLextant(Lextant.RETURN)) ) {
664                        return syntaxErrorNode("returnStmt² [RETURN¹]");
665                }
666       
667                boolean allowCompression = true;
668                ASTNode result = new ReturnStmtNode(nowReading);
669                result.setProductionTag(22);
670                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
671                expect(Lextant.RETURN);
672                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)) ) {
673                        {
674                                ASTNode child = parseExpr();
675                                result.appendChild(child);
676                                allChildren.add(child);
677                        }
678                }
679                expect(Lextant.TERMINATOR);
680                if(allowCompression) {
681                        return result;
682                }
683                return result;
684        }
685         
686        public ASTNode parseExpr() {
687                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))) ) {
688                        return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
689                }
690       
691                boolean allowCompression = true;
692                ASTNode result = new BinaryOperatorNode(nowReading);
693                result.setProductionTag(23);
694                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
695                {
696                        ASTNode child = parseExpr1();
697                        result.appendChild(child);
698                        allChildren.add(child);
699                }
700                if( nowReading.isLextant(Lextant.OR, Lextant.XOR) ) {
701                        if( nowReading.isLextant(Lextant.OR) ) {
702                                result.setToken(nowReading);
703                                expect(Lextant.OR);
704                        }
705                        else if( nowReading.isLextant(Lextant.XOR) ) {
706                                result.setToken(nowReading);
707                                expect(Lextant.XOR);
708                        }
709                        else {
710                                return syntaxErrorNode("[OR¹, XOR¹]");
711                        }
712                        {
713                                ASTNode child = parseExpr();
714                                result.appendChild(child);
715                                allChildren.add(child);
716                        }
717                }
718                result = rotateLeftIfPossible(result);
719                if(allowCompression) {
720                        return compressIfPossible(result);
721                }
722                return result;
723        }
724         
725        public ASTNode parseExpr1() {
726                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))) ) {
727                        return syntaxErrorNode("expr1² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
728                }
729       
730                boolean allowCompression = true;
731                ASTNode result = new BinaryOperatorNode(nowReading);
732                result.setProductionTag(24);
733                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
734                {
735                        ASTNode child = parseExpr2();
736                        result.appendChild(child);
737                        allChildren.add(child);
738                }
739                if( nowReading.isLextant(Lextant.AND) ) {
740                        result.setToken(nowReading);
741                        expect(Lextant.AND);
742                        {
743                                ASTNode child = parseExpr1();
744                                result.appendChild(child);
745                                allChildren.add(child);
746                        }
747                }
748                result = rotateLeftIfPossible(result);
749                if(allowCompression) {
750                        return compressIfPossible(result);
751                }
752                return result;
753        }
754         
755        public ASTNode parseExpr2() {
756                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))) ) {
757                        return syntaxErrorNode("expr2² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
758                }
759       
760                boolean allowCompression = true;
761                ASTNode result = new UnaryOperatorNode(nowReading);
762                result.setProductionTag(25);
763                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
764                if( nowReading.isLextant(Lextant.NOT) ) {
765                        result.setToken(nowReading);
766                        allowCompression = false;
767                        expect(Lextant.NOT);
768                }
769                {
770                        ASTNode child = parseExpr3();
771                        result.appendChild(child);
772                        allChildren.add(child);
773                }
774                if(allowCompression) {
775                        return compressIfPossible(result);
776                }
777                return result;
778        }
779         
780        public ASTNode parseExpr3() {
781                if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
782                        return syntaxErrorNode("expr3² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
783                }
784       
785                boolean allowCompression = true;
786                ASTNode result = new BinaryOperatorNode(nowReading);
787                result.setProductionTag(26);
788                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
789                {
790                        ASTNode child = parseExpr4();
791                        result.appendChild(child);
792                        allChildren.add(child);
793                }
794                if( nowReading.isLextant(Lextant.DIVIDE, Lextant.MULTIPLY) ) {
795                        if( nowReading.isLextant(Lextant.MULTIPLY) ) {
796                                result.setToken(nowReading);
797                                expect(Lextant.MULTIPLY);
798                        }
799                        else if( nowReading.isLextant(Lextant.DIVIDE) ) {
800                                result.setToken(nowReading);
801                                expect(Lextant.DIVIDE);
802                        }
803                        else {
804                                return syntaxErrorNode("[DIVIDE¹, MULTIPLY¹]");
805                        }
806                        {
807                                ASTNode child = parseExpr3();
808                                result.appendChild(child);
809                                allChildren.add(child);
810                        }
811                }
812                result = rotateLeftIfPossible(result);
813                if(allowCompression) {
814                        return compressIfPossible(result);
815                }
816                return result;
817        }
818         
819        public ASTNode parseExpr4() {
820                if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
821                        return syntaxErrorNode("expr4² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
822                }
823       
824                boolean allowCompression = true;
825                ASTNode result = new BinaryOperatorNode(nowReading);
826                result.setProductionTag(27);
827                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
828                {
829                        ASTNode child = parseExpr5();
830                        result.appendChild(child);
831                        allChildren.add(child);
832                }
833                if( nowReading.isLextant(Lextant.ADD, Lextant.SUBTRACT) ) {
834                        if( nowReading.isLextant(Lextant.ADD) ) {
835                                result.setToken(nowReading);
836                                expect(Lextant.ADD);
837                        }
838                        else if( nowReading.isLextant(Lextant.SUBTRACT) ) {
839                                result.setToken(nowReading);
840                                expect(Lextant.SUBTRACT);
841                        }
842                        else {
843                                return syntaxErrorNode("[ADD¹, SUBTRACT¹]");
844                        }
845                        {
846                                ASTNode child = parseExpr4();
847                                result.appendChild(child);
848                                allChildren.add(child);
849                        }
850                }
851                result = rotateLeftIfPossible(result);
852                if(allowCompression) {
853                        return compressIfPossible(result);
854                }
855                return result;
856        }
857         
858        public ASTNode parseExpr5() {
859                if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
860                        return syntaxErrorNode("expr5² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
861                }
862       
863                boolean allowCompression = true;
864                ASTNode result = new ASTNode(nowReading);
865                result.setProductionTag(28);
866                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
867                if( nowReading.isLextant(Lextant.LROUND) ) {
868                        expect(Lextant.LROUND);
869                        {
870                                ASTNode child = parseExpr();
871                                result.appendChild(child);
872                                allChildren.add(child);
873                        }
874                        expect(Lextant.RROUND);
875                }
876                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
877                        {
878                                ASTNode child = parseConstant();
879                                result.appendChild(child);
880                                allChildren.add(child);
881                        }
882                }
883                else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
884                        {
885                                ASTNode child = parseCompoundIdentifier();
886                                result.appendChild(child);
887                                allChildren.add(child);
888                        }
889                        if( nowReading.isLextant(Lextant.LROUND) ) {
890                                {
891                                        ASTNode child = parseFuncCallRest();
892                                        result.appendChild(child);
893                                        allChildren.add(child);
894                                }
895                                result = promoteLastChild(result);
896                                allowCompression = false;
897                        }
898                }
899                else {
900                        return syntaxErrorNode("[IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
901                }
902                if(allowCompression) {
903                        return compressIfPossible(result);
904                }
905                return result;
906        }
907         
908        public ASTNode parseConstant() {
909                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
910                        return syntaxErrorNode("constant² [INTEGER_CONST¹, SQ_STRING¹, STRING¹]");
911                }
912       
913                boolean allowCompression = true;
914                ASTNode result = new ASTNode(nowReading);
915                result.setProductionTag(29);
916                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
917                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
918                        {
919                                ASTNode child = parseStringConstant();
920                                result.appendChild(child);
921                                allChildren.add(child);
922                        }
923                }
924                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
925                        {
926                                ASTNode child = parseIntegerConstant();
927                                result.appendChild(child);
928                                allChildren.add(child);
929                        }
930                }
931                else {
932                        return syntaxErrorNode("[INTEGER_CONST¹, SQ_STRING¹, STRING¹]");
933                }
934                if(allowCompression) {
935                        return compressIfPossible(result);
936                }
937                return result;
938        }
939         
940        public ASTNode parseIntegerConstant() {
941                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
942                        return syntaxErrorNode("integerConstant² [INTEGER_CONST¹]");
943                }
944       
945                boolean allowCompression = true;
946                ASTNode result = new IntegerConstantNode(nowReading);
947                result.setProductionTag(30);
948                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
949                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
950                        return syntaxErrorNode("INTEGER_CONST");
951                }
952                readToken();
953                {
954                        ASTNode temp_1 = result;
955                        IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
956                        IntValuedToken temp_6 = (IntValuedToken)previouslyRead;
957                        int temp_5 = temp_6.getValue();
958                        temp_3.setValue( temp_5 );
959                }
960                if(allowCompression) {
961                        return result;
962                }
963                return result;
964        }
965         
966        public ASTNode parseStringConstant() {
967                if( !((nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
968                        return syntaxErrorNode("stringConstant² [SQ_STRING¹, STRING¹]");
969                }
970       
971                boolean allowCompression = true;
972                ASTNode result = new StringConstantNode(nowReading);
973                result.setProductionTag(31);
974                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
975                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
976                        if( !(nowReading.isLexicalType(LexicalType.STRING)) ) {
977                                return syntaxErrorNode("STRING");
978                        }
979                        readToken();
980                }
981                else if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) ) {
982                        if( !(nowReading.isLexicalType(LexicalType.SQ_STRING)) ) {
983                                return syntaxErrorNode("SQ_STRING");
984                        }
985                        readToken();
986                }
987                else {
988                        return syntaxErrorNode("[SQ_STRING¹, STRING¹]");
989                }
990                if(allowCompression) {
991                        return result;
992                }
993                return result;
994        }
995         
996        public ASTNode parseCompoundIdentifier() {
997                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
998                        return syntaxErrorNode("compoundIdentifier² [IDENTIFIER¹]");
999                }
1000       
1001                boolean allowCompression = true;
1002                ASTNode result = new CompoundIdentifierNode(nowReading);
1003                result.setProductionTag(32);
1004                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1005                {
1006                        ASTNode child = parseIdentifier();
1007                        result.appendChild(child);
1008                        allChildren.add(child);
1009                }
1010                if( nowReading.isLextant(Lextant.DOT) ) {
1011                        result.setToken(nowReading);
1012                        expect(Lextant.DOT);
1013                        {
1014                                ASTNode child = parseIdentifier();
1015                                result.appendChild(child);
1016                                allChildren.add(child);
1017                        }
1018                }
1019                if(allowCompression) {
1020                        return compressIfPossible(result);
1021                }
1022                return result;
1023        }
1024         
1025        public ASTNode parseIdentifier() {
1026                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
1027                        return syntaxErrorNode("identifier² [IDENTIFIER¹]");
1028                }
1029       
1030                boolean allowCompression = true;
1031                ASTNode result = new IdentifierNode(nowReading);
1032                result.setProductionTag(33);
1033                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1034                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
1035                        return syntaxErrorNode("IDENTIFIER");
1036                }
1037                readToken();
1038                if(allowCompression) {
1039                        return result;
1040                }
1041                return result;
1042        }
1043         
1044        public ASTNode parseFuncCallRest() {
1045                if( !(nowReading.isLextant(Lextant.LROUND)) ) {
1046                        return syntaxErrorNode("funcCallRest² [LROUND¹]");
1047                }
1048       
1049                boolean allowCompression = true;
1050                ASTNode result = new FuncCallNode(nowReading);
1051                result.setProductionTag(34);
1052                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1053                result.setToken(nowReading);
1054                expect(Lextant.LROUND);
1055                {
1056                        ASTNode child = parseFuncCallArgList();
1057                        result.appendChild(child);
1058                        allChildren.add(child);
1059                }
1060                expect(Lextant.RROUND);
1061                if(allowCompression) {
1062                        return result;
1063                }
1064                return result;
1065        }
1066         
1067        public ASTNode parseFuncCallArgList() {
1068                boolean allowCompression = true;
1069                ASTNode result = new FuncCallArgListNode(nowReading);
1070                result.setProductionTag(35);
1071                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1072                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)) ) {
1073                        {
1074                                ASTNode child = parseExpr();
1075                                result.appendChild(child);
1076                                allChildren.add(child);
1077                        }
1078                        while( nowReading.isLextant(Lextant.COMMA) ) {
1079                                expect(Lextant.COMMA);
1080                                {
1081                                        ASTNode child = parseExpr();
1082                                        result.appendChild(child);
1083                                        allChildren.add(child);
1084                                }
1085                        }
1086                }
1087                if(allowCompression) {
1088                        return result;
1089                }
1090                return result;
1091        }
1092         
1093        public ASTNode parseType() {
1094                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
1095                        return syntaxErrorNode("type² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
1096                }
1097       
1098                boolean allowCompression = true;
1099                ASTNode result = new ASTNode(nowReading);
1100                result.setProductionTag(36);
1101                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1102                if( nowReading.isLextant(Lextant.INT, Lextant.VOID) ) {
1103                        {
1104                                ASTNode child = parsePrimitiveType();
1105                                result.appendChild(child);
1106                                allChildren.add(child);
1107                        }
1108                }
1109                else if( nowReading.isLextant(Lextant.STREAM) ) {
1110                        {
1111                                ASTNode child = parseStreamType();
1112                                result.appendChild(child);
1113                                allChildren.add(child);
1114                        }
1115                }
1116                else if( nowReading.isLextant(Lextant.STRUCT) ) {
1117                        {
1118                                ASTNode child = parseStructType();
1119                                result.appendChild(child);
1120                                allChildren.add(child);
1121                        }
1122                }
1123                else {
1124                        return syntaxErrorNode("[INT¹, STREAM¹, STRUCT¹, VOID¹]");
1125                }
1126                if(allowCompression) {
1127                        return compressIfPossible(result);
1128                }
1129                return result;
1130        }
1131         
1132        public ASTNode parsePrimitiveType() {
1133                if( !(nowReading.isLextant(Lextant.INT, Lextant.VOID)) ) {
1134                        return syntaxErrorNode("primitiveType² [INT¹, VOID¹]");
1135                }
1136       
1137                boolean allowCompression = true;
1138                ASTNode result = new ASTNode(nowReading);
1139                result.setProductionTag(37);
1140                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1141                if( nowReading.isLextant(Lextant.INT) ) {
1142                        {
1143                                ASTNode child = parseIntType();
1144                                result.appendChild(child);
1145                                allChildren.add(child);
1146                        }
1147                }
1148                else if( nowReading.isLextant(Lextant.VOID) ) {
1149                        {
1150                                ASTNode child = parseVoidType();
1151                                result.appendChild(child);
1152                                allChildren.add(child);
1153                        }
1154                }
1155                else {
1156                        return syntaxErrorNode("[INT¹, VOID¹]");
1157                }
1158                if(allowCompression) {
1159                        return compressIfPossible(result);
1160                }
1161                return result;
1162        }
1163         
1164        public ASTNode parseIntType() {
1165                if( !(nowReading.isLextant(Lextant.INT)) ) {
1166                        return syntaxErrorNode("intType² [INT¹]");
1167                }
1168       
1169                boolean allowCompression = true;
1170                ASTNode result = new IntTypeNode(nowReading);
1171                result.setProductionTag(38);
1172                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1173                expect(Lextant.INT);
1174                {
1175                        ASTNode temp_7 = result;
1176                        ASTNode temp_9 = (ASTNode)temp_7;
1177                        temp_9.setType( PrimitiveType.INTEGER );
1178                }
1179                if(allowCompression) {
1180                        return result;
1181                }
1182                return result;
1183        }
1184         
1185        public ASTNode parseVoidType() {
1186                if( !(nowReading.isLextant(Lextant.VOID)) ) {
1187                        return syntaxErrorNode("voidType² [VOID¹]");
1188                }
1189       
1190                boolean allowCompression = true;
1191                ASTNode result = new VoidTypeNode(nowReading);
1192                result.setProductionTag(39);
1193                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1194                expect(Lextant.VOID);
1195                {
1196                        ASTNode temp_10 = result;
1197                        ASTNode temp_12 = (ASTNode)temp_10;
1198                        temp_12.setType( PrimitiveType.VOID );
1199                }
1200                if(allowCompression) {
1201                        return result;
1202                }
1203                return result;
1204        }
1205         
1206        public ASTNode parseStreamType() {
1207                if( !(nowReading.isLextant(Lextant.STREAM)) ) {
1208                        return syntaxErrorNode("streamType² [STREAM¹]");
1209                }
1210       
1211                boolean allowCompression = true;
1212                ASTNode result = new StreamTypeNode(nowReading);
1213                result.setProductionTag(40);
1214                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1215                expect(Lextant.STREAM);
1216                {
1217                        ASTNode child = parseFieldWidthSpecifier();
1218                        // node omitted - no result.appendChild(child);
1219                        allChildren.add(child);
1220                }
1221                {
1222                        ASTNode temp_13 = result;
1223                        HasFieldWidthNodeType temp_15 = (HasFieldWidthNodeType)temp_13;
1224                        ASTNode temp_16 = allChildren.revGet(0);
1225                        IntValuedNodeType temp_18 = (IntValuedNodeType)temp_16;
1226                        int temp_17 = temp_18.getValue();
1227                        temp_15.setFieldWidth( temp_17 );
1228                }
1229                {
1230                        ASTNode temp_19 = result;
1231                        ASTNode temp_21 = (ASTNode)temp_19;
1232                        ASTNode temp_22 = result;
1233                        HasFieldWidthNodeType temp_24 = (HasFieldWidthNodeType)temp_22;
1234                        int temp_23 = temp_24.getFieldWidth();
1235                        temp_21.setType(  StreamType.STREAM(temp_23)  );
1236                }
1237                if(allowCompression) {
1238                        return result;
1239                }
1240                return result;
1241        }
1242         
1243        public ASTNode parseFieldWidthSpecifier() {
1244                boolean allowCompression = true;
1245                ASTNode result = new IntegerConstantNode(nowReading);
1246                result.setProductionTag(41);
1247                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1248                if( nowReading.isLextant(Lextant.LANGLE) ) {
1249                        expect(Lextant.LANGLE);
1250                        {
1251                                ASTNode child = parseIntegerConstant();
1252                                result.appendChild(child);
1253                                allChildren.add(child);
1254                        }
1255                        expect(Lextant.RANGLE);
1256                }
1257                else if( true ) {
1258                        // epsilon
1259                        {
1260                                ASTNode temp_25 = result;
1261                                IntValuedNodeType temp_27 = (IntValuedNodeType)temp_25;
1262                                int temp_28 = 1;
1263                                temp_27.setValue( temp_28 );
1264                        }
1265                }
1266                else {
1267                        return syntaxErrorNode("[LANGLE¹]");
1268                }
1269                if(allowCompression) {
1270                        return compressIfPossible(result);
1271                }
1272                return result;
1273        }
1274         
1275        public ASTNode parseStructType() {
1276                if( !(nowReading.isLextant(Lextant.STRUCT)) ) {
1277                        return syntaxErrorNode("structType² [STRUCT¹]");
1278                }
1279       
1280                boolean allowCompression = true;
1281                ASTNode result = new StructTypeNode(nowReading);
1282                result.setProductionTag(42);
1283                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1284                expect(Lextant.STRUCT);
1285                {
1286                        ASTNode child = parseStructName();
1287                        result.appendChild(child);
1288                        allChildren.add(child);
1289                }
1290                if(allowCompression) {
1291                        return result;
1292                }
1293                return result;
1294        }
1295         
1296        public ASTNode parseStructName() {
1297                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
1298                        return syntaxErrorNode("structName² [IDENTIFIER¹]");
1299                }
1300       
1301                boolean allowCompression = true;
1302                ASTNode result = new ASTNode(nowReading);
1303                result.setProductionTag(43);
1304                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
1305                {
1306                        ASTNode child = parseIdentifier();
1307                        result.appendChild(child);
1308                        allChildren.add(child);
1309                }
1310                if(allowCompression) {
1311                        return compressIfPossible(result);
1312                }
1313                return result;
1314        }
1315         
1316
1317
1318        // end of generated portion
1319       
1320        private void readToken() {
1321                previouslyRead = nowReading;
1322                nowReading = lexController.next();
1323        }       
1324
1325        // skip forward to the next lextant in the list.
1326        private void skipToLextant(Lextant... lextants) {
1327                while(!(nowReading instanceof NullToken) && !(nowReading.isLextant(lextants))) {
1328                        readToken();
1329                }
1330        }
1331        // skip over an optional token
1332        private void skipOptional(Lextant ...lextants ) {
1333                if(nowReading.isLextant(lextants)) {
1334                        readToken();
1335                }
1336        }       
1337        // if the current token is one of the given lextants, read the next token.
1338        // otherwise, give a syntax error and read next token (to avoid endless looping).
1339        private void expect(Lextant ...lextants ) {
1340                if(!nowReading.isLextant(lextants)) {
1341                        syntaxError(nowReading, "expecting " + Arrays.toString(lextants));
1342                }
1343                readToken();
1344        }
1345        // return node or, if it has one child, its single child.       
1346        private ASTNode compressIfPossible(ASTNode node) {
1347                if(node.nChildren() != 1) {
1348                        return node;
1349                }
1350                ASTNode result = node.child(0);
1351                result.setCompressed();
1352                return result;
1353        }
1354       
1355        // if both top and its right child have two children, and they are from same
1356        // production, rotate tree left and repeat on left subchild.
1357        private ASTNode rotateLeftIfPossible(ASTNode tree) {
1358                ASTNode top = tree;
1359                if(top.nChildren() != 2) {
1360                        return top;
1361                }
1362                ASTNode left   = top.child(0);
1363                ASTNode newTop = top.child(1);
1364               
1365                if( (newTop.nChildren() == 2)  &&  fromSameProduction(top, newTop) ) {
1366                        ASTNode middle = newTop.child(0);
1367                        ASTNode right = newTop.child(1);
1368
1369                        top.initChildren();
1370                        top.appendChild(left);
1371                        top.appendChild(middle);
1372                        top = rotateLeftIfPossible(top);
1373
1374                        newTop.initChildren();
1375                        newTop.appendChild(top);
1376                        newTop.appendChild(right);
1377
1378                        return newTop;
1379                }
1380                else  {
1381                        return top;
1382                }
1383        }
1384        private boolean fromSameProduction(ASTNode node1, ASTNode node2) {
1385                return (node1.getProductionTag() == node2.getProductionTag()) &&
1386                           !node1.isCompressed() &&
1387                           !node2.isCompressed();
1388        }
1389        private ASTNode promoteLastChild(ASTNode tree) {
1390                int lastIndex = tree.nChildren() - 1;
1391                ASTNode lastChild = tree.child(lastIndex);
1392                tree.removeChild(lastIndex);
1393               
1394                for(int index = tree.nChildren() - 1; index >= 0 ; index--) {
1395                        lastChild.insertChild(tree.child(index));
1396                }
1397                return lastChild;
1398        }
1399        private ASTNode syntaxErrorNode(String expectedSymbol) {
1400                syntaxError(nowReading, "expecting " + expectedSymbol);
1401                ASTNode errorNode = new ErrorNode(nowReading);
1402                readToken();
1403                return errorNode;
1404        }
1405        private void syntaxError(Token token, String errorDescription) {
1406                String message = "" + token.getLocation() + " " + errorDescription;
1407                error(message);
1408        }
1409        private void error(String message) {
1410                ScatterLogger log = ScatterLogger.getLogger("compiler.Parser");
1411                log.severe("syntax error: " + message);
1412        }       
1413}
1414
Note: See TracBrowser for help on using the repository browser.