source: proto/s2k/trunk/framework/src/s2k/parser/Parser.java @ 3767

Last change on this file since 3767 was 3767, checked in by ksherdy, 4 years ago

Replaced function keyword with filter.

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