1 // $ANTLR !Unknown version! Grammar/CTFParser.g 2012-03-09 14:59:18
3 package org
.eclipse
.linuxtools
.ctf
.parser
;
5 import java
.util
.HashSet
;
7 import java
.util
.Stack
;
9 import org
.antlr
.runtime
.BaseRecognizer
;
10 import org
.antlr
.runtime
.BitSet
;
11 import org
.antlr
.runtime
.DFA
;
12 import org
.antlr
.runtime
.EarlyExitException
;
13 import org
.antlr
.runtime
.FailedPredicateException
;
14 import org
.antlr
.runtime
.IntStream
;
15 import org
.antlr
.runtime
.MismatchedSetException
;
16 import org
.antlr
.runtime
.MismatchedTokenException
;
17 import org
.antlr
.runtime
.NoViableAltException
;
18 import org
.antlr
.runtime
.Parser
;
19 import org
.antlr
.runtime
.ParserRuleReturnScope
;
20 import org
.antlr
.runtime
.RecognitionException
;
21 import org
.antlr
.runtime
.RecognizerSharedState
;
22 import org
.antlr
.runtime
.Token
;
23 import org
.antlr
.runtime
.TokenStream
;
24 import org
.antlr
.runtime
.tree
.CommonTree
;
25 import org
.antlr
.runtime
.tree
.CommonTreeAdaptor
;
26 import org
.antlr
.runtime
.tree
.RewriteEarlyExitException
;
27 import org
.antlr
.runtime
.tree
.RewriteRuleSubtreeStream
;
28 import org
.antlr
.runtime
.tree
.RewriteRuleTokenStream
;
29 import org
.antlr
.runtime
.tree
.TreeAdaptor
;
31 @SuppressWarnings({ "nls", "unused", "unchecked", "rawtypes", "null" })
32 public class CTFParser
extends Parser
{
33 public static final String
[] tokenNames
= new String
[] { "<invalid>",
34 "<EOR>", "<DOWN>", "<UP>", "ALIGNTOK", "CONSTTOK", "CHARTOK",
35 "DOUBLETOK", "ENUMTOK", "EVENTTOK", "FLOATINGPOINTTOK", "FLOATTOK",
36 "INTEGERTOK", "INTTOK", "LONGTOK", "SHORTTOK", "SIGNEDTOK",
37 "STREAMTOK", "STRINGTOK", "STRUCTTOK", "TRACETOK", "TYPEALIASTOK",
38 "TYPEDEFTOK", "UNSIGNEDTOK", "VARIANTTOK", "VOIDTOK", "BOOLTOK",
39 "COMPLEXTOK", "IMAGINARYTOK", "ENVTOK", "CLOCKTOK", "NANNUMBERTOK",
40 "INFINITYTOK", "NINFINITYTOK", "SEPARATOR", "COLON", "ELIPSES",
41 "ASSIGNMENT", "TYPE_ASSIGNMENT", "LT", "GT", "OPENBRAC",
42 "CLOSEBRAC", "LPAREN", "RPAREN", "LCURL", "RCURL", "TERM",
43 "POINTER", "SIGN", "ARROW", "DOT", "BACKSLASH",
44 "INTEGER_TYPES_SUFFIX", "OCTAL_LITERAL", "DIGIT",
45 "DECIMAL_LITERAL", "HEX_PREFIX", "HEX_DIGIT", "HEX_LITERAL",
46 "NONZERO_DIGIT", "OCTAL_ESCAPE", "UNICODE_ESCAPE",
47 "HEXADECIMAL_ESCAPE", "ESCAPE_SEQUENCE", "STRINGPREFIX",
48 "SINGLEQUOTE", "CHAR_CONTENT", "CHARACTER_LITERAL", "DOUBLEQUOTE",
49 "STRING_CONTENT", "STRING_LITERAL", "WS", "COMMENT_OPEN",
50 "COMMENT_CLOSE", "COMMENT", "LINE_COMMENT", "NONDIGIT",
51 "IDENTIFIER", "ROOT", "EVENT", "STREAM", "TRACE", "ENV", "CLOCK",
52 "DECLARATION", "SV_DECLARATION", "TYPE_SPECIFIER_LIST",
53 "TYPE_DECLARATOR_LIST", "TYPE_DECLARATOR", "STRUCT", "STRUCT_NAME",
54 "STRUCT_BODY", "ALIGN", "CTF_EXPRESSION_TYPE",
55 "CTF_EXPRESSION_VAL", "CTF_LEFT", "CTF_RIGHT",
56 "UNARY_EXPRESSION_STRING", "UNARY_EXPRESSION_STRING_QUOTES",
57 "UNARY_EXPRESSION_DEC", "UNARY_EXPRESSION_HEX",
58 "UNARY_EXPRESSION_OCT", "LENGTH", "TYPEDEF", "TYPEALIAS",
59 "TYPEALIAS_TARGET", "TYPEALIAS_ALIAS", "INTEGER", "STRING",
60 "FLOATING_POINT", "ENUM", "ENUM_CONTAINER_TYPE", "ENUM_ENUMERATOR",
61 "ENUM_NAME", "ENUM_VALUE", "ENUM_VALUE_RANGE", "ENUM_BODY",
62 "VARIANT", "VARIANT_NAME", "VARIANT_TAG", "VARIANT_BODY",
64 public static final int SIGN
= 49;
65 public static final int LT
= 39;
66 public static final int TYPEDEFTOK
= 22;
67 public static final int VARIANT_NAME
= 119;
68 public static final int ENV
= 83;
69 public static final int INTEGER_TYPES_SUFFIX
= 53;
70 public static final int POINTER
= 48;
71 public static final int TRACE
= 82;
72 public static final int HEX_PREFIX
= 57;
73 public static final int INTTOK
= 13;
74 public static final int SEPARATOR
= 34;
75 public static final int ENUMTOK
= 8;
76 public static final int COMPLEXTOK
= 27;
77 public static final int IMAGINARYTOK
= 28;
78 public static final int STREAMTOK
= 17;
79 public static final int EOF
= -1;
80 public static final int UNARY_EXPRESSION_OCT
= 102;
81 public static final int ENUM_VALUE
= 115;
82 public static final int UNSIGNEDTOK
= 23;
83 public static final int ENUM_NAME
= 114;
84 public static final int RPAREN
= 44;
85 public static final int CHAR_CONTENT
= 67;
86 public static final int STRING_LITERAL
= 71;
87 public static final int UNARY_EXPRESSION_STRING_QUOTES
= 99;
88 public static final int ALIGNTOK
= 4;
89 public static final int FLOATTOK
= 11;
90 public static final int STRUCT_BODY
= 92;
91 public static final int ENUM_BODY
= 117;
92 public static final int COMMENT_CLOSE
= 74;
93 public static final int STRINGTOK
= 18;
94 public static final int COMMENT
= 75;
95 public static final int STREAM
= 81;
96 public static final int UNARY_EXPRESSION_HEX
= 101;
97 public static final int UNARY_EXPRESSION_DEC
= 100;
98 public static final int FLOATINGPOINTTOK
= 10;
99 public static final int LINE_COMMENT
= 76;
100 public static final int CTF_EXPRESSION_TYPE
= 94;
101 public static final int DOUBLETOK
= 7;
102 public static final int TYPE_DECLARATOR
= 89;
103 public static final int CHARACTER_LITERAL
= 68;
104 public static final int OCTAL_ESCAPE
= 61;
105 public static final int STRUCT_NAME
= 91;
106 public static final int VARIANT
= 118;
107 public static final int NANNUMBERTOK
= 31;
108 public static final int ENUM_ENUMERATOR
= 113;
109 public static final int FLOATING_POINT
= 110;
110 public static final int DECLARATOR
= 122;
111 public static final int SIGNEDTOK
= 16;
112 public static final int CHARTOK
= 6;
113 public static final int WS
= 72;
114 public static final int INTEGERTOK
= 12;
115 public static final int VARIANT_BODY
= 121;
116 public static final int NONDIGIT
= 77;
117 public static final int GT
= 40;
118 public static final int TYPEALIAS_TARGET
= 106;
119 public static final int DECIMAL_LITERAL
= 56;
120 public static final int BACKSLASH
= 52;
121 public static final int CLOSEBRAC
= 42;
122 public static final int TERM
= 47;
123 public static final int BOOLTOK
= 26;
124 public static final int CTF_RIGHT
= 97;
125 public static final int TYPE_DECLARATOR_LIST
= 88;
126 public static final int STRING_CONTENT
= 70;
127 public static final int TYPE_ASSIGNMENT
= 38;
128 public static final int ENUM_CONTAINER_TYPE
= 112;
129 public static final int DOUBLEQUOTE
= 69;
130 public static final int ENUM_VALUE_RANGE
= 116;
131 public static final int DECLARATION
= 85;
132 public static final int LENGTH
= 103;
133 public static final int LPAREN
= 43;
134 public static final int INFINITYTOK
= 32;
135 public static final int STRINGPREFIX
= 65;
136 public static final int CTF_EXPRESSION_VAL
= 95;
137 public static final int ESCAPE_SEQUENCE
= 64;
138 public static final int UNICODE_ESCAPE
= 62;
139 public static final int SINGLEQUOTE
= 66;
140 public static final int IDENTIFIER
= 78;
141 public static final int HEX_LITERAL
= 59;
142 public static final int ALIGN
= 93;
143 public static final int DIGIT
= 55;
144 public static final int DOT
= 51;
145 public static final int ENVTOK
= 29;
146 public static final int STRUCTTOK
= 19;
147 public static final int OPENBRAC
= 41;
148 public static final int TYPEALIASTOK
= 21;
149 public static final int CLOCK
= 84;
150 public static final int INTEGER
= 108;
151 public static final int TYPEALIAS
= 105;
152 public static final int EVENTTOK
= 9;
153 public static final int NINFINITYTOK
= 33;
154 public static final int TYPEDEF
= 104;
155 public static final int VOIDTOK
= 25;
156 public static final int TYPE_SPECIFIER_LIST
= 87;
157 public static final int OCTAL_LITERAL
= 54;
158 public static final int COMMENT_OPEN
= 73;
159 public static final int HEX_DIGIT
= 58;
160 public static final int STRUCT
= 90;
161 public static final int EVENT
= 80;
162 public static final int LONGTOK
= 14;
163 public static final int ROOT
= 79;
164 public static final int CTF_LEFT
= 96;
165 public static final int CLOCKTOK
= 30;
166 public static final int TRACETOK
= 20;
167 public static final int COLON
= 35;
168 public static final int HEXADECIMAL_ESCAPE
= 63;
169 public static final int LCURL
= 45;
170 public static final int VARIANTTOK
= 24;
171 public static final int VARIANT_TAG
= 120;
172 public static final int ENUM
= 111;
173 public static final int ELIPSES
= 36;
174 public static final int RCURL
= 46;
175 public static final int TYPEALIAS_ALIAS
= 107;
176 public static final int UNARY_EXPRESSION_STRING
= 98;
177 public static final int ARROW
= 50;
178 public static final int ASSIGNMENT
= 37;
179 public static final int SHORTTOK
= 15;
180 public static final int SV_DECLARATION
= 86;
181 public static final int NONZERO_DIGIT
= 60;
182 public static final int CONSTTOK
= 5;
183 public static final int STRING
= 109;
188 protected static class Symbols_scope
{
192 protected Stack Symbols_stack
= new Stack();
194 public CTFParser(TokenStream input
) {
195 this(input
, new RecognizerSharedState());
198 public CTFParser(TokenStream input
, RecognizerSharedState state
) {
203 protected TreeAdaptor adaptor
= new CommonTreeAdaptor();
205 public void setTreeAdaptor(TreeAdaptor adaptor
) {
206 this.adaptor
= adaptor
;
209 public TreeAdaptor
getTreeAdaptor() {
214 public String
[] getTokenNames() {
215 return CTFParser
.tokenNames
;
219 public String
getGrammarFileName() {
220 return "Grammar/CTFParser.g";
223 public CTFParser(TokenStream input
, boolean verbose
) {
225 this.verbose
= verbose
;
229 * To disable automatic error recovery. When we have a mismatched token,
230 * simply throw an exception.
233 protected Object
recoverFromMismatchedToken(IntStream input
, int ttype
,
234 BitSet follow
) throws RecognitionException
{
235 throw new MismatchedTokenException(ttype
, input
);
239 * Checks if a given name has been defined has a type. From:
240 * http://www.antlr.org/grammar/1153358328744/C.g
244 * @return True if is is a type, false otherwise.
246 boolean isTypeName(String name
) {
247 for (int i
= Symbols_stack
.size() - 1; i
>= 0; i
--) {
248 Symbols_scope scope
= (Symbols_scope
) Symbols_stack
.get(i
);
249 if (scope
.types
.contains(name
)) {
256 void addTypeName(String name
) {
257 ((Symbols_scope
) Symbols_stack
.peek()).types
.add(name
);
259 debug_print("New type: " + name
);
263 boolean _inTypedef
= false;
266 debug_print("typedefOn");
271 debug_print("typedefOff");
275 boolean inTypedef() {
279 boolean _inTypealiasAlias
= false;
281 void typealiasAliasOn() {
282 debug_print("typealiasAliasOn");
283 _inTypealiasAlias
= true;
286 void typealiasAliasOff() {
287 debug_print("typealiasAliasOff");
288 _inTypealiasAlias
= false;
291 boolean inTypealiasAlias() {
292 return _inTypealiasAlias
;
295 static void print_tabs(int n
) {
296 for (int i
= 0; i
< n
; i
++) {
297 if(System
.out
!= null) {//findbugs
298 System
.out
.print(" ");
303 void enter(String name
) {
305 if (state
.backtracking
== 0) {
307 debug_print("+ " + name
);
313 void exit(String name
) {
317 debug_print("- " + name
);
321 void debug_print(String str
) {
323 if(System
.out
!= null) {//findbugs
324 System
.out
.println(str
);
331 /* Prints rule entry and exit while parsing */
332 boolean verbose
= false;
334 public static class parse_return
extends ParserRuleReturnScope
{
338 public Object
getTree() {
343 // $ANTLR start "parse"
344 // Grammar/CTFParser.g:198:1: parse : ( declaration )+ EOF -> ^( ROOT (
345 // declaration )+ ) ;
346 public final CTFParser
.parse_return
parse() throws RecognitionException
{
347 Symbols_stack
.push(new Symbols_scope());
349 CTFParser
.parse_return retval
= new CTFParser
.parse_return();
350 retval
.start
= input
.LT(1);
352 CommonTree root_0
= null;
355 CTFParser
.declaration_return declaration1
= null;
357 CommonTree EOF2_tree
= null;
358 RewriteRuleTokenStream stream_EOF
= new RewriteRuleTokenStream(adaptor
,
360 RewriteRuleSubtreeStream stream_declaration
= new RewriteRuleSubtreeStream(
361 adaptor
, "rule declaration");
364 debug_print("Scope push " + Symbols_stack
.size());
365 ((Symbols_scope
) Symbols_stack
.peek()).types
= new HashSet
<String
>();
368 // Grammar/CTFParser.g:211:1: ( ( declaration )+ EOF -> ^( ROOT (
369 // declaration )+ ) )
370 // Grammar/CTFParser.g:212:3: ( declaration )+ EOF
372 // Grammar/CTFParser.g:212:3: ( declaration )+
376 int LA1_0
= input
.LA(1);
378 if ((((LA1_0
>= CONSTTOK
) && (LA1_0
<= ENUMTOK
))
379 || ((LA1_0
>= FLOATINGPOINTTOK
) && (LA1_0
<= SIGNEDTOK
))
380 || ((LA1_0
>= STRINGTOK
) && (LA1_0
<= STRUCTTOK
)) || ((LA1_0
>= TYPEDEFTOK
) && (LA1_0
<= IMAGINARYTOK
)))) {
382 } else if ((LA1_0
== IDENTIFIER
)
383 && ((inTypealiasAlias() || isTypeName(input
.LT(1)
386 } else if (((LA1_0
== EVENTTOK
) || (LA1_0
== STREAMTOK
)
387 || ((LA1_0
>= TRACETOK
) && (LA1_0
<= TYPEALIASTOK
)) || ((LA1_0
>= ENVTOK
) && (LA1_0
<= CLOCKTOK
)))) {
393 // Grammar/CTFParser.g:212:3: declaration
395 pushFollow(FOLLOW_declaration_in_parse321
);
396 declaration1
= declaration();
402 if (state
.backtracking
== 0) {
403 stream_declaration
.add(declaration1
.getTree());
413 if (state
.backtracking
> 0) {
417 EarlyExitException eee
= new EarlyExitException(1,
424 EOF2
= (Token
) match(input
, EOF
, FOLLOW_EOF_in_parse324
);
428 if (state
.backtracking
== 0) {
429 stream_EOF
.add(EOF2
);
433 // elements: declaration
435 // rule labels: retval
436 // token list labels:
439 if (state
.backtracking
== 0) {
440 retval
.tree
= root_0
;
441 // RewriteRuleSubtreeStream stream_retval =
442 new RewriteRuleSubtreeStream(
443 adaptor
, "rule retval",
444 retval
!= null ? retval
.tree
: null);
446 root_0
= (CommonTree
) adaptor
.nil();
447 // 212:20: -> ^( ROOT ( declaration )+ )
449 // Grammar/CTFParser.g:212:23: ^( ROOT ( declaration )+
452 CommonTree root_1
= (CommonTree
) adaptor
.nil();
453 root_1
= (CommonTree
) adaptor
.becomeRoot(
454 adaptor
.create(ROOT
, "ROOT"), root_1
);
456 if (!(stream_declaration
.hasNext())) {
457 throw new RewriteEarlyExitException();
459 while (stream_declaration
.hasNext()) {
460 adaptor
.addChild(root_1
,
461 stream_declaration
.nextTree());
464 stream_declaration
.reset();
466 adaptor
.addChild(root_0
, root_1
);
471 retval
.tree
= root_0
;
475 retval
.stop
= input
.LT(-1);
477 if (state
.backtracking
== 0) {
479 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
480 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
483 if (state
.backtracking
== 0) {
485 debug_print("Scope pop " + Symbols_stack
.size());
488 debug_print("Final depth, should be 0: " + depth
);
493 catch (RecognitionException e
) {
502 // $ANTLR end "parse"
504 public static class numberLiteral_return
extends ParserRuleReturnScope
{
508 public Object
getTree() {
513 // $ANTLR start "numberLiteral"
514 // Grammar/CTFParser.g:215:1: numberLiteral : ( SIGN )* ( HEX_LITERAL -> ^(
515 // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^(
516 // UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^(
517 // UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) ) ;
518 public final CTFParser
.numberLiteral_return
numberLiteral()
519 throws RecognitionException
{
520 CTFParser
.numberLiteral_return retval
= new CTFParser
.numberLiteral_return();
521 retval
.start
= input
.LT(1);
523 CommonTree root_0
= null;
526 Token HEX_LITERAL4
= null;
527 Token DECIMAL_LITERAL5
= null;
528 Token OCTAL_LITERAL6
= null;
530 CommonTree SIGN3_tree
= null;
531 CommonTree HEX_LITERAL4_tree
= null;
532 CommonTree DECIMAL_LITERAL5_tree
= null;
533 CommonTree OCTAL_LITERAL6_tree
= null;
534 RewriteRuleTokenStream stream_SIGN
= new RewriteRuleTokenStream(
535 adaptor
, "token SIGN");
536 RewriteRuleTokenStream stream_OCTAL_LITERAL
= new RewriteRuleTokenStream(
537 adaptor
, "token OCTAL_LITERAL");
538 RewriteRuleTokenStream stream_HEX_LITERAL
= new RewriteRuleTokenStream(
539 adaptor
, "token HEX_LITERAL");
540 RewriteRuleTokenStream stream_DECIMAL_LITERAL
= new RewriteRuleTokenStream(
541 adaptor
, "token DECIMAL_LITERAL");
543 enter("numberLiteral");
546 // Grammar/CTFParser.g:223:1: ( ( SIGN )* ( HEX_LITERAL -> ^(
547 // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL ->
548 // ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) |
549 // OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )*
551 // Grammar/CTFParser.g:224:3: ( SIGN )* ( HEX_LITERAL -> ^(
552 // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL ->
553 // ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) |
554 // OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )*
557 // Grammar/CTFParser.g:224:3: ( SIGN )*
560 int LA2_0
= input
.LA(1);
562 if ((LA2_0
== SIGN
)) {
568 // Grammar/CTFParser.g:224:3: SIGN
570 SIGN3
= (Token
) match(input
, SIGN
,
571 FOLLOW_SIGN_in_numberLiteral357
);
575 if (state
.backtracking
== 0) {
576 stream_SIGN
.add(SIGN3
);
587 // Grammar/CTFParser.g:224:10: ( HEX_LITERAL -> ^(
588 // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) |
589 // DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL (
590 // SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT
591 // OCTAL_LITERAL ( SIGN )* ) )
593 switch (input
.LA(1)) {
598 case DECIMAL_LITERAL
: {
602 case OCTAL_LITERAL
: {
607 if (state
.backtracking
> 0) {
611 NoViableAltException nvae
= new NoViableAltException("", 3,
619 // Grammar/CTFParser.g:224:11: HEX_LITERAL
621 HEX_LITERAL4
= (Token
) match(input
, HEX_LITERAL
,
622 FOLLOW_HEX_LITERAL_in_numberLiteral362
);
626 if (state
.backtracking
== 0) {
627 stream_HEX_LITERAL
.add(HEX_LITERAL4
);
631 // elements: SIGN, HEX_LITERAL
633 // rule labels: retval
634 // token list labels:
637 if (state
.backtracking
== 0) {
638 retval
.tree
= root_0
;
639 // RewriteRuleSubtreeStream stream_retval =
640 new RewriteRuleSubtreeStream(
641 adaptor
, "rule retval",
642 retval
!= null ? retval
.tree
: null);
644 root_0
= (CommonTree
) adaptor
.nil();
645 // 224:23: -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN
648 // Grammar/CTFParser.g:224:26: ^(
649 // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
651 CommonTree root_1
= (CommonTree
) adaptor
.nil();
652 root_1
= (CommonTree
) adaptor
653 .becomeRoot(adaptor
.create(
654 UNARY_EXPRESSION_HEX
,
655 "UNARY_EXPRESSION_HEX"), root_1
);
657 adaptor
.addChild(root_1
,
658 stream_HEX_LITERAL
.nextNode());
659 // Grammar/CTFParser.g:224:61: ( SIGN )*
660 while (stream_SIGN
.hasNext()) {
661 adaptor
.addChild(root_1
,
662 stream_SIGN
.nextNode());
667 adaptor
.addChild(root_0
, root_1
);
672 retval
.tree
= root_0
;
677 // Grammar/CTFParser.g:225:5: DECIMAL_LITERAL
679 DECIMAL_LITERAL5
= (Token
) match(input
, DECIMAL_LITERAL
,
680 FOLLOW_DECIMAL_LITERAL_in_numberLiteral379
);
684 if (state
.backtracking
== 0) {
685 stream_DECIMAL_LITERAL
.add(DECIMAL_LITERAL5
);
689 // elements: DECIMAL_LITERAL, SIGN
691 // rule labels: retval
692 // token list labels:
695 if (state
.backtracking
== 0) {
696 retval
.tree
= root_0
;
697 // RewriteRuleSubtreeStream stream_retval =
698 new RewriteRuleSubtreeStream(
699 adaptor
, "rule retval",
700 retval
!= null ? retval
.tree
: null);
702 root_0
= (CommonTree
) adaptor
.nil();
703 // 225:21: -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL (
706 // Grammar/CTFParser.g:225:24: ^(
707 // UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
709 CommonTree root_1
= (CommonTree
) adaptor
.nil();
710 root_1
= (CommonTree
) adaptor
711 .becomeRoot(adaptor
.create(
712 UNARY_EXPRESSION_DEC
,
713 "UNARY_EXPRESSION_DEC"), root_1
);
715 adaptor
.addChild(root_1
,
716 stream_DECIMAL_LITERAL
.nextNode());
717 // Grammar/CTFParser.g:225:63: ( SIGN )*
718 while (stream_SIGN
.hasNext()) {
719 adaptor
.addChild(root_1
,
720 stream_SIGN
.nextNode());
725 adaptor
.addChild(root_0
, root_1
);
730 retval
.tree
= root_0
;
735 // Grammar/CTFParser.g:226:5: OCTAL_LITERAL
737 OCTAL_LITERAL6
= (Token
) match(input
, OCTAL_LITERAL
,
738 FOLLOW_OCTAL_LITERAL_in_numberLiteral396
);
742 if (state
.backtracking
== 0) {
743 stream_OCTAL_LITERAL
.add(OCTAL_LITERAL6
);
747 // elements: SIGN, OCTAL_LITERAL
749 // rule labels: retval
750 // token list labels:
753 if (state
.backtracking
== 0) {
754 retval
.tree
= root_0
;
755 // RewriteRuleSubtreeStream stream_retval =
756 new RewriteRuleSubtreeStream(
757 adaptor
, "rule retval",
758 retval
!= null ? retval
.tree
: null);
760 root_0
= (CommonTree
) adaptor
.nil();
761 // 226:19: -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL (
764 // Grammar/CTFParser.g:226:22: ^(
765 // UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
767 CommonTree root_1
= (CommonTree
) adaptor
.nil();
768 root_1
= (CommonTree
) adaptor
769 .becomeRoot(adaptor
.create(
770 UNARY_EXPRESSION_OCT
,
771 "UNARY_EXPRESSION_OCT"), root_1
);
773 adaptor
.addChild(root_1
,
774 stream_OCTAL_LITERAL
.nextNode());
775 // Grammar/CTFParser.g:226:59: ( SIGN )*
776 while (stream_SIGN
.hasNext()) {
777 adaptor
.addChild(root_1
,
778 stream_SIGN
.nextNode());
783 adaptor
.addChild(root_0
, root_1
);
788 retval
.tree
= root_0
;
797 retval
.stop
= input
.LT(-1);
799 if (state
.backtracking
== 0) {
801 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
802 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
805 if (state
.backtracking
== 0) {
807 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
808 exit("numberLiteral");
813 catch (RecognitionException e
) {
820 // $ANTLR end "numberLiteral"
822 public static class constant_return
extends ParserRuleReturnScope
{
826 public Object
getTree() {
831 // $ANTLR start "constant"
832 // Grammar/CTFParser.g:229:1: constant : ( numberLiteral | enumConstant |
833 // CHARACTER_LITERAL );
834 public final CTFParser
.constant_return
constant()
835 throws RecognitionException
{
836 CTFParser
.constant_return retval
= new CTFParser
.constant_return();
837 retval
.start
= input
.LT(1);
839 CommonTree root_0
= null;
841 Token CHARACTER_LITERAL9
= null;
842 CTFParser
.numberLiteral_return numberLiteral7
= null;
844 CTFParser
.enumConstant_return enumConstant8
= null;
846 CommonTree CHARACTER_LITERAL9_tree
= null;
851 // Grammar/CTFParser.g:236:1: ( numberLiteral | enumConstant |
852 // CHARACTER_LITERAL )
854 switch (input
.LA(1)) {
857 case DECIMAL_LITERAL
:
871 case CHARACTER_LITERAL
: {
876 if (state
.backtracking
> 0) {
880 NoViableAltException nvae
= new NoViableAltException("", 4, 0,
888 // Grammar/CTFParser.g:237:4: numberLiteral
890 root_0
= (CommonTree
) adaptor
.nil();
892 pushFollow(FOLLOW_numberLiteral_in_constant432
);
893 numberLiteral7
= numberLiteral();
899 if (state
.backtracking
== 0) {
900 adaptor
.addChild(root_0
, numberLiteral7
.getTree());
906 // Grammar/CTFParser.g:238:5: enumConstant
908 root_0
= (CommonTree
) adaptor
.nil();
910 pushFollow(FOLLOW_enumConstant_in_constant438
);
911 enumConstant8
= enumConstant();
917 if (state
.backtracking
== 0) {
918 adaptor
.addChild(root_0
, enumConstant8
.getTree());
924 // Grammar/CTFParser.g:239:5: CHARACTER_LITERAL
926 root_0
= (CommonTree
) adaptor
.nil();
928 CHARACTER_LITERAL9
= (Token
) match(input
, CHARACTER_LITERAL
,
929 FOLLOW_CHARACTER_LITERAL_in_constant444
);
933 if (state
.backtracking
== 0) {
934 CHARACTER_LITERAL9_tree
= (CommonTree
) adaptor
935 .create(CHARACTER_LITERAL9
);
936 adaptor
.addChild(root_0
, CHARACTER_LITERAL9_tree
);
943 retval
.stop
= input
.LT(-1);
945 if (state
.backtracking
== 0) {
947 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
948 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
951 if (state
.backtracking
== 0) {
958 catch (RecognitionException e
) {
965 // $ANTLR end "constant"
967 public static class primaryExpression_return
extends ParserRuleReturnScope
{
971 public Object
getTree() {
976 // $ANTLR start "primaryExpression"
977 // Grammar/CTFParser.g:242:1: primaryExpression : ( ( IDENTIFIER )=>
978 // IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=>
979 // ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | ( STRING_LITERAL
980 // )=> STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
982 public final CTFParser
.primaryExpression_return
primaryExpression()
983 throws RecognitionException
{
984 CTFParser
.primaryExpression_return retval
= new CTFParser
.primaryExpression_return();
985 retval
.start
= input
.LT(1);
987 CommonTree root_0
= null;
989 Token IDENTIFIER10
= null;
990 Token STRING_LITERAL12
= null;
991 CTFParser
.ctfKeyword_return ctfKeyword11
= null;
993 CTFParser
.constant_return constant13
= null;
995 CommonTree IDENTIFIER10_tree
= null;
996 CommonTree STRING_LITERAL12_tree
= null;
997 RewriteRuleTokenStream stream_STRING_LITERAL
= new RewriteRuleTokenStream(
998 adaptor
, "token STRING_LITERAL");
999 RewriteRuleTokenStream stream_IDENTIFIER
= new RewriteRuleTokenStream(
1000 adaptor
, "token IDENTIFIER");
1001 RewriteRuleSubtreeStream stream_ctfKeyword
= new RewriteRuleSubtreeStream(
1002 adaptor
, "rule ctfKeyword");
1004 enter("primaryExpression");
1007 // Grammar/CTFParser.g:249:1: ( ( IDENTIFIER )=> IDENTIFIER -> ^(
1008 // UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=>
1009 // ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | (
1010 // STRING_LITERAL )=> STRING_LITERAL -> ^(
1011 // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | constant )
1013 switch (input
.LA(1)) {
1015 int LA5_1
= input
.LA(2);
1017 if ((synpred1_CTFParser())) {
1019 } else if ((true)) {
1022 if (state
.backtracking
> 0) {
1023 state
.failed
= true;
1026 NoViableAltException nvae
= new NoViableAltException("", 5,
1037 int LA5_2
= input
.LA(2);
1039 if ((synpred2_CTFParser())) {
1041 } else if ((true)) {
1044 if (state
.backtracking
> 0) {
1045 state
.failed
= true;
1048 NoViableAltException nvae
= new NoViableAltException("", 5,
1055 case STRING_LITERAL
: {
1056 int LA5_3
= input
.LA(2);
1058 if ((synpred3_CTFParser())) {
1060 } else if ((true)) {
1063 if (state
.backtracking
> 0) {
1064 state
.failed
= true;
1067 NoViableAltException nvae
= new NoViableAltException("", 5,
1076 case DECIMAL_LITERAL
:
1078 case CHARACTER_LITERAL
: {
1083 if (state
.backtracking
> 0) {
1084 state
.failed
= true;
1087 NoViableAltException nvae
= new NoViableAltException("", 5, 0,
1095 // Grammar/CTFParser.g:250:5: ( IDENTIFIER )=> IDENTIFIER
1097 IDENTIFIER10
= (Token
) match(input
, IDENTIFIER
,
1098 FOLLOW_IDENTIFIER_in_primaryExpression475
);
1102 if (state
.backtracking
== 0) {
1103 stream_IDENTIFIER
.add(IDENTIFIER10
);
1106 if (state
.backtracking
== 0) {
1107 debug_print("IDENTIFIER: "
1108 + (IDENTIFIER10
!= null ? IDENTIFIER10
.getText()
1113 // elements: IDENTIFIER
1115 // rule labels: retval
1116 // token list labels:
1117 // rule list labels:
1119 if (state
.backtracking
== 0) {
1120 retval
.tree
= root_0
;
1121 // RewriteRuleSubtreeStream stream_retval =
1122 new RewriteRuleSubtreeStream(
1123 adaptor
, "rule retval",
1124 retval
!= null ? retval
.tree
: null);
1126 root_0
= (CommonTree
) adaptor
.nil();
1127 // 250:83: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
1129 // Grammar/CTFParser.g:250:86: ^(
1130 // UNARY_EXPRESSION_STRING IDENTIFIER )
1132 CommonTree root_1
= (CommonTree
) adaptor
.nil();
1133 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
1134 .create(UNARY_EXPRESSION_STRING
,
1135 "UNARY_EXPRESSION_STRING"), root_1
);
1137 adaptor
.addChild(root_1
,
1138 stream_IDENTIFIER
.nextNode());
1140 adaptor
.addChild(root_0
, root_1
);
1145 retval
.tree
= root_0
;
1150 // Grammar/CTFParser.g:251:5: ( ctfKeyword )=> ctfKeyword
1152 pushFollow(FOLLOW_ctfKeyword_in_primaryExpression497
);
1153 ctfKeyword11
= ctfKeyword();
1159 if (state
.backtracking
== 0) {
1160 stream_ctfKeyword
.add(ctfKeyword11
.getTree());
1164 // elements: ctfKeyword
1166 // rule labels: retval
1167 // token list labels:
1168 // rule list labels:
1170 if (state
.backtracking
== 0) {
1171 retval
.tree
= root_0
;
1172 // RewriteRuleSubtreeStream stream_retval =
1173 new RewriteRuleSubtreeStream(
1174 adaptor
, "rule retval",
1175 retval
!= null ? retval
.tree
: null);
1177 root_0
= (CommonTree
) adaptor
.nil();
1178 // 251:32: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
1180 // Grammar/CTFParser.g:251:35: ^(
1181 // UNARY_EXPRESSION_STRING ctfKeyword )
1183 CommonTree root_1
= (CommonTree
) adaptor
.nil();
1184 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
1185 .create(UNARY_EXPRESSION_STRING
,
1186 "UNARY_EXPRESSION_STRING"), root_1
);
1188 adaptor
.addChild(root_1
,
1189 stream_ctfKeyword
.nextTree());
1191 adaptor
.addChild(root_0
, root_1
);
1196 retval
.tree
= root_0
;
1201 // Grammar/CTFParser.g:252:5: ( STRING_LITERAL )=> STRING_LITERAL
1203 STRING_LITERAL12
= (Token
) match(input
, STRING_LITERAL
,
1204 FOLLOW_STRING_LITERAL_in_primaryExpression517
);
1208 if (state
.backtracking
== 0) {
1209 stream_STRING_LITERAL
.add(STRING_LITERAL12
);
1212 if (state
.backtracking
== 0) {
1213 debug_print("STRING_LITERAL: "
1214 + (STRING_LITERAL12
!= null ? STRING_LITERAL12
1215 .getText() : null));
1219 // elements: STRING_LITERAL
1221 // rule labels: retval
1222 // token list labels:
1223 // rule list labels:
1225 if (state
.backtracking
== 0) {
1226 retval
.tree
= root_0
;
1227 new RewriteRuleSubtreeStream(
1228 adaptor
, "rule retval",
1229 retval
!= null ? retval
.tree
: null);
1231 root_0
= (CommonTree
) adaptor
.nil();
1232 // 252:99: -> ^( UNARY_EXPRESSION_STRING_QUOTES
1235 // Grammar/CTFParser.g:252:102: ^(
1236 // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
1238 CommonTree root_1
= (CommonTree
) adaptor
.nil();
1239 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
1240 .create(UNARY_EXPRESSION_STRING_QUOTES
,
1241 "UNARY_EXPRESSION_STRING_QUOTES"),
1244 adaptor
.addChild(root_1
,
1245 stream_STRING_LITERAL
.nextNode());
1247 adaptor
.addChild(root_0
, root_1
);
1252 retval
.tree
= root_0
;
1257 // Grammar/CTFParser.g:254:5: constant
1259 root_0
= (CommonTree
) adaptor
.nil();
1261 pushFollow(FOLLOW_constant_in_primaryExpression538
);
1262 constant13
= constant();
1268 if (state
.backtracking
== 0) {
1269 adaptor
.addChild(root_0
, constant13
.getTree());
1276 retval
.stop
= input
.LT(-1);
1278 if (state
.backtracking
== 0) {
1280 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
1281 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
1284 if (state
.backtracking
== 0) {
1286 exit("primaryExpression");
1291 catch (RecognitionException e
) {
1297 // $ANTLR end "primaryExpression"
1299 public static class reference_return
extends ParserRuleReturnScope
{
1303 public Object
getTree() {
1308 // $ANTLR start "reference"
1309 // Grammar/CTFParser.g:257:1: reference : (ref= DOT | ref= ARROW )
1310 // IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) ;
1311 public final CTFParser
.reference_return
reference()
1312 throws RecognitionException
{
1313 CTFParser
.reference_return retval
= new CTFParser
.reference_return();
1314 retval
.start
= input
.LT(1);
1316 CommonTree root_0
= null;
1319 Token IDENTIFIER14
= null;
1321 CommonTree ref_tree
= null;
1322 CommonTree IDENTIFIER14_tree
= null;
1323 RewriteRuleTokenStream stream_ARROW
= new RewriteRuleTokenStream(
1324 adaptor
, "token ARROW");
1325 RewriteRuleTokenStream stream_DOT
= new RewriteRuleTokenStream(adaptor
,
1327 RewriteRuleTokenStream stream_IDENTIFIER
= new RewriteRuleTokenStream(
1328 adaptor
, "token IDENTIFIER");
1333 // Grammar/CTFParser.g:265:1: ( (ref= DOT | ref= ARROW ) IDENTIFIER
1334 // -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) )
1335 // Grammar/CTFParser.g:266:3: (ref= DOT | ref= ARROW ) IDENTIFIER
1337 // Grammar/CTFParser.g:266:3: (ref= DOT | ref= ARROW )
1339 int LA6_0
= input
.LA(1);
1341 if ((LA6_0
== DOT
)) {
1343 } else if ((LA6_0
== ARROW
)) {
1346 if (state
.backtracking
> 0) {
1347 state
.failed
= true;
1350 NoViableAltException nvae
= new NoViableAltException("", 6,
1357 // Grammar/CTFParser.g:266:4: ref= DOT
1359 ref
= (Token
) match(input
, DOT
, FOLLOW_DOT_in_reference564
);
1363 if (state
.backtracking
== 0) {
1364 stream_DOT
.add(ref
);
1370 // Grammar/CTFParser.g:266:14: ref= ARROW
1372 ref
= (Token
) match(input
, ARROW
,
1373 FOLLOW_ARROW_in_reference570
);
1377 if (state
.backtracking
== 0) {
1378 stream_ARROW
.add(ref
);
1386 IDENTIFIER14
= (Token
) match(input
, IDENTIFIER
,
1387 FOLLOW_IDENTIFIER_in_reference573
);
1391 if (state
.backtracking
== 0) {
1392 stream_IDENTIFIER
.add(IDENTIFIER14
);
1396 // elements: IDENTIFIER, ref
1397 // token labels: ref
1398 // rule labels: retval
1399 // token list labels:
1400 // rule list labels:
1402 if (state
.backtracking
== 0) {
1403 retval
.tree
= root_0
;
1404 RewriteRuleTokenStream stream_ref
= new RewriteRuleTokenStream(
1405 adaptor
, "token ref", ref
);
1406 // RewriteRuleSubtreeStream stream_retval =
1407 new RewriteRuleSubtreeStream(
1408 adaptor
, "rule retval",
1409 retval
!= null ? retval
.tree
: null);
1411 root_0
= (CommonTree
) adaptor
.nil();
1412 // 266:36: -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER
1415 // Grammar/CTFParser.g:266:39: ^( $ref ^(
1416 // UNARY_EXPRESSION_STRING IDENTIFIER ) )
1418 CommonTree root_1
= (CommonTree
) adaptor
.nil();
1419 root_1
= (CommonTree
) adaptor
.becomeRoot(
1420 stream_ref
.nextNode(), root_1
);
1422 // Grammar/CTFParser.g:266:46: ^(
1423 // UNARY_EXPRESSION_STRING IDENTIFIER )
1425 CommonTree root_2
= (CommonTree
) adaptor
.nil();
1426 root_2
= (CommonTree
) adaptor
.becomeRoot(
1427 adaptor
.create(UNARY_EXPRESSION_STRING
,
1428 "UNARY_EXPRESSION_STRING"),
1431 adaptor
.addChild(root_2
,
1432 stream_IDENTIFIER
.nextNode());
1434 adaptor
.addChild(root_1
, root_2
);
1437 adaptor
.addChild(root_0
, root_1
);
1442 retval
.tree
= root_0
;
1446 retval
.stop
= input
.LT(-1);
1448 if (state
.backtracking
== 0) {
1450 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
1451 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
1454 if (state
.backtracking
== 0) {
1456 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
1462 catch (RecognitionException e
) {
1468 // $ANTLR end "reference"
1470 public static class postfixExpressionSuffix_return
extends
1471 ParserRuleReturnScope
{
1475 public Object
getTree() {
1480 // $ANTLR start "postfixExpressionSuffix"
1481 // Grammar/CTFParser.g:269:1: postfixExpressionSuffix : ( ( OPENBRAC
1482 // unaryExpression CLOSEBRAC ) | reference );
1483 public final CTFParser
.postfixExpressionSuffix_return
postfixExpressionSuffix()
1484 throws RecognitionException
{
1485 CTFParser
.postfixExpressionSuffix_return retval
= new CTFParser
.postfixExpressionSuffix_return();
1486 retval
.start
= input
.LT(1);
1488 CommonTree root_0
= null;
1490 Token OPENBRAC15
= null;
1491 Token CLOSEBRAC17
= null;
1492 CTFParser
.unaryExpression_return unaryExpression16
= null;
1494 CTFParser
.reference_return reference18
= null;
1496 CommonTree OPENBRAC15_tree
= null;
1497 CommonTree CLOSEBRAC17_tree
= null;
1499 enter("postfixExpressionSuffix");
1502 // Grammar/CTFParser.g:276:1: ( ( OPENBRAC unaryExpression CLOSEBRAC
1505 int LA7_0
= input
.LA(1);
1507 if ((LA7_0
== OPENBRAC
)) {
1509 } else if ((((LA7_0
>= ARROW
) && (LA7_0
<= DOT
)))) {
1512 if (state
.backtracking
> 0) {
1513 state
.failed
= true;
1516 NoViableAltException nvae
= new NoViableAltException("", 7, 0,
1523 // Grammar/CTFParser.g:277:5: ( OPENBRAC unaryExpression CLOSEBRAC )
1525 root_0
= (CommonTree
) adaptor
.nil();
1527 // Grammar/CTFParser.g:277:5: ( OPENBRAC unaryExpression
1529 // Grammar/CTFParser.g:277:6: OPENBRAC unaryExpression CLOSEBRAC
1531 OPENBRAC15
= (Token
) match(input
, OPENBRAC
,
1532 FOLLOW_OPENBRAC_in_postfixExpressionSuffix612
);
1536 if (state
.backtracking
== 0) {
1537 OPENBRAC15_tree
= (CommonTree
) adaptor
1538 .create(OPENBRAC15
);
1539 adaptor
.addChild(root_0
, OPENBRAC15_tree
);
1541 pushFollow(FOLLOW_unaryExpression_in_postfixExpressionSuffix614
);
1542 unaryExpression16
= unaryExpression();
1548 if (state
.backtracking
== 0) {
1549 adaptor
.addChild(root_0
, unaryExpression16
.getTree());
1551 // CLOSEBRAC17 = (Token)
1552 match(input
, CLOSEBRAC
,
1553 FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix616
);
1563 // Grammar/CTFParser.g:278:5: reference
1565 root_0
= (CommonTree
) adaptor
.nil();
1567 pushFollow(FOLLOW_reference_in_postfixExpressionSuffix624
);
1568 reference18
= reference();
1574 if (state
.backtracking
== 0) {
1575 adaptor
.addChild(root_0
, reference18
.getTree());
1582 retval
.stop
= input
.LT(-1);
1584 if (state
.backtracking
== 0) {
1586 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
1587 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
1590 if (state
.backtracking
== 0) {
1592 exit("postfixExpressionSuffix");
1597 catch (RecognitionException e
) {
1603 // $ANTLR end "postfixExpressionSuffix"
1605 public static class postfixExpression_return
extends ParserRuleReturnScope
{
1609 public Object
getTree() {
1614 // $ANTLR start "postfixExpression"
1615 // Grammar/CTFParser.g:281:1: postfixExpression : ( ( primaryExpression ) (
1616 // postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) (
1617 // postfixExpressionSuffix )+ ) );
1618 public final CTFParser
.postfixExpression_return
postfixExpression()
1619 throws RecognitionException
{
1620 CTFParser
.postfixExpression_return retval
= new CTFParser
.postfixExpression_return();
1621 retval
.start
= input
.LT(1);
1623 CommonTree root_0
= null;
1625 CTFParser
.primaryExpression_return primaryExpression19
= null;
1627 CTFParser
.postfixExpressionSuffix_return postfixExpressionSuffix20
= null;
1629 CTFParser
.ctfSpecifierHead_return ctfSpecifierHead21
= null;
1631 CTFParser
.postfixExpressionSuffix_return postfixExpressionSuffix22
= null;
1633 enter("postfixExpression");
1636 // Grammar/CTFParser.g:288:1: ( ( primaryExpression ) (
1637 // postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) (
1638 // postfixExpressionSuffix )+ ) )
1640 alt10
= dfa10
.predict(input
);
1643 // Grammar/CTFParser.g:289:3: ( primaryExpression ) (
1644 // postfixExpressionSuffix )*
1646 root_0
= (CommonTree
) adaptor
.nil();
1648 // Grammar/CTFParser.g:289:3: ( primaryExpression )
1649 // Grammar/CTFParser.g:289:4: primaryExpression
1651 pushFollow(FOLLOW_primaryExpression_in_postfixExpression648
);
1652 primaryExpression19
= primaryExpression();
1658 if (state
.backtracking
== 0) {
1659 adaptor
.addChild(root_0
, primaryExpression19
.getTree());
1664 // Grammar/CTFParser.g:289:23: ( postfixExpressionSuffix )*
1667 int LA8_0
= input
.LA(1);
1669 if (((LA8_0
== OPENBRAC
) || ((LA8_0
>= ARROW
) && (LA8_0
<= DOT
)))) {
1675 // Grammar/CTFParser.g:289:24: postfixExpressionSuffix
1677 pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression652
);
1678 postfixExpressionSuffix20
= postfixExpressionSuffix();
1684 if (state
.backtracking
== 0) {
1685 adaptor
.addChild(root_0
,
1686 postfixExpressionSuffix20
.getTree());
1700 // Grammar/CTFParser.g:290:3: ( ( ctfSpecifierHead ) (
1701 // postfixExpressionSuffix )+ )
1703 root_0
= (CommonTree
) adaptor
.nil();
1705 // Grammar/CTFParser.g:290:3: ( ( ctfSpecifierHead ) (
1706 // postfixExpressionSuffix )+ )
1707 // Grammar/CTFParser.g:290:4: ( ctfSpecifierHead ) (
1708 // postfixExpressionSuffix )+
1710 // Grammar/CTFParser.g:290:4: ( ctfSpecifierHead )
1711 // Grammar/CTFParser.g:290:5: ctfSpecifierHead
1713 pushFollow(FOLLOW_ctfSpecifierHead_in_postfixExpression661
);
1714 ctfSpecifierHead21
= ctfSpecifierHead();
1720 if (state
.backtracking
== 0) {
1721 adaptor
.addChild(root_0
,
1722 ctfSpecifierHead21
.getTree());
1727 // Grammar/CTFParser.g:290:24: ( postfixExpressionSuffix )+
1731 int LA9_0
= input
.LA(1);
1733 if (((LA9_0
== OPENBRAC
) || ((LA9_0
>= ARROW
) && (LA9_0
<= DOT
)))) {
1739 // Grammar/CTFParser.g:290:25: postfixExpressionSuffix
1741 pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression666
);
1742 postfixExpressionSuffix22
= postfixExpressionSuffix();
1748 if (state
.backtracking
== 0) {
1749 adaptor
.addChild(root_0
,
1750 postfixExpressionSuffix22
.getTree());
1760 if (state
.backtracking
> 0) {
1761 state
.failed
= true;
1764 EarlyExitException eee
= new EarlyExitException(9,
1777 retval
.stop
= input
.LT(-1);
1779 if (state
.backtracking
== 0) {
1781 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
1782 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
1785 if (state
.backtracking
== 0) {
1787 exit("postfixExpression");
1792 catch (RecognitionException e
) {
1798 // $ANTLR end "postfixExpression"
1800 public static class unaryExpression_return
extends ParserRuleReturnScope
{
1804 public Object
getTree() {
1809 // $ANTLR start "unaryExpression"
1810 // Grammar/CTFParser.g:293:1: unaryExpression : postfixExpression ;
1811 public final CTFParser
.unaryExpression_return
unaryExpression()
1812 throws RecognitionException
{
1813 CTFParser
.unaryExpression_return retval
= new CTFParser
.unaryExpression_return();
1814 retval
.start
= input
.LT(1);
1816 CommonTree root_0
= null;
1818 CTFParser
.postfixExpression_return postfixExpression23
= null;
1820 enter("unaryExpression");
1823 // Grammar/CTFParser.g:300:1: ( postfixExpression )
1824 // Grammar/CTFParser.g:303:5: postfixExpression
1826 root_0
= (CommonTree
) adaptor
.nil();
1828 pushFollow(FOLLOW_postfixExpression_in_unaryExpression700
);
1829 postfixExpression23
= postfixExpression();
1835 if (state
.backtracking
== 0) {
1836 adaptor
.addChild(root_0
, postfixExpression23
.getTree());
1841 retval
.stop
= input
.LT(-1);
1843 if (state
.backtracking
== 0) {
1845 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
1846 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
1849 if (state
.backtracking
== 0) {
1851 exit("unaryExpression");
1856 catch (RecognitionException e
) {
1862 // $ANTLR end "unaryExpression"
1864 public static class enumConstant_return
extends ParserRuleReturnScope
{
1868 public Object
getTree() {
1873 // $ANTLR start "enumConstant"
1874 // Grammar/CTFParser.g:306:1: enumConstant : ( STRING_LITERAL -> ^(
1875 // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER -> ^(
1876 // UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^(
1877 // UNARY_EXPRESSION_STRING ctfKeyword ) );
1878 public final CTFParser
.enumConstant_return
enumConstant()
1879 throws RecognitionException
{
1880 CTFParser
.enumConstant_return retval
= new CTFParser
.enumConstant_return();
1881 retval
.start
= input
.LT(1);
1883 CommonTree root_0
= null;
1885 Token STRING_LITERAL24
= null;
1886 Token IDENTIFIER25
= null;
1887 CTFParser
.ctfKeyword_return ctfKeyword26
= null;
1889 CommonTree STRING_LITERAL24_tree
= null;
1890 CommonTree IDENTIFIER25_tree
= null;
1891 RewriteRuleTokenStream stream_STRING_LITERAL
= new RewriteRuleTokenStream(
1892 adaptor
, "token STRING_LITERAL");
1893 RewriteRuleTokenStream stream_IDENTIFIER
= new RewriteRuleTokenStream(
1894 adaptor
, "token IDENTIFIER");
1895 RewriteRuleSubtreeStream stream_ctfKeyword
= new RewriteRuleSubtreeStream(
1896 adaptor
, "rule ctfKeyword");
1898 enter("enumConstant");
1901 // Grammar/CTFParser.g:314:1: ( STRING_LITERAL -> ^(
1902 // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER ->
1903 // ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^(
1904 // UNARY_EXPRESSION_STRING ctfKeyword ) )
1906 switch (input
.LA(1)) {
1907 case STRING_LITERAL
: {
1923 if (state
.backtracking
> 0) {
1924 state
.failed
= true;
1927 NoViableAltException nvae
= new NoViableAltException("", 11, 0,
1935 // Grammar/CTFParser.g:315:5: STRING_LITERAL
1937 STRING_LITERAL24
= (Token
) match(input
, STRING_LITERAL
,
1938 FOLLOW_STRING_LITERAL_in_enumConstant725
);
1942 if (state
.backtracking
== 0) {
1943 stream_STRING_LITERAL
.add(STRING_LITERAL24
);
1947 // elements: STRING_LITERAL
1949 // rule labels: retval
1950 // token list labels:
1951 // rule list labels:
1953 if (state
.backtracking
== 0) {
1954 retval
.tree
= root_0
;
1955 // RewriteRuleSubtreeStream stream_retval =
1956 new RewriteRuleSubtreeStream(
1957 adaptor
, "rule retval",
1958 retval
!= null ? retval
.tree
: null);
1960 root_0
= (CommonTree
) adaptor
.nil();
1961 // 315:20: -> ^( UNARY_EXPRESSION_STRING_QUOTES
1964 // Grammar/CTFParser.g:315:23: ^(
1965 // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
1967 CommonTree root_1
= (CommonTree
) adaptor
.nil();
1968 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
1969 .create(UNARY_EXPRESSION_STRING_QUOTES
,
1970 "UNARY_EXPRESSION_STRING_QUOTES"),
1973 adaptor
.addChild(root_1
,
1974 stream_STRING_LITERAL
.nextNode());
1976 adaptor
.addChild(root_0
, root_1
);
1981 retval
.tree
= root_0
;
1986 // Grammar/CTFParser.g:316:7: IDENTIFIER
1988 IDENTIFIER25
= (Token
) match(input
, IDENTIFIER
,
1989 FOLLOW_IDENTIFIER_in_enumConstant741
);
1993 if (state
.backtracking
== 0) {
1994 stream_IDENTIFIER
.add(IDENTIFIER25
);
1998 // elements: IDENTIFIER
2000 // rule labels: retval
2001 // token list labels:
2002 // rule list labels:
2004 if (state
.backtracking
== 0) {
2005 retval
.tree
= root_0
;
2006 // RewriteRuleSubtreeStream stream_retval =
2007 new RewriteRuleSubtreeStream(
2008 adaptor
, "rule retval",
2009 retval
!= null ? retval
.tree
: null);
2011 root_0
= (CommonTree
) adaptor
.nil();
2012 // 316:18: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
2014 // Grammar/CTFParser.g:316:21: ^(
2015 // UNARY_EXPRESSION_STRING IDENTIFIER )
2017 CommonTree root_1
= (CommonTree
) adaptor
.nil();
2018 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
2019 .create(UNARY_EXPRESSION_STRING
,
2020 "UNARY_EXPRESSION_STRING"), root_1
);
2022 adaptor
.addChild(root_1
,
2023 stream_IDENTIFIER
.nextNode());
2025 adaptor
.addChild(root_0
, root_1
);
2030 retval
.tree
= root_0
;
2035 // Grammar/CTFParser.g:317:7: ctfKeyword
2037 pushFollow(FOLLOW_ctfKeyword_in_enumConstant757
);
2038 ctfKeyword26
= ctfKeyword();
2044 if (state
.backtracking
== 0) {
2045 stream_ctfKeyword
.add(ctfKeyword26
.getTree());
2049 // elements: ctfKeyword
2051 // rule labels: retval
2052 // token list labels:
2053 // rule list labels:
2055 if (state
.backtracking
== 0) {
2056 retval
.tree
= root_0
;
2057 // RewriteRuleSubtreeStream stream_retval =
2058 new RewriteRuleSubtreeStream(
2059 adaptor
, "rule retval",
2060 retval
!= null ? retval
.tree
: null);
2062 root_0
= (CommonTree
) adaptor
.nil();
2063 // 317:18: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
2065 // Grammar/CTFParser.g:317:21: ^(
2066 // UNARY_EXPRESSION_STRING ctfKeyword )
2068 CommonTree root_1
= (CommonTree
) adaptor
.nil();
2069 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
2070 .create(UNARY_EXPRESSION_STRING
,
2071 "UNARY_EXPRESSION_STRING"), root_1
);
2073 adaptor
.addChild(root_1
,
2074 stream_ctfKeyword
.nextTree());
2076 adaptor
.addChild(root_0
, root_1
);
2081 retval
.tree
= root_0
;
2087 retval
.stop
= input
.LT(-1);
2089 if (state
.backtracking
== 0) {
2091 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
2092 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
2095 if (state
.backtracking
== 0) {
2097 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
2098 exit("enumConstant");
2103 catch (RecognitionException e
) {
2109 // $ANTLR end "enumConstant"
2111 public static class declaration_return
extends ParserRuleReturnScope
{
2115 public Object
getTree() {
2120 // $ANTLR start "declaration"
2121 // Grammar/CTFParser.g:321:1: declaration : ( ( declarationSpecifiers (
2122 // declaratorList )? TERM ) -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF
2123 // declaratorList declarationSpecifiers ) ) -> ^( DECLARATION
2124 // declarationSpecifiers ( declaratorList )? ) | ( ctfSpecifier TERM ) );
2125 public final CTFParser
.declaration_return
declaration()
2126 throws RecognitionException
{
2127 CTFParser
.declaration_return retval
= new CTFParser
.declaration_return();
2128 retval
.start
= input
.LT(1);
2130 CommonTree root_0
= null;
2132 Token TERM29
= null;
2133 Token TERM31
= null;
2134 CTFParser
.declarationSpecifiers_return declarationSpecifiers27
= null;
2136 CTFParser
.declaratorList_return declaratorList28
= null;
2138 CTFParser
.ctfSpecifier_return ctfSpecifier30
= null;
2140 CommonTree TERM29_tree
= null;
2141 CommonTree TERM31_tree
= null;
2142 RewriteRuleTokenStream stream_TERM
= new RewriteRuleTokenStream(
2143 adaptor
, "token TERM");
2144 RewriteRuleSubtreeStream stream_declaratorList
= new RewriteRuleSubtreeStream(
2145 adaptor
, "rule declaratorList");
2146 RewriteRuleSubtreeStream stream_declarationSpecifiers
= new RewriteRuleSubtreeStream(
2147 adaptor
, "rule declarationSpecifiers");
2149 enter("declaration");
2152 // Grammar/CTFParser.g:330:1: ( ( declarationSpecifiers (
2153 // declaratorList )? TERM ) -> {inTypedef()}? ^( DECLARATION ^(
2154 // TYPEDEF declaratorList declarationSpecifiers ) ) -> ^(
2155 // DECLARATION declarationSpecifiers ( declaratorList )? ) | (
2156 // ctfSpecifier TERM ) )
2158 int LA13_0
= input
.LA(1);
2160 if ((((LA13_0
>= CONSTTOK
) && (LA13_0
<= ENUMTOK
))
2161 || ((LA13_0
>= FLOATINGPOINTTOK
) && (LA13_0
<= SIGNEDTOK
))
2162 || ((LA13_0
>= STRINGTOK
) && (LA13_0
<= STRUCTTOK
)) || ((LA13_0
>= TYPEDEFTOK
) && (LA13_0
<= IMAGINARYTOK
)))) {
2164 } else if ((LA13_0
== IDENTIFIER
)
2165 && ((inTypealiasAlias() || isTypeName(input
.LT(1).getText())))) {
2167 } else if (((LA13_0
== EVENTTOK
) || (LA13_0
== STREAMTOK
)
2168 || ((LA13_0
>= TRACETOK
) && (LA13_0
<= TYPEALIASTOK
)) || ((LA13_0
>= ENVTOK
) && (LA13_0
<= CLOCKTOK
)))) {
2171 if (state
.backtracking
> 0) {
2172 state
.failed
= true;
2175 NoViableAltException nvae
= new NoViableAltException("", 13, 0,
2182 // Grammar/CTFParser.g:331:3: ( declarationSpecifiers (
2183 // declaratorList )? TERM )
2185 // Grammar/CTFParser.g:331:3: ( declarationSpecifiers (
2186 // declaratorList )? TERM )
2187 // Grammar/CTFParser.g:331:4: declarationSpecifiers (
2188 // declaratorList )? TERM
2190 pushFollow(FOLLOW_declarationSpecifiers_in_declaration790
);
2191 declarationSpecifiers27
= declarationSpecifiers();
2197 if (state
.backtracking
== 0) {
2198 stream_declarationSpecifiers
2199 .add(declarationSpecifiers27
.getTree());
2201 // Grammar/CTFParser.g:331:26: ( declaratorList )?
2203 int LA12_0
= input
.LA(1);
2205 if (((LA12_0
== POINTER
) || (LA12_0
== IDENTIFIER
))) {
2210 // Grammar/CTFParser.g:331:26: declaratorList
2212 pushFollow(FOLLOW_declaratorList_in_declaration792
);
2213 declaratorList28
= declaratorList();
2219 if (state
.backtracking
== 0) {
2220 stream_declaratorList
.add(declaratorList28
2229 TERM29
= (Token
) match(input
, TERM
,
2230 FOLLOW_TERM_in_declaration795
);
2234 if (state
.backtracking
== 0) {
2235 stream_TERM
.add(TERM29
);
2241 // elements: declaratorList, declaratorList,
2242 // declarationSpecifiers, declarationSpecifiers
2244 // rule labels: retval
2245 // token list labels:
2246 // rule list labels:
2248 if (state
.backtracking
== 0) {
2249 retval
.tree
= root_0
;
2250 // RewriteRuleSubtreeStream stream_retval =
2251 new RewriteRuleSubtreeStream(
2252 adaptor
, "rule retval",
2253 retval
!= null ? retval
.tree
: null);
2255 root_0
= (CommonTree
) adaptor
.nil();
2256 // 334:3: -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF
2257 // declaratorList declarationSpecifiers ) )
2259 // Grammar/CTFParser.g:334:21: ^( DECLARATION ^( TYPEDEF
2260 // declaratorList declarationSpecifiers ) )
2262 CommonTree root_1
= (CommonTree
) adaptor
.nil();
2263 root_1
= (CommonTree
) adaptor
.becomeRoot(
2264 adaptor
.create(DECLARATION
, "DECLARATION"),
2267 // Grammar/CTFParser.g:334:35: ^( TYPEDEF
2268 // declaratorList declarationSpecifiers )
2270 CommonTree root_2
= (CommonTree
) adaptor
.nil();
2271 root_2
= (CommonTree
) adaptor
.becomeRoot(
2272 adaptor
.create(TYPEDEF
, "TYPEDEF"),
2275 adaptor
.addChild(root_2
,
2276 stream_declaratorList
.nextTree());
2277 adaptor
.addChild(root_2
,
2278 stream_declarationSpecifiers
.nextTree());
2280 adaptor
.addChild(root_1
, root_2
);
2283 adaptor
.addChild(root_0
, root_1
);
2286 } else // 335:3: -> ^( DECLARATION declarationSpecifiers (
2287 // declaratorList )? )
2289 // Grammar/CTFParser.g:335:6: ^( DECLARATION
2290 // declarationSpecifiers ( declaratorList )? )
2292 CommonTree root_1
= (CommonTree
) adaptor
.nil();
2293 root_1
= (CommonTree
) adaptor
.becomeRoot(
2294 adaptor
.create(DECLARATION
, "DECLARATION"),
2297 adaptor
.addChild(root_1
,
2298 stream_declarationSpecifiers
.nextTree());
2299 // Grammar/CTFParser.g:335:42: ( declaratorList )?
2300 if (stream_declaratorList
.hasNext()) {
2301 adaptor
.addChild(root_1
,
2302 stream_declaratorList
.nextTree());
2305 stream_declaratorList
.reset();
2307 adaptor
.addChild(root_0
, root_1
);
2312 retval
.tree
= root_0
;
2317 // Grammar/CTFParser.g:337:5: ( ctfSpecifier TERM )
2319 root_0
= (CommonTree
) adaptor
.nil();
2321 // Grammar/CTFParser.g:337:5: ( ctfSpecifier TERM )
2322 // Grammar/CTFParser.g:337:6: ctfSpecifier TERM
2324 pushFollow(FOLLOW_ctfSpecifier_in_declaration844
);
2325 ctfSpecifier30
= ctfSpecifier();
2331 if (state
.backtracking
== 0) {
2332 adaptor
.addChild(root_0
, ctfSpecifier30
.getTree());
2336 FOLLOW_TERM_in_declaration846
);
2347 retval
.stop
= input
.LT(-1);
2349 if (state
.backtracking
== 0) {
2351 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
2352 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
2355 if (state
.backtracking
== 0) {
2357 exit("declaration");
2365 catch (RecognitionException e
) {
2371 // $ANTLR end "declaration"
2373 public static class declarationSpecifiers_return
extends
2374 ParserRuleReturnScope
{
2378 public Object
getTree() {
2383 // $ANTLR start "declarationSpecifiers"
2384 // Grammar/CTFParser.g:340:1: declarationSpecifiers : (
2385 // storageClassSpecifier | typeQualifier | typeSpecifier )+ -> ^(
2386 // TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
2387 public final CTFParser
.declarationSpecifiers_return
declarationSpecifiers()
2388 throws RecognitionException
{
2389 CTFParser
.declarationSpecifiers_return retval
= new CTFParser
.declarationSpecifiers_return();
2390 retval
.start
= input
.LT(1);
2392 CommonTree root_0
= null;
2394 CTFParser
.storageClassSpecifier_return storageClassSpecifier32
= null;
2396 CTFParser
.typeQualifier_return typeQualifier33
= null;
2398 CTFParser
.typeSpecifier_return typeSpecifier34
= null;
2400 RewriteRuleSubtreeStream stream_typeSpecifier
= new RewriteRuleSubtreeStream(
2401 adaptor
, "rule typeSpecifier");
2402 RewriteRuleSubtreeStream stream_typeQualifier
= new RewriteRuleSubtreeStream(
2403 adaptor
, "rule typeQualifier");
2404 RewriteRuleSubtreeStream stream_storageClassSpecifier
= new RewriteRuleSubtreeStream(
2405 adaptor
, "rule storageClassSpecifier");
2407 enter("declarationSpecifiers");
2410 // Grammar/CTFParser.g:348:1: ( ( storageClassSpecifier |
2411 // typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST (
2412 // typeQualifier )* ( typeSpecifier )* ) )
2413 // Grammar/CTFParser.g:349:3: ( storageClassSpecifier |
2414 // typeQualifier | typeSpecifier )+
2416 // Grammar/CTFParser.g:349:3: ( storageClassSpecifier |
2417 // typeQualifier | typeSpecifier )+
2421 switch (input
.LA(1)) {
2423 int LA14_2
= input
.LA(2);
2425 if (((inTypealiasAlias() || isTypeName(input
.LT(1)
2443 case FLOATINGPOINTTOK
:
2457 case IMAGINARYTOK
: {
2466 // Grammar/CTFParser.g:352:6: storageClassSpecifier
2468 pushFollow(FOLLOW_storageClassSpecifier_in_declarationSpecifiers891
);
2469 storageClassSpecifier32
= storageClassSpecifier();
2475 if (state
.backtracking
== 0) {
2476 stream_storageClassSpecifier
2477 .add(storageClassSpecifier32
.getTree());
2483 // Grammar/CTFParser.g:353:6: typeQualifier
2485 pushFollow(FOLLOW_typeQualifier_in_declarationSpecifiers898
);
2486 typeQualifier33
= typeQualifier();
2492 if (state
.backtracking
== 0) {
2493 stream_typeQualifier
.add(typeQualifier33
.getTree());
2499 // Grammar/CTFParser.g:354:6: typeSpecifier
2501 pushFollow(FOLLOW_typeSpecifier_in_declarationSpecifiers905
);
2502 typeSpecifier34
= typeSpecifier();
2508 if (state
.backtracking
== 0) {
2509 stream_typeSpecifier
.add(typeSpecifier34
.getTree());
2519 if (state
.backtracking
> 0) {
2520 state
.failed
= true;
2523 EarlyExitException eee
= new EarlyExitException(14,
2531 // elements: typeQualifier, typeSpecifier
2533 // rule labels: retval
2534 // token list labels:
2535 // rule list labels:
2537 if (state
.backtracking
== 0) {
2538 retval
.tree
= root_0
;
2539 // RewriteRuleSubtreeStream stream_retval =
2540 new RewriteRuleSubtreeStream(
2541 adaptor
, "rule retval",
2542 retval
!= null ? retval
.tree
: null);
2544 root_0
= (CommonTree
) adaptor
.nil();
2545 // 355:6: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
2546 // typeSpecifier )* )
2548 // Grammar/CTFParser.g:355:9: ^( TYPE_SPECIFIER_LIST (
2549 // typeQualifier )* ( typeSpecifier )* )
2551 CommonTree root_1
= (CommonTree
) adaptor
.nil();
2552 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
2553 .create(TYPE_SPECIFIER_LIST
,
2554 "TYPE_SPECIFIER_LIST"), root_1
);
2556 // Grammar/CTFParser.g:355:31: ( typeQualifier )*
2557 while (stream_typeQualifier
.hasNext()) {
2558 adaptor
.addChild(root_1
,
2559 stream_typeQualifier
.nextTree());
2562 stream_typeQualifier
.reset();
2563 // Grammar/CTFParser.g:355:46: ( typeSpecifier )*
2564 while (stream_typeSpecifier
.hasNext()) {
2565 adaptor
.addChild(root_1
,
2566 stream_typeSpecifier
.nextTree());
2569 stream_typeSpecifier
.reset();
2571 adaptor
.addChild(root_0
, root_1
);
2576 retval
.tree
= root_0
;
2580 retval
.stop
= input
.LT(-1);
2582 if (state
.backtracking
== 0) {
2584 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
2585 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
2588 if (state
.backtracking
== 0) {
2590 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
2591 exit("declarationSpecifiers");
2596 catch (RecognitionException e
) {
2603 // $ANTLR end "declarationSpecifiers"
2605 public static class declaratorList_return
extends ParserRuleReturnScope
{
2609 public Object
getTree() {
2614 // $ANTLR start "declaratorList"
2615 // Grammar/CTFParser.g:358:1: declaratorList : declarator ( SEPARATOR
2616 // declarator )* -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) ;
2617 public final CTFParser
.declaratorList_return
declaratorList()
2618 throws RecognitionException
{
2619 CTFParser
.declaratorList_return retval
= new CTFParser
.declaratorList_return();
2620 retval
.start
= input
.LT(1);
2622 CommonTree root_0
= null;
2624 Token SEPARATOR36
= null;
2625 CTFParser
.declarator_return declarator35
= null;
2627 CTFParser
.declarator_return declarator37
= null;
2629 CommonTree SEPARATOR36_tree
= null;
2630 RewriteRuleTokenStream stream_SEPARATOR
= new RewriteRuleTokenStream(
2631 adaptor
, "token SEPARATOR");
2632 RewriteRuleSubtreeStream stream_declarator
= new RewriteRuleSubtreeStream(
2633 adaptor
, "rule declarator");
2635 enter("declaratorList");
2638 // Grammar/CTFParser.g:365:1: ( declarator ( SEPARATOR declarator )*
2639 // -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) )
2640 // Grammar/CTFParser.g:366:3: declarator ( SEPARATOR declarator )*
2642 pushFollow(FOLLOW_declarator_in_declaratorList946
);
2643 declarator35
= declarator();
2649 if (state
.backtracking
== 0) {
2650 stream_declarator
.add(declarator35
.getTree());
2652 // Grammar/CTFParser.g:366:14: ( SEPARATOR declarator )*
2655 int LA15_0
= input
.LA(1);
2657 if ((LA15_0
== SEPARATOR
)) {
2663 // Grammar/CTFParser.g:366:15: SEPARATOR declarator
2665 SEPARATOR36
= (Token
) match(input
, SEPARATOR
,
2666 FOLLOW_SEPARATOR_in_declaratorList949
);
2670 if (state
.backtracking
== 0) {
2671 stream_SEPARATOR
.add(SEPARATOR36
);
2674 pushFollow(FOLLOW_declarator_in_declaratorList951
);
2675 declarator37
= declarator();
2681 if (state
.backtracking
== 0) {
2682 stream_declarator
.add(declarator37
.getTree());
2694 // elements: declarator
2696 // rule labels: retval
2697 // token list labels:
2698 // rule list labels:
2700 if (state
.backtracking
== 0) {
2701 retval
.tree
= root_0
;
2702 // RewriteRuleSubtreeStream stream_retval =
2703 new RewriteRuleSubtreeStream(
2704 adaptor
, "rule retval",
2705 retval
!= null ? retval
.tree
: null);
2707 root_0
= (CommonTree
) adaptor
.nil();
2708 // 366:38: -> ^( TYPE_DECLARATOR_LIST ( declarator )+ )
2710 // Grammar/CTFParser.g:366:41: ^( TYPE_DECLARATOR_LIST (
2713 CommonTree root_1
= (CommonTree
) adaptor
.nil();
2714 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
2715 .create(TYPE_DECLARATOR_LIST
,
2716 "TYPE_DECLARATOR_LIST"), root_1
);
2718 if (!(stream_declarator
.hasNext())) {
2719 throw new RewriteEarlyExitException();
2721 while (stream_declarator
.hasNext()) {
2722 adaptor
.addChild(root_1
,
2723 stream_declarator
.nextTree());
2726 stream_declarator
.reset();
2728 adaptor
.addChild(root_0
, root_1
);
2733 retval
.tree
= root_0
;
2737 retval
.stop
= input
.LT(-1);
2739 if (state
.backtracking
== 0) {
2741 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
2742 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
2745 if (state
.backtracking
== 0) {
2747 exit("declaratorList");
2752 catch (RecognitionException e
) {
2759 // $ANTLR end "declaratorList"
2761 public static class abstractDeclaratorList_return
extends
2762 ParserRuleReturnScope
{
2766 public Object
getTree() {
2771 // $ANTLR start "abstractDeclaratorList"
2772 // Grammar/CTFParser.g:369:1: abstractDeclaratorList : abstractDeclarator (
2773 // SEPARATOR abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST (
2774 // abstractDeclarator )+ ) ;
2775 public final CTFParser
.abstractDeclaratorList_return
abstractDeclaratorList()
2776 throws RecognitionException
{
2777 CTFParser
.abstractDeclaratorList_return retval
= new CTFParser
.abstractDeclaratorList_return();
2778 retval
.start
= input
.LT(1);
2780 CommonTree root_0
= null;
2782 Token SEPARATOR39
= null;
2783 CTFParser
.abstractDeclarator_return abstractDeclarator38
= null;
2785 CTFParser
.abstractDeclarator_return abstractDeclarator40
= null;
2787 CommonTree SEPARATOR39_tree
= null;
2788 RewriteRuleTokenStream stream_SEPARATOR
= new RewriteRuleTokenStream(
2789 adaptor
, "token SEPARATOR");
2790 RewriteRuleSubtreeStream stream_abstractDeclarator
= new RewriteRuleSubtreeStream(
2791 adaptor
, "rule abstractDeclarator");
2793 enter("abstractDeclaratorList");
2796 // Grammar/CTFParser.g:376:1: ( abstractDeclarator ( SEPARATOR
2797 // abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST (
2798 // abstractDeclarator )+ ) )
2799 // Grammar/CTFParser.g:377:3: abstractDeclarator ( SEPARATOR
2800 // abstractDeclarator )*
2802 pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList985
);
2803 abstractDeclarator38
= abstractDeclarator();
2809 if (state
.backtracking
== 0) {
2810 stream_abstractDeclarator
.add(abstractDeclarator38
2813 // Grammar/CTFParser.g:377:22: ( SEPARATOR abstractDeclarator )*
2816 int LA16_0
= input
.LA(1);
2818 if ((LA16_0
== SEPARATOR
)) {
2824 // Grammar/CTFParser.g:377:23: SEPARATOR abstractDeclarator
2826 SEPARATOR39
= (Token
) match(input
, SEPARATOR
,
2827 FOLLOW_SEPARATOR_in_abstractDeclaratorList988
);
2831 if (state
.backtracking
== 0) {
2832 stream_SEPARATOR
.add(SEPARATOR39
);
2835 pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList990
);
2836 abstractDeclarator40
= abstractDeclarator();
2842 if (state
.backtracking
== 0) {
2843 stream_abstractDeclarator
.add(abstractDeclarator40
2856 // elements: abstractDeclarator
2858 // rule labels: retval
2859 // token list labels:
2860 // rule list labels:
2862 if (state
.backtracking
== 0) {
2863 retval
.tree
= root_0
;
2864 // RewriteRuleSubtreeStream stream_retval =
2865 new RewriteRuleSubtreeStream(
2866 adaptor
, "rule retval",
2867 retval
!= null ? retval
.tree
: null);
2869 root_0
= (CommonTree
) adaptor
.nil();
2870 // 377:54: -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator
2873 // Grammar/CTFParser.g:377:57: ^( TYPE_DECLARATOR_LIST (
2874 // abstractDeclarator )+ )
2876 CommonTree root_1
= (CommonTree
) adaptor
.nil();
2877 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
2878 .create(TYPE_DECLARATOR_LIST
,
2879 "TYPE_DECLARATOR_LIST"), root_1
);
2881 if (!(stream_abstractDeclarator
.hasNext())) {
2882 throw new RewriteEarlyExitException();
2884 while (stream_abstractDeclarator
.hasNext()) {
2885 adaptor
.addChild(root_1
,
2886 stream_abstractDeclarator
.nextTree());
2889 stream_abstractDeclarator
.reset();
2891 adaptor
.addChild(root_0
, root_1
);
2896 retval
.tree
= root_0
;
2900 retval
.stop
= input
.LT(-1);
2902 if (state
.backtracking
== 0) {
2904 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
2905 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
2908 if (state
.backtracking
== 0) {
2910 exit("abstractDeclaratorList");
2915 catch (RecognitionException e
) {
2921 // $ANTLR end "abstractDeclaratorList"
2923 public static class storageClassSpecifier_return
extends
2924 ParserRuleReturnScope
{
2928 public Object
getTree() {
2933 // $ANTLR start "storageClassSpecifier"
2934 // Grammar/CTFParser.g:380:1: storageClassSpecifier : TYPEDEFTOK ;
2935 public final CTFParser
.storageClassSpecifier_return
storageClassSpecifier()
2936 throws RecognitionException
{
2937 CTFParser
.storageClassSpecifier_return retval
= new CTFParser
.storageClassSpecifier_return();
2938 retval
.start
= input
.LT(1);
2940 CommonTree root_0
= null;
2942 Token TYPEDEFTOK41
= null;
2944 CommonTree TYPEDEFTOK41_tree
= null;
2947 // Grammar/CTFParser.g:380:23: ( TYPEDEFTOK )
2948 // Grammar/CTFParser.g:381:3: TYPEDEFTOK
2950 root_0
= (CommonTree
) adaptor
.nil();
2952 TYPEDEFTOK41
= (Token
) match(input
, TYPEDEFTOK
,
2953 FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1014
);
2957 if (state
.backtracking
== 0) {
2958 TYPEDEFTOK41_tree
= (CommonTree
) adaptor
2959 .create(TYPEDEFTOK41
);
2960 adaptor
.addChild(root_0
, TYPEDEFTOK41_tree
);
2962 if (state
.backtracking
== 0) {
2968 retval
.stop
= input
.LT(-1);
2970 if (state
.backtracking
== 0) {
2972 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
2973 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
2978 catch (RecognitionException e
) {
2985 // $ANTLR end "storageClassSpecifier"
2987 public static class typeSpecifier_return
extends ParserRuleReturnScope
{
2991 public Object
getTree() {
2996 // $ANTLR start "typeSpecifier"
2997 // Grammar/CTFParser.g:384:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK
2998 // | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK |
2999 // BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier
3000 // | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName );
3001 public final CTFParser
.typeSpecifier_return
typeSpecifier()
3002 throws RecognitionException
{
3003 CTFParser
.typeSpecifier_return retval
= new CTFParser
.typeSpecifier_return();
3004 retval
.start
= input
.LT(1);
3006 CommonTree root_0
= null;
3008 Token FLOATTOK42
= null;
3009 Token INTTOK43
= null;
3010 Token LONGTOK44
= null;
3011 Token SHORTTOK45
= null;
3012 Token SIGNEDTOK46
= null;
3013 Token UNSIGNEDTOK47
= null;
3014 Token CHARTOK48
= null;
3015 Token DOUBLETOK49
= null;
3016 Token VOIDTOK50
= null;
3017 Token BOOLTOK51
= null;
3018 Token COMPLEXTOK52
= null;
3019 Token IMAGINARYTOK53
= null;
3020 CTFParser
.structSpecifier_return structSpecifier54
= null;
3022 CTFParser
.variantSpecifier_return variantSpecifier55
= null;
3024 CTFParser
.enumSpecifier_return enumSpecifier56
= null;
3026 CTFParser
.ctfTypeSpecifier_return ctfTypeSpecifier57
= null;
3028 CTFParser
.typedefName_return typedefName58
= null;
3030 CommonTree FLOATTOK42_tree
= null;
3031 CommonTree INTTOK43_tree
= null;
3032 CommonTree LONGTOK44_tree
= null;
3033 CommonTree SHORTTOK45_tree
= null;
3034 CommonTree SIGNEDTOK46_tree
= null;
3035 CommonTree UNSIGNEDTOK47_tree
= null;
3036 CommonTree CHARTOK48_tree
= null;
3037 CommonTree DOUBLETOK49_tree
= null;
3038 CommonTree VOIDTOK50_tree
= null;
3039 CommonTree BOOLTOK51_tree
= null;
3040 CommonTree COMPLEXTOK52_tree
= null;
3041 CommonTree IMAGINARYTOK53_tree
= null;
3043 enter("typeSpecifier");
3046 // Grammar/CTFParser.g:392:1: ( FLOATTOK | INTTOK | LONGTOK |
3047 // SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK |
3048 // VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier |
3049 // variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? =>
3052 alt17
= dfa17
.predict(input
);
3055 // Grammar/CTFParser.g:393:3: FLOATTOK
3057 root_0
= (CommonTree
) adaptor
.nil();
3059 FLOATTOK42
= (Token
) match(input
, FLOATTOK
,
3060 FOLLOW_FLOATTOK_in_typeSpecifier1040
);
3064 if (state
.backtracking
== 0) {
3065 FLOATTOK42_tree
= (CommonTree
) adaptor
.create(FLOATTOK42
);
3066 adaptor
.addChild(root_0
, FLOATTOK42_tree
);
3072 // Grammar/CTFParser.g:394:5: INTTOK
3074 root_0
= (CommonTree
) adaptor
.nil();
3076 INTTOK43
= (Token
) match(input
, INTTOK
,
3077 FOLLOW_INTTOK_in_typeSpecifier1046
);
3081 if (state
.backtracking
== 0) {
3082 INTTOK43_tree
= (CommonTree
) adaptor
.create(INTTOK43
);
3083 adaptor
.addChild(root_0
, INTTOK43_tree
);
3089 // Grammar/CTFParser.g:395:5: LONGTOK
3091 root_0
= (CommonTree
) adaptor
.nil();
3093 LONGTOK44
= (Token
) match(input
, LONGTOK
,
3094 FOLLOW_LONGTOK_in_typeSpecifier1052
);
3098 if (state
.backtracking
== 0) {
3099 LONGTOK44_tree
= (CommonTree
) adaptor
.create(LONGTOK44
);
3100 adaptor
.addChild(root_0
, LONGTOK44_tree
);
3106 // Grammar/CTFParser.g:396:5: SHORTTOK
3108 root_0
= (CommonTree
) adaptor
.nil();
3110 SHORTTOK45
= (Token
) match(input
, SHORTTOK
,
3111 FOLLOW_SHORTTOK_in_typeSpecifier1058
);
3115 if (state
.backtracking
== 0) {
3116 SHORTTOK45_tree
= (CommonTree
) adaptor
.create(SHORTTOK45
);
3117 adaptor
.addChild(root_0
, SHORTTOK45_tree
);
3123 // Grammar/CTFParser.g:397:5: SIGNEDTOK
3125 root_0
= (CommonTree
) adaptor
.nil();
3127 SIGNEDTOK46
= (Token
) match(input
, SIGNEDTOK
,
3128 FOLLOW_SIGNEDTOK_in_typeSpecifier1064
);
3132 if (state
.backtracking
== 0) {
3133 SIGNEDTOK46_tree
= (CommonTree
) adaptor
.create(SIGNEDTOK46
);
3134 adaptor
.addChild(root_0
, SIGNEDTOK46_tree
);
3140 // Grammar/CTFParser.g:398:5: UNSIGNEDTOK
3142 root_0
= (CommonTree
) adaptor
.nil();
3144 UNSIGNEDTOK47
= (Token
) match(input
, UNSIGNEDTOK
,
3145 FOLLOW_UNSIGNEDTOK_in_typeSpecifier1070
);
3149 if (state
.backtracking
== 0) {
3150 UNSIGNEDTOK47_tree
= (CommonTree
) adaptor
3151 .create(UNSIGNEDTOK47
);
3152 adaptor
.addChild(root_0
, UNSIGNEDTOK47_tree
);
3158 // Grammar/CTFParser.g:399:5: CHARTOK
3160 root_0
= (CommonTree
) adaptor
.nil();
3162 CHARTOK48
= (Token
) match(input
, CHARTOK
,
3163 FOLLOW_CHARTOK_in_typeSpecifier1076
);
3167 if (state
.backtracking
== 0) {
3168 CHARTOK48_tree
= (CommonTree
) adaptor
.create(CHARTOK48
);
3169 adaptor
.addChild(root_0
, CHARTOK48_tree
);
3175 // Grammar/CTFParser.g:400:5: DOUBLETOK
3177 root_0
= (CommonTree
) adaptor
.nil();
3179 DOUBLETOK49
= (Token
) match(input
, DOUBLETOK
,
3180 FOLLOW_DOUBLETOK_in_typeSpecifier1082
);
3184 if (state
.backtracking
== 0) {
3185 DOUBLETOK49_tree
= (CommonTree
) adaptor
.create(DOUBLETOK49
);
3186 adaptor
.addChild(root_0
, DOUBLETOK49_tree
);
3192 // Grammar/CTFParser.g:401:5: VOIDTOK
3194 root_0
= (CommonTree
) adaptor
.nil();
3196 VOIDTOK50
= (Token
) match(input
, VOIDTOK
,
3197 FOLLOW_VOIDTOK_in_typeSpecifier1088
);
3201 if (state
.backtracking
== 0) {
3202 VOIDTOK50_tree
= (CommonTree
) adaptor
.create(VOIDTOK50
);
3203 adaptor
.addChild(root_0
, VOIDTOK50_tree
);
3209 // Grammar/CTFParser.g:402:5: BOOLTOK
3211 root_0
= (CommonTree
) adaptor
.nil();
3213 BOOLTOK51
= (Token
) match(input
, BOOLTOK
,
3214 FOLLOW_BOOLTOK_in_typeSpecifier1094
);
3218 if (state
.backtracking
== 0) {
3219 BOOLTOK51_tree
= (CommonTree
) adaptor
.create(BOOLTOK51
);
3220 adaptor
.addChild(root_0
, BOOLTOK51_tree
);
3226 // Grammar/CTFParser.g:403:5: COMPLEXTOK
3228 root_0
= (CommonTree
) adaptor
.nil();
3230 COMPLEXTOK52
= (Token
) match(input
, COMPLEXTOK
,
3231 FOLLOW_COMPLEXTOK_in_typeSpecifier1100
);
3235 if (state
.backtracking
== 0) {
3236 COMPLEXTOK52_tree
= (CommonTree
) adaptor
3237 .create(COMPLEXTOK52
);
3238 adaptor
.addChild(root_0
, COMPLEXTOK52_tree
);
3244 // Grammar/CTFParser.g:404:5: IMAGINARYTOK
3246 root_0
= (CommonTree
) adaptor
.nil();
3248 IMAGINARYTOK53
= (Token
) match(input
, IMAGINARYTOK
,
3249 FOLLOW_IMAGINARYTOK_in_typeSpecifier1106
);
3253 if (state
.backtracking
== 0) {
3254 IMAGINARYTOK53_tree
= (CommonTree
) adaptor
3255 .create(IMAGINARYTOK53
);
3256 adaptor
.addChild(root_0
, IMAGINARYTOK53_tree
);
3262 // Grammar/CTFParser.g:405:5: structSpecifier
3264 root_0
= (CommonTree
) adaptor
.nil();
3266 pushFollow(FOLLOW_structSpecifier_in_typeSpecifier1112
);
3267 structSpecifier54
= structSpecifier();
3273 if (state
.backtracking
== 0) {
3274 adaptor
.addChild(root_0
, structSpecifier54
.getTree());
3280 // Grammar/CTFParser.g:406:5: variantSpecifier
3282 root_0
= (CommonTree
) adaptor
.nil();
3284 pushFollow(FOLLOW_variantSpecifier_in_typeSpecifier1118
);
3285 variantSpecifier55
= variantSpecifier();
3291 if (state
.backtracking
== 0) {
3292 adaptor
.addChild(root_0
, variantSpecifier55
.getTree());
3298 // Grammar/CTFParser.g:407:5: enumSpecifier
3300 root_0
= (CommonTree
) adaptor
.nil();
3302 pushFollow(FOLLOW_enumSpecifier_in_typeSpecifier1124
);
3303 enumSpecifier56
= enumSpecifier();
3309 if (state
.backtracking
== 0) {
3310 adaptor
.addChild(root_0
, enumSpecifier56
.getTree());
3316 // Grammar/CTFParser.g:408:5: ctfTypeSpecifier
3318 root_0
= (CommonTree
) adaptor
.nil();
3320 pushFollow(FOLLOW_ctfTypeSpecifier_in_typeSpecifier1130
);
3321 ctfTypeSpecifier57
= ctfTypeSpecifier();
3327 if (state
.backtracking
== 0) {
3328 adaptor
.addChild(root_0
, ctfTypeSpecifier57
.getTree());
3334 // Grammar/CTFParser.g:409:5: {...}? => typedefName
3336 root_0
= (CommonTree
) adaptor
.nil();
3338 if (!((inTypealiasAlias() || isTypeName(input
.LT(1).getText())))) {
3339 if (state
.backtracking
> 0) {
3340 state
.failed
= true;
3343 throw new FailedPredicateException(input
, "typeSpecifier",
3344 "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
3346 pushFollow(FOLLOW_typedefName_in_typeSpecifier1140
);
3347 typedefName58
= typedefName();
3353 if (state
.backtracking
== 0) {
3354 adaptor
.addChild(root_0
, typedefName58
.getTree());
3361 retval
.stop
= input
.LT(-1);
3363 if (state
.backtracking
== 0) {
3365 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
3366 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
3369 if (state
.backtracking
== 0) {
3371 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
3372 exit("typeSpecifier");
3377 catch (RecognitionException e
) {
3384 // $ANTLR end "typeSpecifier"
3386 public static class typeQualifier_return
extends ParserRuleReturnScope
{
3390 public Object
getTree() {
3395 // $ANTLR start "typeQualifier"
3396 // Grammar/CTFParser.g:412:1: typeQualifier : CONSTTOK ;
3397 public final CTFParser
.typeQualifier_return
typeQualifier()
3398 throws RecognitionException
{
3399 CTFParser
.typeQualifier_return retval
= new CTFParser
.typeQualifier_return();
3400 retval
.start
= input
.LT(1);
3402 CommonTree root_0
= null;
3404 Token CONSTTOK59
= null;
3406 CommonTree CONSTTOK59_tree
= null;
3408 enter("typeQualifier");
3411 // Grammar/CTFParser.g:420:1: ( CONSTTOK )
3412 // Grammar/CTFParser.g:421:3: CONSTTOK
3414 root_0
= (CommonTree
) adaptor
.nil();
3416 CONSTTOK59
= (Token
) match(input
, CONSTTOK
,
3417 FOLLOW_CONSTTOK_in_typeQualifier1163
);
3421 if (state
.backtracking
== 0) {
3422 CONSTTOK59_tree
= (CommonTree
) adaptor
.create(CONSTTOK59
);
3423 adaptor
.addChild(root_0
, CONSTTOK59_tree
);
3428 retval
.stop
= input
.LT(-1);
3430 if (state
.backtracking
== 0) {
3432 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
3433 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
3436 if (state
.backtracking
== 0) {
3438 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
3439 exit("typeQualifier");
3444 catch (RecognitionException e
) {
3451 // $ANTLR end "typeQualifier"
3453 public static class alignAttribute_return
extends ParserRuleReturnScope
{
3457 public Object
getTree() {
3462 // $ANTLR start "alignAttribute"
3463 // Grammar/CTFParser.g:424:1: alignAttribute : ALIGNTOK LPAREN
3464 // unaryExpression RPAREN -> ^( ALIGN unaryExpression ) ;
3465 public final CTFParser
.alignAttribute_return
alignAttribute()
3466 throws RecognitionException
{
3467 CTFParser
.alignAttribute_return retval
= new CTFParser
.alignAttribute_return();
3468 retval
.start
= input
.LT(1);
3470 CommonTree root_0
= null;
3472 Token ALIGNTOK60
= null;
3473 Token LPAREN61
= null;
3474 Token RPAREN63
= null;
3475 CTFParser
.unaryExpression_return unaryExpression62
= null;
3477 CommonTree ALIGNTOK60_tree
= null;
3478 CommonTree LPAREN61_tree
= null;
3479 CommonTree RPAREN63_tree
= null;
3480 RewriteRuleTokenStream stream_RPAREN
= new RewriteRuleTokenStream(
3481 adaptor
, "token RPAREN");
3482 RewriteRuleTokenStream stream_ALIGNTOK
= new RewriteRuleTokenStream(
3483 adaptor
, "token ALIGNTOK");
3484 RewriteRuleTokenStream stream_LPAREN
= new RewriteRuleTokenStream(
3485 adaptor
, "token LPAREN");
3486 RewriteRuleSubtreeStream stream_unaryExpression
= new RewriteRuleSubtreeStream(
3487 adaptor
, "rule unaryExpression");
3489 // Grammar/CTFParser.g:424:16: ( ALIGNTOK LPAREN unaryExpression
3490 // RPAREN -> ^( ALIGN unaryExpression ) )
3491 // Grammar/CTFParser.g:425:3: ALIGNTOK LPAREN unaryExpression RPAREN
3493 ALIGNTOK60
= (Token
) match(input
, ALIGNTOK
,
3494 FOLLOW_ALIGNTOK_in_alignAttribute1176
);
3498 if (state
.backtracking
== 0) {
3499 stream_ALIGNTOK
.add(ALIGNTOK60
);
3502 LPAREN61
= (Token
) match(input
, LPAREN
,
3503 FOLLOW_LPAREN_in_alignAttribute1178
);
3507 if (state
.backtracking
== 0) {
3508 stream_LPAREN
.add(LPAREN61
);
3511 pushFollow(FOLLOW_unaryExpression_in_alignAttribute1180
);
3512 unaryExpression62
= unaryExpression();
3518 if (state
.backtracking
== 0) {
3519 stream_unaryExpression
.add(unaryExpression62
.getTree());
3521 RPAREN63
= (Token
) match(input
, RPAREN
,
3522 FOLLOW_RPAREN_in_alignAttribute1182
);
3526 if (state
.backtracking
== 0) {
3527 stream_RPAREN
.add(RPAREN63
);
3531 // elements: unaryExpression
3533 // rule labels: retval
3534 // token list labels:
3535 // rule list labels:
3537 if (state
.backtracking
== 0) {
3538 retval
.tree
= root_0
;
3539 // RewriteRuleSubtreeStream stream_retval =
3540 new RewriteRuleSubtreeStream(
3541 adaptor
, "rule retval",
3542 retval
!= null ? retval
.tree
: null);
3544 root_0
= (CommonTree
) adaptor
.nil();
3545 // 425:42: -> ^( ALIGN unaryExpression )
3547 // Grammar/CTFParser.g:425:45: ^( ALIGN unaryExpression
3550 CommonTree root_1
= (CommonTree
) adaptor
.nil();
3551 root_1
= (CommonTree
) adaptor
.becomeRoot(
3552 adaptor
.create(ALIGN
, "ALIGN"), root_1
);
3554 adaptor
.addChild(root_1
,
3555 stream_unaryExpression
.nextTree());
3557 adaptor
.addChild(root_0
, root_1
);
3562 retval
.tree
= root_0
;
3566 retval
.stop
= input
.LT(-1);
3568 if (state
.backtracking
== 0) {
3570 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
3571 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
3576 catch (RecognitionException e
) {
3583 // $ANTLR end "alignAttribute"
3585 public static class structBody_return
extends ParserRuleReturnScope
{
3589 public Object
getTree() {
3594 // $ANTLR start "structBody"
3595 // Grammar/CTFParser.g:429:1: structBody : LCURL (
3596 // structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY (
3597 // structOrVariantDeclarationList )? ) ;
3598 public final CTFParser
.structBody_return
structBody()
3599 throws RecognitionException
{
3600 Symbols_stack
.push(new Symbols_scope());
3602 CTFParser
.structBody_return retval
= new CTFParser
.structBody_return();
3603 retval
.start
= input
.LT(1);
3605 CommonTree root_0
= null;
3607 Token LCURL64
= null;
3608 Token RCURL66
= null;
3609 CTFParser
.structOrVariantDeclarationList_return structOrVariantDeclarationList65
= null;
3611 CommonTree LCURL64_tree
= null;
3612 CommonTree RCURL66_tree
= null;
3613 RewriteRuleTokenStream stream_LCURL
= new RewriteRuleTokenStream(
3614 adaptor
, "token LCURL");
3615 RewriteRuleTokenStream stream_RCURL
= new RewriteRuleTokenStream(
3616 adaptor
, "token RCURL");
3617 RewriteRuleSubtreeStream stream_structOrVariantDeclarationList
= new RewriteRuleSubtreeStream(
3618 adaptor
, "rule structOrVariantDeclarationList");
3620 enter("structBody");
3621 debug_print("Scope push " + Symbols_stack
.size());
3622 ((Symbols_scope
) Symbols_stack
.peek()).types
= new HashSet
<String
>();
3625 // Grammar/CTFParser.g:440:1: ( LCURL (
3626 // structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY (
3627 // structOrVariantDeclarationList )? ) )
3628 // Grammar/CTFParser.g:441:3: LCURL ( structOrVariantDeclarationList
3631 LCURL64
= (Token
) match(input
, LCURL
,
3632 FOLLOW_LCURL_in_structBody1223
);
3636 if (state
.backtracking
== 0) {
3637 stream_LCURL
.add(LCURL64
);
3640 // Grammar/CTFParser.g:441:9: ( structOrVariantDeclarationList
3643 int LA18_0
= input
.LA(1);
3645 if ((((LA18_0
>= CONSTTOK
) && (LA18_0
<= ENUMTOK
))
3646 || ((LA18_0
>= FLOATINGPOINTTOK
) && (LA18_0
<= SIGNEDTOK
))
3647 || ((LA18_0
>= STRINGTOK
) && (LA18_0
<= STRUCTTOK
)) || ((LA18_0
>= TYPEDEFTOK
) && (LA18_0
<= IMAGINARYTOK
)))) {
3649 } else if ((LA18_0
== IDENTIFIER
)
3650 && ((inTypealiasAlias() || isTypeName(input
.LT(1)
3653 } else if ((LA18_0
== TYPEALIASTOK
)) {
3658 // Grammar/CTFParser.g:441:9: structOrVariantDeclarationList
3660 pushFollow(FOLLOW_structOrVariantDeclarationList_in_structBody1225
);
3661 structOrVariantDeclarationList65
= structOrVariantDeclarationList();
3667 if (state
.backtracking
== 0) {
3668 stream_structOrVariantDeclarationList
3669 .add(structOrVariantDeclarationList65
.getTree());
3677 RCURL66
= (Token
) match(input
, RCURL
,
3678 FOLLOW_RCURL_in_structBody1228
);
3682 if (state
.backtracking
== 0) {
3683 stream_RCURL
.add(RCURL66
);
3687 // elements: structOrVariantDeclarationList
3689 // rule labels: retval
3690 // token list labels:
3691 // rule list labels:
3693 if (state
.backtracking
== 0) {
3694 retval
.tree
= root_0
;
3695 // RewriteRuleSubtreeStream stream_retval =
3696 new RewriteRuleSubtreeStream(
3697 adaptor
, "rule retval",
3698 retval
!= null ? retval
.tree
: null);
3700 root_0
= (CommonTree
) adaptor
.nil();
3701 // 441:47: -> ^( STRUCT_BODY (
3702 // structOrVariantDeclarationList )? )
3704 // Grammar/CTFParser.g:441:50: ^( STRUCT_BODY (
3705 // structOrVariantDeclarationList )? )
3707 CommonTree root_1
= (CommonTree
) adaptor
.nil();
3708 root_1
= (CommonTree
) adaptor
.becomeRoot(
3709 adaptor
.create(STRUCT_BODY
, "STRUCT_BODY"),
3712 // Grammar/CTFParser.g:441:64: (
3713 // structOrVariantDeclarationList )?
3714 if (stream_structOrVariantDeclarationList
.hasNext()) {
3715 adaptor
.addChild(root_1
,
3716 stream_structOrVariantDeclarationList
3720 stream_structOrVariantDeclarationList
.reset();
3722 adaptor
.addChild(root_0
, root_1
);
3727 retval
.tree
= root_0
;
3731 retval
.stop
= input
.LT(-1);
3733 if (state
.backtracking
== 0) {
3735 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
3736 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
3739 if (state
.backtracking
== 0) {
3741 debug_print("Scope pop " + Symbols_stack
.size());
3747 catch (RecognitionException e
) {
3750 Symbols_stack
.pop();
3756 // $ANTLR end "structBody"
3758 public static class structSpecifier_return
extends ParserRuleReturnScope
{
3762 public Object
getTree() {
3767 // $ANTLR start "structSpecifier"
3768 // Grammar/CTFParser.g:446:1: structSpecifier : STRUCTTOK ( ( structName (
3769 // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | ( structBody
3770 // ( alignAttribute | ) ) ) -> ^( STRUCT ( structName )? ( structBody )? (
3771 // alignAttribute )? ) ;
3772 public final CTFParser
.structSpecifier_return
structSpecifier()
3773 throws RecognitionException
{
3774 CTFParser
.structSpecifier_return retval
= new CTFParser
.structSpecifier_return();
3775 retval
.start
= input
.LT(1);
3777 CommonTree root_0
= null;
3779 Token STRUCTTOK67
= null;
3780 CTFParser
.structName_return structName68
= null;
3782 CTFParser
.alignAttribute_return alignAttribute69
= null;
3784 CTFParser
.structBody_return structBody70
= null;
3786 CTFParser
.alignAttribute_return alignAttribute71
= null;
3788 CTFParser
.structBody_return structBody72
= null;
3790 CTFParser
.alignAttribute_return alignAttribute73
= null;
3792 CommonTree STRUCTTOK67_tree
= null;
3793 RewriteRuleTokenStream stream_STRUCTTOK
= new RewriteRuleTokenStream(
3794 adaptor
, "token STRUCTTOK");
3795 RewriteRuleSubtreeStream stream_structName
= new RewriteRuleSubtreeStream(
3796 adaptor
, "rule structName");
3797 RewriteRuleSubtreeStream stream_structBody
= new RewriteRuleSubtreeStream(
3798 adaptor
, "rule structBody");
3799 RewriteRuleSubtreeStream stream_alignAttribute
= new RewriteRuleSubtreeStream(
3800 adaptor
, "rule alignAttribute");
3802 enter("structSpecifier");
3805 // Grammar/CTFParser.g:453:1: ( STRUCTTOK ( ( structName (
3806 // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | (
3807 // structBody ( alignAttribute | ) ) ) -> ^( STRUCT ( structName )?
3808 // ( structBody )? ( alignAttribute )? ) )
3809 // Grammar/CTFParser.g:454:3: STRUCTTOK ( ( structName (
3810 // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | (
3811 // structBody ( alignAttribute | ) ) )
3813 STRUCTTOK67
= (Token
) match(input
, STRUCTTOK
,
3814 FOLLOW_STRUCTTOK_in_structSpecifier1266
);
3818 if (state
.backtracking
== 0) {
3819 stream_STRUCTTOK
.add(STRUCTTOK67
);
3822 // Grammar/CTFParser.g:455:3: ( ( structName ( alignAttribute |
3823 // ( structBody ( alignAttribute | ) ) | ) ) | ( structBody (
3824 // alignAttribute | ) ) )
3826 int LA22_0
= input
.LA(1);
3828 if ((LA22_0
== IDENTIFIER
)) {
3830 } else if ((LA22_0
== LCURL
)) {
3833 if (state
.backtracking
> 0) {
3834 state
.failed
= true;
3837 NoViableAltException nvae
= new NoViableAltException("",
3844 // Grammar/CTFParser.g:457:5: ( structName ( alignAttribute | (
3845 // structBody ( alignAttribute | ) ) | ) )
3847 // Grammar/CTFParser.g:457:5: ( structName ( alignAttribute
3848 // | ( structBody ( alignAttribute | ) ) | ) )
3849 // Grammar/CTFParser.g:458:6: structName ( alignAttribute |
3850 // ( structBody ( alignAttribute | ) ) | )
3852 pushFollow(FOLLOW_structName_in_structSpecifier1288
);
3853 structName68
= structName();
3859 if (state
.backtracking
== 0) {
3860 stream_structName
.add(structName68
.getTree());
3862 // Grammar/CTFParser.g:459:6: ( alignAttribute | (
3863 // structBody ( alignAttribute | ) ) | )
3865 switch (input
.LA(1)) {
3871 switch (input
.LA(2)) {
3876 case FLOATINGPOINTTOK
:
3896 int LA20_5
= input
.LA(3);
3898 if ((((LA20_5
>= CONSTTOK
) && (LA20_5
<= ENUMTOK
))
3899 || ((LA20_5
>= FLOATINGPOINTTOK
) && (LA20_5
<= SIGNEDTOK
))
3900 || ((LA20_5
>= STRINGTOK
) && (LA20_5
<= STRUCTTOK
))
3901 || ((LA20_5
>= TYPEDEFTOK
) && (LA20_5
<= IMAGINARYTOK
))
3902 || (LA20_5
== POINTER
) || (LA20_5
== IDENTIFIER
))) {
3904 } else if (((LA20_5
== SEPARATOR
)
3905 || (LA20_5
== ASSIGNMENT
) || (LA20_5
== RCURL
))) {
3908 if (state
.backtracking
> 0) {
3909 state
.failed
= true;
3912 NoViableAltException nvae
= new NoViableAltException(
3920 int LA20_6
= input
.LA(3);
3922 if ((((LA20_6
>= CONSTTOK
) && (LA20_6
<= ENUMTOK
))
3923 || ((LA20_6
>= FLOATINGPOINTTOK
) && (LA20_6
<= SIGNEDTOK
))
3924 || ((LA20_6
>= STRINGTOK
) && (LA20_6
<= STRUCTTOK
))
3925 || ((LA20_6
>= TYPEDEFTOK
) && (LA20_6
<= IMAGINARYTOK
))
3926 || (LA20_6
== LCURL
)
3927 || (LA20_6
== POINTER
) || (LA20_6
== IDENTIFIER
))) {
3929 } else if (((LA20_6
== SEPARATOR
)
3930 || (LA20_6
== ASSIGNMENT
) || (LA20_6
== RCURL
))) {
3933 if (state
.backtracking
> 0) {
3934 state
.failed
= true;
3937 NoViableAltException nvae
= new NoViableAltException(
3945 int LA20_7
= input
.LA(3);
3947 if (((LA20_7
== SEPARATOR
)
3948 || (LA20_7
== ASSIGNMENT
) || (LA20_7
== RCURL
))) {
3950 } else if ((((LA20_7
>= CONSTTOK
) && (LA20_7
<= ENUMTOK
))
3951 || ((LA20_7
>= FLOATINGPOINTTOK
) && (LA20_7
<= SIGNEDTOK
))
3952 || ((LA20_7
>= STRINGTOK
) && (LA20_7
<= STRUCTTOK
))
3953 || ((LA20_7
>= TYPEDEFTOK
) && (LA20_7
<= IMAGINARYTOK
))
3954 || (LA20_7
== POINTER
) || (LA20_7
== IDENTIFIER
))) {
3957 if (state
.backtracking
> 0) {
3958 state
.failed
= true;
3961 NoViableAltException nvae
= new NoViableAltException(
3970 case STRING_LITERAL
: {
3975 if (state
.backtracking
> 0) {
3976 state
.failed
= true;
3979 NoViableAltException nvae
= new NoViableAltException(
3992 case FLOATINGPOINTTOK
:
4008 case TYPE_ASSIGNMENT
:
4017 if (state
.backtracking
> 0) {
4018 state
.failed
= true;
4021 NoViableAltException nvae
= new NoViableAltException(
4029 // Grammar/CTFParser.g:460:8: alignAttribute
4031 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1304
);
4032 alignAttribute69
= alignAttribute();
4038 if (state
.backtracking
== 0) {
4039 stream_alignAttribute
.add(alignAttribute69
4046 // Grammar/CTFParser.g:462:8: ( structBody (
4047 // alignAttribute | ) )
4049 // Grammar/CTFParser.g:462:8: ( structBody (
4050 // alignAttribute | ) )
4051 // Grammar/CTFParser.g:463:10: structBody (
4052 // alignAttribute | )
4054 pushFollow(FOLLOW_structBody_in_structSpecifier1333
);
4055 structBody70
= structBody();
4061 if (state
.backtracking
== 0) {
4062 stream_structBody
.add(structBody70
4065 // Grammar/CTFParser.g:464:10: ( alignAttribute
4068 int LA19_0
= input
.LA(1);
4070 if ((LA19_0
== ALIGNTOK
)) {
4072 } else if (((LA19_0
== EOF
)
4073 || ((LA19_0
>= CONSTTOK
) && (LA19_0
<= ENUMTOK
))
4074 || ((LA19_0
>= FLOATINGPOINTTOK
) && (LA19_0
<= SIGNEDTOK
))
4075 || ((LA19_0
>= STRINGTOK
) && (LA19_0
<= STRUCTTOK
))
4076 || ((LA19_0
>= TYPEDEFTOK
) && (LA19_0
<= IMAGINARYTOK
))
4077 || (LA19_0
== TYPE_ASSIGNMENT
)
4078 || (LA19_0
== LPAREN
)
4079 || (LA19_0
== LCURL
)
4080 || ((LA19_0
>= TERM
) && (LA19_0
<= POINTER
)) || (LA19_0
== IDENTIFIER
))) {
4083 if (state
.backtracking
> 0) {
4084 state
.failed
= true;
4087 NoViableAltException nvae
= new NoViableAltException(
4094 // Grammar/CTFParser.g:465:11: alignAttribute
4096 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1358
);
4097 alignAttribute71
= alignAttribute();
4103 if (state
.backtracking
== 0) {
4104 stream_alignAttribute
4105 .add(alignAttribute71
.getTree());
4111 // Grammar/CTFParser.g:468:10:
4123 // Grammar/CTFParser.g:472:6:
4135 // Grammar/CTFParser.g:476:5: ( structBody ( alignAttribute | )
4138 // Grammar/CTFParser.g:476:5: ( structBody ( alignAttribute
4140 // Grammar/CTFParser.g:477:7: structBody ( alignAttribute |
4143 pushFollow(FOLLOW_structBody_in_structSpecifier1456
);
4144 structBody72
= structBody();
4150 if (state
.backtracking
== 0) {
4151 stream_structBody
.add(structBody72
.getTree());
4153 // Grammar/CTFParser.g:478:7: ( alignAttribute | )
4155 int LA21_0
= input
.LA(1);
4157 if ((LA21_0
== ALIGNTOK
)) {
4159 } else if (((LA21_0
== EOF
)
4160 || ((LA21_0
>= CONSTTOK
) && (LA21_0
<= ENUMTOK
))
4161 || ((LA21_0
>= FLOATINGPOINTTOK
) && (LA21_0
<= SIGNEDTOK
))
4162 || ((LA21_0
>= STRINGTOK
) && (LA21_0
<= STRUCTTOK
))
4163 || ((LA21_0
>= TYPEDEFTOK
) && (LA21_0
<= IMAGINARYTOK
))
4164 || (LA21_0
== TYPE_ASSIGNMENT
)
4165 || (LA21_0
== LPAREN
) || (LA21_0
== LCURL
)
4166 || ((LA21_0
>= TERM
) && (LA21_0
<= POINTER
)) || (LA21_0
== IDENTIFIER
))) {
4169 if (state
.backtracking
> 0) {
4170 state
.failed
= true;
4173 NoViableAltException nvae
= new NoViableAltException(
4180 // Grammar/CTFParser.g:479:9: alignAttribute
4182 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1474
);
4183 alignAttribute73
= alignAttribute();
4189 if (state
.backtracking
== 0) {
4190 stream_alignAttribute
.add(alignAttribute73
4209 // elements: alignAttribute, structName, structBody
4211 // rule labels: retval
4212 // token list labels:
4213 // rule list labels:
4215 if (state
.backtracking
== 0) {
4216 retval
.tree
= root_0
;
4217 RewriteRuleSubtreeStream stream_retval
= new RewriteRuleSubtreeStream(
4218 adaptor
, "rule retval",
4219 retval
!= null ? retval
.tree
: null);
4221 root_0
= (CommonTree
) adaptor
.nil();
4222 // 484:5: -> ^( STRUCT ( structName )? ( structBody )? (
4223 // alignAttribute )? )
4225 // Grammar/CTFParser.g:484:8: ^( STRUCT ( structName )?
4226 // ( structBody )? ( alignAttribute )? )
4228 CommonTree root_1
= (CommonTree
) adaptor
.nil();
4229 root_1
= (CommonTree
) adaptor
.becomeRoot(
4230 adaptor
.create(STRUCT
, "STRUCT"), root_1
);
4232 // Grammar/CTFParser.g:484:17: ( structName )?
4233 if (stream_structName
.hasNext()) {
4234 adaptor
.addChild(root_1
,
4235 stream_structName
.nextTree());
4238 stream_structName
.reset();
4239 // Grammar/CTFParser.g:484:29: ( structBody )?
4240 if (stream_structBody
.hasNext()) {
4241 adaptor
.addChild(root_1
,
4242 stream_structBody
.nextTree());
4245 stream_structBody
.reset();
4246 // Grammar/CTFParser.g:484:41: ( alignAttribute )?
4247 if (stream_alignAttribute
.hasNext()) {
4248 adaptor
.addChild(root_1
,
4249 stream_alignAttribute
.nextTree());
4252 stream_alignAttribute
.reset();
4254 adaptor
.addChild(root_0
, root_1
);
4259 retval
.tree
= root_0
;
4263 retval
.stop
= input
.LT(-1);
4265 if (state
.backtracking
== 0) {
4267 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
4268 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
4271 if (state
.backtracking
== 0) {
4273 exit("structSpecifier");
4278 catch (RecognitionException e
) {
4284 // $ANTLR end "structSpecifier"
4286 public static class structName_return
extends ParserRuleReturnScope
{
4290 public Object
getTree() {
4295 // $ANTLR start "structName"
4296 // Grammar/CTFParser.g:487:1: structName : IDENTIFIER -> ^( STRUCT_NAME
4298 public final CTFParser
.structName_return
structName()
4299 throws RecognitionException
{
4300 CTFParser
.structName_return retval
= new CTFParser
.structName_return();
4301 retval
.start
= input
.LT(1);
4303 CommonTree root_0
= null;
4305 Token IDENTIFIER74
= null;
4307 CommonTree IDENTIFIER74_tree
= null;
4308 RewriteRuleTokenStream stream_IDENTIFIER
= new RewriteRuleTokenStream(
4309 adaptor
, "token IDENTIFIER");
4311 enter("structName");
4314 // Grammar/CTFParser.g:495:1: ( IDENTIFIER -> ^( STRUCT_NAME
4316 // Grammar/CTFParser.g:496:3: IDENTIFIER
4318 IDENTIFIER74
= (Token
) match(input
, IDENTIFIER
,
4319 FOLLOW_IDENTIFIER_in_structName1550
);
4323 if (state
.backtracking
== 0) {
4324 stream_IDENTIFIER
.add(IDENTIFIER74
);
4328 // elements: IDENTIFIER
4330 // rule labels: retval
4331 // token list labels:
4332 // rule list labels:
4334 if (state
.backtracking
== 0) {
4335 retval
.tree
= root_0
;
4336 // RewriteRuleSubtreeStream stream_retval =
4337 new RewriteRuleSubtreeStream(
4338 adaptor
, "rule retval",
4339 retval
!= null ? retval
.tree
: null);
4341 root_0
= (CommonTree
) adaptor
.nil();
4342 // 496:14: -> ^( STRUCT_NAME IDENTIFIER )
4344 // Grammar/CTFParser.g:496:17: ^( STRUCT_NAME IDENTIFIER
4347 CommonTree root_1
= (CommonTree
) adaptor
.nil();
4348 root_1
= (CommonTree
) adaptor
.becomeRoot(
4349 adaptor
.create(STRUCT_NAME
, "STRUCT_NAME"),
4352 adaptor
.addChild(root_1
,
4353 stream_IDENTIFIER
.nextNode());
4355 adaptor
.addChild(root_0
, root_1
);
4360 retval
.tree
= root_0
;
4364 retval
.stop
= input
.LT(-1);
4366 if (state
.backtracking
== 0) {
4368 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
4369 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
4372 if (state
.backtracking
== 0) {
4374 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
4380 catch (RecognitionException e
) {
4386 // $ANTLR end "structName"
4388 public static class structOrVariantDeclarationList_return
extends
4389 ParserRuleReturnScope
{
4393 public Object
getTree() {
4398 // $ANTLR start "structOrVariantDeclarationList"
4399 // Grammar/CTFParser.g:499:1: structOrVariantDeclarationList : (
4400 // structOrVariantDeclaration )+ ;
4401 public final CTFParser
.structOrVariantDeclarationList_return
structOrVariantDeclarationList()
4402 throws RecognitionException
{
4403 CTFParser
.structOrVariantDeclarationList_return retval
= new CTFParser
.structOrVariantDeclarationList_return();
4404 retval
.start
= input
.LT(1);
4406 CommonTree root_0
= null;
4408 CTFParser
.structOrVariantDeclaration_return structOrVariantDeclaration75
= null;
4410 enter("structOrVariantDeclarationList");
4413 // Grammar/CTFParser.g:506:1: ( ( structOrVariantDeclaration )+ )
4414 // Grammar/CTFParser.g:507:3: ( structOrVariantDeclaration )+
4416 root_0
= (CommonTree
) adaptor
.nil();
4418 // Grammar/CTFParser.g:507:3: ( structOrVariantDeclaration )+
4422 int LA23_0
= input
.LA(1);
4424 if ((((LA23_0
>= CONSTTOK
) && (LA23_0
<= ENUMTOK
))
4425 || ((LA23_0
>= FLOATINGPOINTTOK
) && (LA23_0
<= SIGNEDTOK
))
4426 || ((LA23_0
>= STRINGTOK
) && (LA23_0
<= STRUCTTOK
)) || ((LA23_0
>= TYPEDEFTOK
) && (LA23_0
<= IMAGINARYTOK
)))) {
4428 } else if ((LA23_0
== IDENTIFIER
)
4429 && ((inTypealiasAlias() || isTypeName(input
.LT(1)
4432 } else if ((LA23_0
== TYPEALIASTOK
)) {
4438 // Grammar/CTFParser.g:507:3: structOrVariantDeclaration
4440 pushFollow(FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1581
);
4441 structOrVariantDeclaration75
= structOrVariantDeclaration();
4447 if (state
.backtracking
== 0) {
4448 adaptor
.addChild(root_0
,
4449 structOrVariantDeclaration75
.getTree());
4459 if (state
.backtracking
> 0) {
4460 state
.failed
= true;
4463 EarlyExitException eee
= new EarlyExitException(23,
4472 retval
.stop
= input
.LT(-1);
4474 if (state
.backtracking
== 0) {
4476 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
4477 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
4480 if (state
.backtracking
== 0) {
4482 exit("structOrVariantDeclarationList");
4487 catch (RecognitionException e
) {
4494 // $ANTLR end "structOrVariantDeclarationList"
4496 public static class structOrVariantDeclaration_return
extends
4497 ParserRuleReturnScope
{
4501 public Object
getTree() {
4506 // $ANTLR start "structOrVariantDeclaration"
4507 // Grammar/CTFParser.g:510:1: structOrVariantDeclaration : ( (
4508 // declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF
4509 // declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList ->
4510 // ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )
4511 // ) | typealiasDecl -> typealiasDecl ) TERM ;
4512 public final CTFParser
.structOrVariantDeclaration_return
structOrVariantDeclaration()
4513 throws RecognitionException
{
4514 CTFParser
.structOrVariantDeclaration_return retval
= new CTFParser
.structOrVariantDeclaration_return();
4515 retval
.start
= input
.LT(1);
4517 CommonTree root_0
= null;
4519 Token TERM80
= null;
4520 CTFParser
.declarationSpecifiers_return declarationSpecifiers76
= null;
4522 CTFParser
.declaratorList_return declaratorList77
= null;
4524 CTFParser
.structOrVariantDeclaratorList_return structOrVariantDeclaratorList78
= null;
4526 CTFParser
.typealiasDecl_return typealiasDecl79
= null;
4528 CommonTree TERM80_tree
= null;
4529 RewriteRuleTokenStream stream_TERM
= new RewriteRuleTokenStream(
4530 adaptor
, "token TERM");
4531 RewriteRuleSubtreeStream stream_declaratorList
= new RewriteRuleSubtreeStream(
4532 adaptor
, "rule declaratorList");
4533 RewriteRuleSubtreeStream stream_typealiasDecl
= new RewriteRuleSubtreeStream(
4534 adaptor
, "rule typealiasDecl");
4535 RewriteRuleSubtreeStream stream_declarationSpecifiers
= new RewriteRuleSubtreeStream(
4536 adaptor
, "rule declarationSpecifiers");
4537 RewriteRuleSubtreeStream stream_structOrVariantDeclaratorList
= new RewriteRuleSubtreeStream(
4538 adaptor
, "rule structOrVariantDeclaratorList");
4540 enter("structOrVariantDeclaration");
4543 // Grammar/CTFParser.g:517:1: ( ( ( declarationSpecifiers ({...}? =>
4544 // declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers
4545 // ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION
4546 // declarationSpecifiers structOrVariantDeclaratorList ) ) ) |
4547 // typealiasDecl -> typealiasDecl ) TERM )
4548 // Grammar/CTFParser.g:518:3: ( ( declarationSpecifiers ({...}? =>
4549 // declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers
4550 // ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION
4551 // declarationSpecifiers structOrVariantDeclaratorList ) ) ) |
4552 // typealiasDecl -> typealiasDecl ) TERM
4554 // Grammar/CTFParser.g:518:3: ( ( declarationSpecifiers ({...}?
4555 // => declaratorList -> ^( TYPEDEF declaratorList
4556 // declarationSpecifiers ) | structOrVariantDeclaratorList -> ^(
4557 // SV_DECLARATION declarationSpecifiers
4558 // structOrVariantDeclaratorList ) ) ) | typealiasDecl ->
4561 int LA25_0
= input
.LA(1);
4563 if ((((LA25_0
>= CONSTTOK
) && (LA25_0
<= ENUMTOK
))
4564 || ((LA25_0
>= FLOATINGPOINTTOK
) && (LA25_0
<= SIGNEDTOK
))
4565 || ((LA25_0
>= STRINGTOK
) && (LA25_0
<= STRUCTTOK
)) || ((LA25_0
>= TYPEDEFTOK
) && (LA25_0
<= IMAGINARYTOK
)))) {
4567 } else if ((LA25_0
== IDENTIFIER
)
4568 && ((inTypealiasAlias() || isTypeName(input
.LT(1)
4571 } else if ((LA25_0
== TYPEALIASTOK
)) {
4574 if (state
.backtracking
> 0) {
4575 state
.failed
= true;
4578 NoViableAltException nvae
= new NoViableAltException("",
4585 // Grammar/CTFParser.g:519:4: ( declarationSpecifiers ({...}? =>
4586 // declaratorList -> ^( TYPEDEF declaratorList
4587 // declarationSpecifiers ) | structOrVariantDeclaratorList -> ^(
4588 // SV_DECLARATION declarationSpecifiers
4589 // structOrVariantDeclaratorList ) ) )
4591 // Grammar/CTFParser.g:519:4: ( declarationSpecifiers
4592 // ({...}? => declaratorList -> ^( TYPEDEF declaratorList
4593 // declarationSpecifiers ) | structOrVariantDeclaratorList
4594 // -> ^( SV_DECLARATION declarationSpecifiers
4595 // structOrVariantDeclaratorList ) ) )
4596 // Grammar/CTFParser.g:520:5: declarationSpecifiers ({...}?
4597 // => declaratorList -> ^( TYPEDEF declaratorList
4598 // declarationSpecifiers ) | structOrVariantDeclaratorList
4599 // -> ^( SV_DECLARATION declarationSpecifiers
4600 // structOrVariantDeclaratorList ) )
4602 pushFollow(FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1619
);
4603 declarationSpecifiers76
= declarationSpecifiers();
4609 if (state
.backtracking
== 0) {
4610 stream_declarationSpecifiers
4611 .add(declarationSpecifiers76
.getTree());
4613 // Grammar/CTFParser.g:521:7: ({...}? => declaratorList
4614 // -> ^( TYPEDEF declaratorList declarationSpecifiers )
4615 // | structOrVariantDeclaratorList -> ^( SV_DECLARATION
4616 // declarationSpecifiers structOrVariantDeclaratorList )
4619 alt24
= dfa24
.predict(input
);
4622 // Grammar/CTFParser.g:523:9: {...}? => declaratorList
4624 if (!((inTypedef()))) {
4625 if (state
.backtracking
> 0) {
4626 state
.failed
= true;
4629 throw new FailedPredicateException(input
,
4630 "structOrVariantDeclaration",
4633 pushFollow(FOLLOW_declaratorList_in_structOrVariantDeclaration1651
);
4634 declaratorList77
= declaratorList();
4640 if (state
.backtracking
== 0) {
4641 stream_declaratorList
.add(declaratorList77
4644 if (state
.backtracking
== 0) {
4649 // elements: declarationSpecifiers, declaratorList
4651 // rule labels: retval
4652 // token list labels:
4653 // rule list labels:
4655 if (state
.backtracking
== 0) {
4656 retval
.tree
= root_0
;
4657 // RewriteRuleSubtreeStream stream_retval =
4658 new RewriteRuleSubtreeStream(
4659 adaptor
, "rule retval",
4660 retval
!= null ? retval
.tree
: null);
4662 root_0
= (CommonTree
) adaptor
.nil();
4663 // 524:11: -> ^( TYPEDEF declaratorList
4664 // declarationSpecifiers )
4666 // Grammar/CTFParser.g:524:14: ^( TYPEDEF
4667 // declaratorList declarationSpecifiers )
4669 CommonTree root_1
= (CommonTree
) adaptor
4671 root_1
= (CommonTree
) adaptor
4672 .becomeRoot(adaptor
.create(
4673 TYPEDEF
, "TYPEDEF"),
4676 adaptor
.addChild(root_1
,
4677 stream_declaratorList
4679 adaptor
.addChild(root_1
,
4680 stream_declarationSpecifiers
4683 adaptor
.addChild(root_0
, root_1
);
4688 retval
.tree
= root_0
;
4693 // Grammar/CTFParser.g:525:11:
4694 // structOrVariantDeclaratorList
4696 pushFollow(FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1685
);
4697 structOrVariantDeclaratorList78
= structOrVariantDeclaratorList();
4703 if (state
.backtracking
== 0) {
4704 stream_structOrVariantDeclaratorList
4705 .add(structOrVariantDeclaratorList78
4710 // elements: structOrVariantDeclaratorList,
4711 // declarationSpecifiers
4713 // rule labels: retval
4714 // token list labels:
4715 // rule list labels:
4717 if (state
.backtracking
== 0) {
4718 retval
.tree
= root_0
;
4719 // RewriteRuleSubtreeStream stream_retval =
4720 new RewriteRuleSubtreeStream(
4721 adaptor
, "rule retval",
4722 retval
!= null ? retval
.tree
: null);
4724 root_0
= (CommonTree
) adaptor
.nil();
4725 // 526:11: -> ^( SV_DECLARATION
4726 // declarationSpecifiers
4727 // structOrVariantDeclaratorList )
4729 // Grammar/CTFParser.g:526:14: ^(
4730 // SV_DECLARATION declarationSpecifiers
4731 // structOrVariantDeclaratorList )
4733 CommonTree root_1
= (CommonTree
) adaptor
4735 root_1
= (CommonTree
) adaptor
4736 .becomeRoot(adaptor
.create(
4741 adaptor
.addChild(root_1
,
4742 stream_declarationSpecifiers
4744 adaptor
.addChild(root_1
,
4745 stream_structOrVariantDeclaratorList
4748 adaptor
.addChild(root_0
, root_1
);
4753 retval
.tree
= root_0
;
4765 // Grammar/CTFParser.g:531:5: typealiasDecl
4767 pushFollow(FOLLOW_typealiasDecl_in_structOrVariantDeclaration1735
);
4768 typealiasDecl79
= typealiasDecl();
4774 if (state
.backtracking
== 0) {
4775 stream_typealiasDecl
.add(typealiasDecl79
.getTree());
4779 // elements: typealiasDecl
4781 // rule labels: retval
4782 // token list labels:
4783 // rule list labels:
4785 if (state
.backtracking
== 0) {
4786 retval
.tree
= root_0
;
4787 // RewriteRuleSubtreeStream stream_retval =
4788 new RewriteRuleSubtreeStream(
4789 adaptor
, "rule retval",
4790 retval
!= null ? retval
.tree
: null);
4792 root_0
= (CommonTree
) adaptor
.nil();
4793 // 531:19: -> typealiasDecl
4795 adaptor
.addChild(root_0
,
4796 stream_typealiasDecl
.nextTree());
4800 retval
.tree
= root_0
;
4807 TERM80
= (Token
) match(input
, TERM
,
4808 FOLLOW_TERM_in_structOrVariantDeclaration1747
);
4812 if (state
.backtracking
== 0) {
4813 stream_TERM
.add(TERM80
);
4818 retval
.stop
= input
.LT(-1);
4820 if (state
.backtracking
== 0) {
4822 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
4823 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
4826 if (state
.backtracking
== 0) {
4828 exit("structOrVariantDeclaration");
4833 catch (RecognitionException e
) {
4840 // $ANTLR end "structOrVariantDeclaration"
4842 public static class specifierQualifierList_return
extends
4843 ParserRuleReturnScope
{
4847 public Object
getTree() {
4852 // $ANTLR start "specifierQualifierList"
4853 // Grammar/CTFParser.g:536:1: specifierQualifierList : ( typeQualifier |
4854 // typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
4855 // typeSpecifier )* ) ;
4856 public final CTFParser
.specifierQualifierList_return
specifierQualifierList()
4857 throws RecognitionException
{
4858 CTFParser
.specifierQualifierList_return retval
= new CTFParser
.specifierQualifierList_return();
4859 retval
.start
= input
.LT(1);
4861 CommonTree root_0
= null;
4863 CTFParser
.typeQualifier_return typeQualifier81
= null;
4865 CTFParser
.typeSpecifier_return typeSpecifier82
= null;
4867 RewriteRuleSubtreeStream stream_typeSpecifier
= new RewriteRuleSubtreeStream(
4868 adaptor
, "rule typeSpecifier");
4869 RewriteRuleSubtreeStream stream_typeQualifier
= new RewriteRuleSubtreeStream(
4870 adaptor
, "rule typeQualifier");
4872 enter("specifierQualifierList");
4875 // Grammar/CTFParser.g:543:1: ( ( typeQualifier | typeSpecifier )+
4876 // -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
4878 // Grammar/CTFParser.g:544:3: ( typeQualifier | typeSpecifier )+
4880 // Grammar/CTFParser.g:544:3: ( typeQualifier | typeSpecifier )+
4884 int LA26_0
= input
.LA(1);
4886 if ((LA26_0
== CONSTTOK
)) {
4888 } else if ((((LA26_0
>= CHARTOK
) && (LA26_0
<= ENUMTOK
))
4889 || ((LA26_0
>= FLOATINGPOINTTOK
) && (LA26_0
<= SIGNEDTOK
))
4890 || ((LA26_0
>= STRINGTOK
) && (LA26_0
<= STRUCTTOK
)) || ((LA26_0
>= UNSIGNEDTOK
) && (LA26_0
<= IMAGINARYTOK
)))) {
4892 } else if ((LA26_0
== IDENTIFIER
)
4893 && ((inTypealiasAlias() || isTypeName(input
.LT(1)
4900 // Grammar/CTFParser.g:544:4: typeQualifier
4902 pushFollow(FOLLOW_typeQualifier_in_specifierQualifierList1771
);
4903 typeQualifier81
= typeQualifier();
4909 if (state
.backtracking
== 0) {
4910 stream_typeQualifier
.add(typeQualifier81
.getTree());
4916 // Grammar/CTFParser.g:544:20: typeSpecifier
4918 pushFollow(FOLLOW_typeSpecifier_in_specifierQualifierList1775
);
4919 typeSpecifier82
= typeSpecifier();
4925 if (state
.backtracking
== 0) {
4926 stream_typeSpecifier
.add(typeSpecifier82
.getTree());
4936 if (state
.backtracking
> 0) {
4937 state
.failed
= true;
4940 EarlyExitException eee
= new EarlyExitException(26,
4948 // elements: typeSpecifier, typeQualifier
4950 // rule labels: retval
4951 // token list labels:
4952 // rule list labels:
4954 if (state
.backtracking
== 0) {
4955 retval
.tree
= root_0
;
4956 // RewriteRuleSubtreeStream stream_retval =
4957 new RewriteRuleSubtreeStream(
4958 adaptor
, "rule retval",
4959 retval
!= null ? retval
.tree
: null);
4961 root_0
= (CommonTree
) adaptor
.nil();
4962 // 544:36: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
4963 // typeSpecifier )* )
4965 // Grammar/CTFParser.g:544:39: ^( TYPE_SPECIFIER_LIST (
4966 // typeQualifier )* ( typeSpecifier )* )
4968 CommonTree root_1
= (CommonTree
) adaptor
.nil();
4969 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
4970 .create(TYPE_SPECIFIER_LIST
,
4971 "TYPE_SPECIFIER_LIST"), root_1
);
4973 // Grammar/CTFParser.g:544:61: ( typeQualifier )*
4974 while (stream_typeQualifier
.hasNext()) {
4975 adaptor
.addChild(root_1
,
4976 stream_typeQualifier
.nextTree());
4979 stream_typeQualifier
.reset();
4980 // Grammar/CTFParser.g:544:76: ( typeSpecifier )*
4981 while (stream_typeSpecifier
.hasNext()) {
4982 adaptor
.addChild(root_1
,
4983 stream_typeSpecifier
.nextTree());
4986 stream_typeSpecifier
.reset();
4988 adaptor
.addChild(root_0
, root_1
);
4993 retval
.tree
= root_0
;
4997 retval
.stop
= input
.LT(-1);
4999 if (state
.backtracking
== 0) {
5001 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
5002 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
5005 if (state
.backtracking
== 0) {
5007 exit("specifierQualifierList");
5012 catch (RecognitionException e
) {
5019 // $ANTLR end "specifierQualifierList"
5021 public static class structOrVariantDeclaratorList_return
extends
5022 ParserRuleReturnScope
{
5026 public Object
getTree() {
5031 // $ANTLR start "structOrVariantDeclaratorList"
5032 // Grammar/CTFParser.g:547:1: structOrVariantDeclaratorList :
5033 // structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )* -> ^(
5034 // TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ ) ;
5035 public final CTFParser
.structOrVariantDeclaratorList_return
structOrVariantDeclaratorList()
5036 throws RecognitionException
{
5037 CTFParser
.structOrVariantDeclaratorList_return retval
= new CTFParser
.structOrVariantDeclaratorList_return();
5038 retval
.start
= input
.LT(1);
5040 CommonTree root_0
= null;
5042 Token SEPARATOR84
= null;
5043 CTFParser
.structOrVariantDeclarator_return structOrVariantDeclarator83
= null;
5045 CTFParser
.structOrVariantDeclarator_return structOrVariantDeclarator85
= null;
5047 CommonTree SEPARATOR84_tree
= null;
5048 RewriteRuleTokenStream stream_SEPARATOR
= new RewriteRuleTokenStream(
5049 adaptor
, "token SEPARATOR");
5050 RewriteRuleSubtreeStream stream_structOrVariantDeclarator
= new RewriteRuleSubtreeStream(
5051 adaptor
, "rule structOrVariantDeclarator");
5053 enter("structOrVariantDeclaratorList");
5056 // Grammar/CTFParser.g:554:1: ( structOrVariantDeclarator (
5057 // SEPARATOR structOrVariantDeclarator )* -> ^( TYPE_DECLARATOR_LIST
5058 // ( structOrVariantDeclarator )+ ) )
5059 // Grammar/CTFParser.g:555:3: structOrVariantDeclarator ( SEPARATOR
5060 // structOrVariantDeclarator )*
5062 pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1812
);
5063 structOrVariantDeclarator83
= structOrVariantDeclarator();
5069 if (state
.backtracking
== 0) {
5070 stream_structOrVariantDeclarator
5071 .add(structOrVariantDeclarator83
.getTree());
5073 // Grammar/CTFParser.g:555:29: ( SEPARATOR
5074 // structOrVariantDeclarator )*
5077 int LA27_0
= input
.LA(1);
5079 if ((LA27_0
== SEPARATOR
)) {
5085 // Grammar/CTFParser.g:555:30: SEPARATOR
5086 // structOrVariantDeclarator
5088 SEPARATOR84
= (Token
) match(input
, SEPARATOR
,
5089 FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1815
);
5093 if (state
.backtracking
== 0) {
5094 stream_SEPARATOR
.add(SEPARATOR84
);
5097 pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1817
);
5098 structOrVariantDeclarator85
= structOrVariantDeclarator();
5104 if (state
.backtracking
== 0) {
5105 stream_structOrVariantDeclarator
5106 .add(structOrVariantDeclarator85
.getTree());
5118 // elements: structOrVariantDeclarator
5120 // rule labels: retval
5121 // token list labels:
5122 // rule list labels:
5124 if (state
.backtracking
== 0) {
5125 retval
.tree
= root_0
;
5126 // RewriteRuleSubtreeStream stream_retval =
5127 new RewriteRuleSubtreeStream(
5128 adaptor
, "rule retval",
5129 retval
!= null ? retval
.tree
: null);
5131 root_0
= (CommonTree
) adaptor
.nil();
5132 // 555:68: -> ^( TYPE_DECLARATOR_LIST (
5133 // structOrVariantDeclarator )+ )
5135 // Grammar/CTFParser.g:555:71: ^( TYPE_DECLARATOR_LIST (
5136 // structOrVariantDeclarator )+ )
5138 CommonTree root_1
= (CommonTree
) adaptor
.nil();
5139 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
5140 .create(TYPE_DECLARATOR_LIST
,
5141 "TYPE_DECLARATOR_LIST"), root_1
);
5143 if (!(stream_structOrVariantDeclarator
.hasNext())) {
5144 throw new RewriteEarlyExitException();
5146 while (stream_structOrVariantDeclarator
.hasNext()) {
5147 adaptor
.addChild(root_1
,
5148 stream_structOrVariantDeclarator
5152 stream_structOrVariantDeclarator
.reset();
5154 adaptor
.addChild(root_0
, root_1
);
5159 retval
.tree
= root_0
;
5163 retval
.stop
= input
.LT(-1);
5165 if (state
.backtracking
== 0) {
5167 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
5168 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
5171 if (state
.backtracking
== 0) {
5173 exit("structOrVariantDeclaratorList");
5178 catch (RecognitionException e
) {
5184 // $ANTLR end "structOrVariantDeclaratorList"
5186 public static class structOrVariantDeclarator_return
extends
5187 ParserRuleReturnScope
{
5191 public Object
getTree() {
5196 // $ANTLR start "structOrVariantDeclarator"
5197 // Grammar/CTFParser.g:558:1: structOrVariantDeclarator : ( declarator (
5198 // COLON numberLiteral )? ) -> declarator ;
5199 public final CTFParser
.structOrVariantDeclarator_return
structOrVariantDeclarator()
5200 throws RecognitionException
{
5201 CTFParser
.structOrVariantDeclarator_return retval
= new CTFParser
.structOrVariantDeclarator_return();
5202 retval
.start
= input
.LT(1);
5204 CommonTree root_0
= null;
5206 Token COLON87
= null;
5207 CTFParser
.declarator_return declarator86
= null;
5209 CTFParser
.numberLiteral_return numberLiteral88
= null;
5211 CommonTree COLON87_tree
= null;
5212 RewriteRuleTokenStream stream_COLON
= new RewriteRuleTokenStream(
5213 adaptor
, "token COLON");
5214 RewriteRuleSubtreeStream stream_declarator
= new RewriteRuleSubtreeStream(
5215 adaptor
, "rule declarator");
5216 RewriteRuleSubtreeStream stream_numberLiteral
= new RewriteRuleSubtreeStream(
5217 adaptor
, "rule numberLiteral");
5219 enter("structOrVariantDeclarator");
5222 // Grammar/CTFParser.g:565:1: ( ( declarator ( COLON numberLiteral
5223 // )? ) -> declarator )
5224 // Grammar/CTFParser.g:567:5: ( declarator ( COLON numberLiteral )?
5227 // Grammar/CTFParser.g:567:5: ( declarator ( COLON numberLiteral
5229 // Grammar/CTFParser.g:567:6: declarator ( COLON numberLiteral
5232 pushFollow(FOLLOW_declarator_in_structOrVariantDeclarator1858
);
5233 declarator86
= declarator();
5239 if (state
.backtracking
== 0) {
5240 stream_declarator
.add(declarator86
.getTree());
5242 // Grammar/CTFParser.g:567:17: ( COLON numberLiteral )?
5244 int LA28_0
= input
.LA(1);
5246 if ((LA28_0
== COLON
)) {
5251 // Grammar/CTFParser.g:567:18: COLON numberLiteral
5253 COLON87
= (Token
) match(input
, COLON
,
5254 FOLLOW_COLON_in_structOrVariantDeclarator1861
);
5258 if (state
.backtracking
== 0) {
5259 stream_COLON
.add(COLON87
);
5262 pushFollow(FOLLOW_numberLiteral_in_structOrVariantDeclarator1863
);
5263 numberLiteral88
= numberLiteral();
5269 if (state
.backtracking
== 0) {
5270 stream_numberLiteral
.add(numberLiteral88
.getTree());
5281 // elements: declarator
5283 // rule labels: retval
5284 // token list labels:
5285 // rule list labels:
5287 if (state
.backtracking
== 0) {
5288 retval
.tree
= root_0
;
5289 // RewriteRuleSubtreeStream stream_retval =
5290 new RewriteRuleSubtreeStream(
5291 adaptor
, "rule retval",
5292 retval
!= null ? retval
.tree
: null);
5294 root_0
= (CommonTree
) adaptor
.nil();
5295 // 567:41: -> declarator
5297 adaptor
.addChild(root_0
, stream_declarator
.nextTree());
5301 retval
.tree
= root_0
;
5305 retval
.stop
= input
.LT(-1);
5307 if (state
.backtracking
== 0) {
5309 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
5310 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
5313 if (state
.backtracking
== 0) {
5315 exit("structOrVariantDeclarator");
5320 catch (RecognitionException e
) {
5326 // $ANTLR end "structOrVariantDeclarator"
5328 public static class variantSpecifier_return
extends ParserRuleReturnScope
{
5332 public Object
getTree() {
5337 // $ANTLR start "variantSpecifier"
5338 // Grammar/CTFParser.g:571:1: variantSpecifier : VARIANTTOK ( ( variantName
5339 // ( ( variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
5340 // variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? ( variantTag
5341 // )? ( variantBody )? ) ;
5342 public final CTFParser
.variantSpecifier_return
variantSpecifier()
5343 throws RecognitionException
{
5344 CTFParser
.variantSpecifier_return retval
= new CTFParser
.variantSpecifier_return();
5345 retval
.start
= input
.LT(1);
5347 CommonTree root_0
= null;
5349 Token VARIANTTOK89
= null;
5350 CTFParser
.variantName_return variantName90
= null;
5352 CTFParser
.variantTag_return variantTag91
= null;
5354 CTFParser
.variantBody_return variantBody92
= null;
5356 CTFParser
.variantBody_return variantBody93
= null;
5358 CTFParser
.variantTag_return variantTag94
= null;
5360 CTFParser
.variantBody_return variantBody95
= null;
5362 CTFParser
.variantBody_return variantBody96
= null;
5364 CommonTree VARIANTTOK89_tree
= null;
5365 RewriteRuleTokenStream stream_VARIANTTOK
= new RewriteRuleTokenStream(
5366 adaptor
, "token VARIANTTOK");
5367 RewriteRuleSubtreeStream stream_variantName
= new RewriteRuleSubtreeStream(
5368 adaptor
, "rule variantName");
5369 RewriteRuleSubtreeStream stream_variantTag
= new RewriteRuleSubtreeStream(
5370 adaptor
, "rule variantTag");
5371 RewriteRuleSubtreeStream stream_variantBody
= new RewriteRuleSubtreeStream(
5372 adaptor
, "rule variantBody");
5374 enter("variantSpecifier");
5377 // Grammar/CTFParser.g:578:1: ( VARIANTTOK ( ( variantName ( (
5378 // variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
5379 // variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? (
5380 // variantTag )? ( variantBody )? ) )
5381 // Grammar/CTFParser.g:579:3: VARIANTTOK ( ( variantName ( (
5382 // variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
5383 // variantBody ) | variantBody )
5385 VARIANTTOK89
= (Token
) match(input
, VARIANTTOK
,
5386 FOLLOW_VARIANTTOK_in_variantSpecifier1897
);
5390 if (state
.backtracking
== 0) {
5391 stream_VARIANTTOK
.add(VARIANTTOK89
);
5394 // Grammar/CTFParser.g:580:3: ( ( variantName ( ( variantTag (
5395 // variantBody | ) ) | variantBody ) ) | ( variantTag
5396 // variantBody ) | variantBody )
5398 switch (input
.LA(1)) {
5412 if (state
.backtracking
> 0) {
5413 state
.failed
= true;
5416 NoViableAltException nvae
= new NoViableAltException("",
5424 // Grammar/CTFParser.g:581:5: ( variantName ( ( variantTag (
5425 // variantBody | ) ) | variantBody ) )
5427 // Grammar/CTFParser.g:581:5: ( variantName ( ( variantTag (
5428 // variantBody | ) ) | variantBody ) )
5429 // Grammar/CTFParser.g:582:7: variantName ( ( variantTag (
5430 // variantBody | ) ) | variantBody )
5432 pushFollow(FOLLOW_variantName_in_variantSpecifier1915
);
5433 variantName90
= variantName();
5439 if (state
.backtracking
== 0) {
5440 stream_variantName
.add(variantName90
.getTree());
5442 // Grammar/CTFParser.g:583:7: ( ( variantTag (
5443 // variantBody | ) ) | variantBody )
5445 int LA30_0
= input
.LA(1);
5447 if ((LA30_0
== LT
)) {
5449 } else if ((LA30_0
== LCURL
)) {
5452 if (state
.backtracking
> 0) {
5453 state
.failed
= true;
5456 NoViableAltException nvae
= new NoViableAltException(
5463 // Grammar/CTFParser.g:584:9: ( variantTag ( variantBody
5466 // Grammar/CTFParser.g:584:9: ( variantTag (
5467 // variantBody | ) )
5468 // Grammar/CTFParser.g:585:11: variantTag (
5471 pushFollow(FOLLOW_variantTag_in_variantSpecifier1946
);
5472 variantTag91
= variantTag();
5478 if (state
.backtracking
== 0) {
5479 stream_variantTag
.add(variantTag91
5482 // Grammar/CTFParser.g:586:11: ( variantBody | )
5484 int LA29_0
= input
.LA(1);
5486 if ((LA29_0
== LCURL
)) {
5487 switch (input
.LA(2)) {
5492 case FLOATINGPOINTTOK
:
5506 case IMAGINARYTOK
: {
5511 int LA29_4
= input
.LA(3);
5513 if ((((LA29_4
>= CONSTTOK
) && (LA29_4
<= ENUMTOK
))
5514 || ((LA29_4
>= FLOATINGPOINTTOK
) && (LA29_4
<= SIGNEDTOK
))
5515 || ((LA29_4
>= STRINGTOK
) && (LA29_4
<= STRUCTTOK
))
5516 || ((LA29_4
>= TYPEDEFTOK
) && (LA29_4
<= IMAGINARYTOK
))
5517 || (LA29_4
== POINTER
) || (LA29_4
== IDENTIFIER
))) {
5519 } else if (((LA29_4
== SEPARATOR
)
5520 || (LA29_4
== ASSIGNMENT
) || (LA29_4
== RCURL
))) {
5523 if (state
.backtracking
> 0) {
5524 state
.failed
= true;
5527 NoViableAltException nvae
= new NoViableAltException(
5535 int LA29_5
= input
.LA(3);
5537 if (((LA29_5
== SEPARATOR
)
5538 || (LA29_5
== ASSIGNMENT
) || (LA29_5
== RCURL
))) {
5540 } else if ((((LA29_5
>= CONSTTOK
) && (LA29_5
<= ENUMTOK
))
5541 || ((LA29_5
>= FLOATINGPOINTTOK
) && (LA29_5
<= SIGNEDTOK
))
5542 || ((LA29_5
>= STRINGTOK
) && (LA29_5
<= STRUCTTOK
))
5543 || ((LA29_5
>= TYPEDEFTOK
) && (LA29_5
<= IMAGINARYTOK
))
5544 || (LA29_5
== LCURL
)
5545 || (LA29_5
== POINTER
) || (LA29_5
== IDENTIFIER
))) {
5548 if (state
.backtracking
> 0) {
5549 state
.failed
= true;
5552 NoViableAltException nvae
= new NoViableAltException(
5560 int LA29_6
= input
.LA(3);
5562 if (((LA29_6
== SEPARATOR
)
5563 || (LA29_6
== ASSIGNMENT
) || (LA29_6
== RCURL
))) {
5565 } else if ((((LA29_6
>= CONSTTOK
) && (LA29_6
<= ENUMTOK
))
5566 || ((LA29_6
>= FLOATINGPOINTTOK
) && (LA29_6
<= SIGNEDTOK
))
5567 || ((LA29_6
>= STRINGTOK
) && (LA29_6
<= STRUCTTOK
))
5568 || ((LA29_6
>= TYPEDEFTOK
) && (LA29_6
<= IMAGINARYTOK
))
5569 || (LA29_6
== POINTER
) || (LA29_6
== IDENTIFIER
))) {
5572 if (state
.backtracking
> 0) {
5573 state
.failed
= true;
5576 NoViableAltException nvae
= new NoViableAltException(
5585 case STRING_LITERAL
: {
5590 if (state
.backtracking
> 0) {
5591 state
.failed
= true;
5594 NoViableAltException nvae
= new NoViableAltException(
5600 } else if (((LA29_0
== EOF
)
5601 || ((LA29_0
>= CONSTTOK
) && (LA29_0
<= ENUMTOK
))
5602 || ((LA29_0
>= FLOATINGPOINTTOK
) && (LA29_0
<= SIGNEDTOK
))
5603 || ((LA29_0
>= STRINGTOK
) && (LA29_0
<= STRUCTTOK
))
5604 || ((LA29_0
>= TYPEDEFTOK
) && (LA29_0
<= IMAGINARYTOK
))
5605 || (LA29_0
== TYPE_ASSIGNMENT
)
5606 || (LA29_0
== LPAREN
)
5607 || ((LA29_0
>= TERM
) && (LA29_0
<= POINTER
)) || (LA29_0
== IDENTIFIER
))) {
5610 if (state
.backtracking
> 0) {
5611 state
.failed
= true;
5614 NoViableAltException nvae
= new NoViableAltException(
5621 // Grammar/CTFParser.g:587:13: variantBody
5623 pushFollow(FOLLOW_variantBody_in_variantSpecifier1972
);
5624 variantBody92
= variantBody();
5630 if (state
.backtracking
== 0) {
5631 stream_variantBody
.add(variantBody92
5647 // Grammar/CTFParser.g:593:9: variantBody
5649 pushFollow(FOLLOW_variantBody_in_variantSpecifier2040
);
5650 variantBody93
= variantBody();
5656 if (state
.backtracking
== 0) {
5657 stream_variantBody
.add(variantBody93
.getTree());
5670 // Grammar/CTFParser.g:597:5: ( variantTag variantBody )
5672 // Grammar/CTFParser.g:597:5: ( variantTag variantBody )
5673 // Grammar/CTFParser.g:597:6: variantTag variantBody
5675 pushFollow(FOLLOW_variantTag_in_variantSpecifier2065
);
5676 variantTag94
= variantTag();
5682 if (state
.backtracking
== 0) {
5683 stream_variantTag
.add(variantTag94
.getTree());
5685 pushFollow(FOLLOW_variantBody_in_variantSpecifier2067
);
5686 variantBody95
= variantBody();
5692 if (state
.backtracking
== 0) {
5693 stream_variantBody
.add(variantBody95
.getTree());
5701 // Grammar/CTFParser.g:599:5: variantBody
5703 pushFollow(FOLLOW_variantBody_in_variantSpecifier2078
);
5704 variantBody96
= variantBody();
5710 if (state
.backtracking
== 0) {
5711 stream_variantBody
.add(variantBody96
.getTree());
5720 // elements: variantBody, variantTag, variantName
5722 // rule labels: retval
5723 // token list labels:
5724 // rule list labels:
5726 if (state
.backtracking
== 0) {
5727 retval
.tree
= root_0
;
5728 RewriteRuleSubtreeStream stream_retval
= new RewriteRuleSubtreeStream(
5729 adaptor
, "rule retval",
5730 retval
!= null ? retval
.tree
: null);
5732 root_0
= (CommonTree
) adaptor
.nil();
5733 // 600:5: -> ^( VARIANT ( variantName )? ( variantTag )? (
5736 // Grammar/CTFParser.g:600:8: ^( VARIANT ( variantName
5737 // )? ( variantTag )? ( variantBody )? )
5739 CommonTree root_1
= (CommonTree
) adaptor
.nil();
5740 root_1
= (CommonTree
) adaptor
.becomeRoot(
5741 adaptor
.create(VARIANT
, "VARIANT"), root_1
);
5743 // Grammar/CTFParser.g:600:18: ( variantName )?
5744 if (stream_variantName
.hasNext()) {
5745 adaptor
.addChild(root_1
,
5746 stream_variantName
.nextTree());
5749 stream_variantName
.reset();
5750 // Grammar/CTFParser.g:600:31: ( variantTag )?
5751 if (stream_variantTag
.hasNext()) {
5752 adaptor
.addChild(root_1
,
5753 stream_variantTag
.nextTree());
5756 stream_variantTag
.reset();
5757 // Grammar/CTFParser.g:600:43: ( variantBody )?
5758 if (stream_variantBody
.hasNext()) {
5759 adaptor
.addChild(root_1
,
5760 stream_variantBody
.nextTree());
5763 stream_variantBody
.reset();
5765 adaptor
.addChild(root_0
, root_1
);
5770 retval
.tree
= root_0
;
5774 retval
.stop
= input
.LT(-1);
5776 if (state
.backtracking
== 0) {
5778 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
5779 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
5782 if (state
.backtracking
== 0) {
5784 exit("variantSpecifier");
5789 catch (RecognitionException e
) {
5795 // $ANTLR end "variantSpecifier"
5797 public static class variantName_return
extends ParserRuleReturnScope
{
5801 public Object
getTree() {
5806 // $ANTLR start "variantName"
5807 // Grammar/CTFParser.g:603:1: variantName : IDENTIFIER -> ^( VARIANT_NAME
5809 public final CTFParser
.variantName_return
variantName()
5810 throws RecognitionException
{
5811 CTFParser
.variantName_return retval
= new CTFParser
.variantName_return();
5812 retval
.start
= input
.LT(1);
5814 CommonTree root_0
= null;
5816 Token IDENTIFIER97
= null;
5818 CommonTree IDENTIFIER97_tree
= null;
5819 RewriteRuleTokenStream stream_IDENTIFIER
= new RewriteRuleTokenStream(
5820 adaptor
, "token IDENTIFIER");
5822 enter("variantName");
5825 // Grammar/CTFParser.g:611:1: ( IDENTIFIER -> ^( VARIANT_NAME
5827 // Grammar/CTFParser.g:612:3: IDENTIFIER
5829 IDENTIFIER97
= (Token
) match(input
, IDENTIFIER
,
5830 FOLLOW_IDENTIFIER_in_variantName2120
);
5834 if (state
.backtracking
== 0) {
5835 stream_IDENTIFIER
.add(IDENTIFIER97
);
5839 // elements: IDENTIFIER
5841 // rule labels: retval
5842 // token list labels:
5843 // rule list labels:
5845 if (state
.backtracking
== 0) {
5846 retval
.tree
= root_0
;
5847 // RewriteRuleSubtreeStream stream_retval =
5848 new RewriteRuleSubtreeStream(
5849 adaptor
, "rule retval",
5850 retval
!= null ? retval
.tree
: null);
5852 root_0
= (CommonTree
) adaptor
.nil();
5853 // 612:14: -> ^( VARIANT_NAME IDENTIFIER )
5855 // Grammar/CTFParser.g:612:17: ^( VARIANT_NAME
5858 CommonTree root_1
= (CommonTree
) adaptor
.nil();
5859 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
5860 .create(VARIANT_NAME
, "VARIANT_NAME"),
5863 adaptor
.addChild(root_1
,
5864 stream_IDENTIFIER
.nextNode());
5866 adaptor
.addChild(root_0
, root_1
);
5871 retval
.tree
= root_0
;
5875 retval
.stop
= input
.LT(-1);
5877 if (state
.backtracking
== 0) {
5879 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
5880 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
5883 if (state
.backtracking
== 0) {
5885 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
5886 exit("variantName");
5891 catch (RecognitionException e
) {
5897 // $ANTLR end "variantName"
5899 public static class variantBody_return
extends ParserRuleReturnScope
{
5903 public Object
getTree() {
5908 // $ANTLR start "variantBody"
5909 // Grammar/CTFParser.g:615:1: variantBody : LCURL
5910 // structOrVariantDeclarationList RCURL -> ^( VARIANT_BODY
5911 // structOrVariantDeclarationList ) ;
5912 public final CTFParser
.variantBody_return
variantBody()
5913 throws RecognitionException
{
5914 Symbols_stack
.push(new Symbols_scope());
5916 CTFParser
.variantBody_return retval
= new CTFParser
.variantBody_return();
5917 retval
.start
= input
.LT(1);
5919 CommonTree root_0
= null;
5921 Token LCURL98
= null;
5922 Token RCURL100
= null;
5923 CTFParser
.structOrVariantDeclarationList_return structOrVariantDeclarationList99
= null;
5925 CommonTree LCURL98_tree
= null;
5926 CommonTree RCURL100_tree
= null;
5927 RewriteRuleTokenStream stream_LCURL
= new RewriteRuleTokenStream(
5928 adaptor
, "token LCURL");
5929 RewriteRuleTokenStream stream_RCURL
= new RewriteRuleTokenStream(
5930 adaptor
, "token RCURL");
5931 RewriteRuleSubtreeStream stream_structOrVariantDeclarationList
= new RewriteRuleSubtreeStream(
5932 adaptor
, "rule structOrVariantDeclarationList");
5934 enter("variantBody");
5935 debug_print("Scope push " + Symbols_stack
.size());
5936 ((Symbols_scope
) Symbols_stack
.peek()).types
= new HashSet
<String
>();
5939 // Grammar/CTFParser.g:626:1: ( LCURL structOrVariantDeclarationList
5940 // RCURL -> ^( VARIANT_BODY structOrVariantDeclarationList ) )
5941 // Grammar/CTFParser.g:627:3: LCURL structOrVariantDeclarationList
5944 LCURL98
= (Token
) match(input
, LCURL
,
5945 FOLLOW_LCURL_in_variantBody2156
);
5949 if (state
.backtracking
== 0) {
5950 stream_LCURL
.add(LCURL98
);
5953 pushFollow(FOLLOW_structOrVariantDeclarationList_in_variantBody2158
);
5954 structOrVariantDeclarationList99
= structOrVariantDeclarationList();
5960 if (state
.backtracking
== 0) {
5961 stream_structOrVariantDeclarationList
5962 .add(structOrVariantDeclarationList99
.getTree());
5964 RCURL100
= (Token
) match(input
, RCURL
,
5965 FOLLOW_RCURL_in_variantBody2160
);
5969 if (state
.backtracking
== 0) {
5970 stream_RCURL
.add(RCURL100
);
5974 // elements: structOrVariantDeclarationList
5976 // rule labels: retval
5977 // token list labels:
5978 // rule list labels:
5980 if (state
.backtracking
== 0) {
5981 retval
.tree
= root_0
;
5982 // RewriteRuleSubtreeStream stream_retval =
5983 new RewriteRuleSubtreeStream(
5984 adaptor
, "rule retval",
5985 retval
!= null ? retval
.tree
: null);
5987 root_0
= (CommonTree
) adaptor
.nil();
5988 // 627:46: -> ^( VARIANT_BODY structOrVariantDeclarationList
5991 // Grammar/CTFParser.g:627:49: ^( VARIANT_BODY
5992 // structOrVariantDeclarationList )
5994 CommonTree root_1
= (CommonTree
) adaptor
.nil();
5995 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
5996 .create(VARIANT_BODY
, "VARIANT_BODY"),
5999 adaptor
.addChild(root_1
,
6000 stream_structOrVariantDeclarationList
6003 adaptor
.addChild(root_0
, root_1
);
6008 retval
.tree
= root_0
;
6012 retval
.stop
= input
.LT(-1);
6014 if (state
.backtracking
== 0) {
6016 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
6017 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
6020 if (state
.backtracking
== 0) {
6022 debug_print("Scope pop " + Symbols_stack
.size());
6023 exit("variantBody");
6028 catch (RecognitionException e
) {
6031 Symbols_stack
.pop();
6037 // $ANTLR end "variantBody"
6039 public static class variantTag_return
extends ParserRuleReturnScope
{
6043 public Object
getTree() {
6048 // $ANTLR start "variantTag"
6049 // Grammar/CTFParser.g:630:1: variantTag : LT IDENTIFIER GT -> ^(
6050 // VARIANT_TAG IDENTIFIER ) ;
6051 public final CTFParser
.variantTag_return
variantTag()
6052 throws RecognitionException
{
6053 CTFParser
.variantTag_return retval
= new CTFParser
.variantTag_return();
6054 retval
.start
= input
.LT(1);
6056 CommonTree root_0
= null;
6059 Token IDENTIFIER102
= null;
6062 CommonTree LT101_tree
= null;
6063 CommonTree IDENTIFIER102_tree
= null;
6064 CommonTree GT103_tree
= null;
6065 RewriteRuleTokenStream stream_GT
= new RewriteRuleTokenStream(adaptor
,
6067 RewriteRuleTokenStream stream_LT
= new RewriteRuleTokenStream(adaptor
,
6069 RewriteRuleTokenStream stream_IDENTIFIER
= new RewriteRuleTokenStream(
6070 adaptor
, "token IDENTIFIER");
6072 enter("variantTag");
6075 // Grammar/CTFParser.g:638:1: ( LT IDENTIFIER GT -> ^( VARIANT_TAG
6077 // Grammar/CTFParser.g:639:3: LT IDENTIFIER GT
6079 LT101
= (Token
) match(input
, LT
, FOLLOW_LT_in_variantTag2191
);
6083 if (state
.backtracking
== 0) {
6084 stream_LT
.add(LT101
);
6087 IDENTIFIER102
= (Token
) match(input
, IDENTIFIER
,
6088 FOLLOW_IDENTIFIER_in_variantTag2193
);
6092 if (state
.backtracking
== 0) {
6093 stream_IDENTIFIER
.add(IDENTIFIER102
);
6096 GT103
= (Token
) match(input
, GT
, FOLLOW_GT_in_variantTag2195
);
6100 if (state
.backtracking
== 0) {
6101 stream_GT
.add(GT103
);
6105 // elements: IDENTIFIER
6107 // rule labels: retval
6108 // token list labels:
6109 // rule list labels:
6111 if (state
.backtracking
== 0) {
6112 retval
.tree
= root_0
;
6113 // RewriteRuleSubtreeStream stream_retval =
6114 new RewriteRuleSubtreeStream(
6115 adaptor
, "rule retval",
6116 retval
!= null ? retval
.tree
: null);
6118 root_0
= (CommonTree
) adaptor
.nil();
6119 // 639:20: -> ^( VARIANT_TAG IDENTIFIER )
6121 // Grammar/CTFParser.g:639:23: ^( VARIANT_TAG IDENTIFIER
6124 CommonTree root_1
= (CommonTree
) adaptor
.nil();
6125 root_1
= (CommonTree
) adaptor
.becomeRoot(
6126 adaptor
.create(VARIANT_TAG
, "VARIANT_TAG"),
6129 adaptor
.addChild(root_1
,
6130 stream_IDENTIFIER
.nextNode());
6132 adaptor
.addChild(root_0
, root_1
);
6137 retval
.tree
= root_0
;
6141 retval
.stop
= input
.LT(-1);
6143 if (state
.backtracking
== 0) {
6145 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
6146 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
6149 if (state
.backtracking
== 0) {
6151 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
6157 catch (RecognitionException e
) {
6164 // $ANTLR end "variantTag"
6166 public static class enumSpecifier_return
extends ParserRuleReturnScope
{
6170 public Object
getTree() {
6175 // $ANTLR start "enumSpecifier"
6176 // Grammar/CTFParser.g:642:1: enumSpecifier : ENUMTOK ( ( enumName (
6177 // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
6178 // enumBody | enumBody ) ) -> ^( ENUM ( enumName )? ( enumContainerType )? (
6180 public final CTFParser
.enumSpecifier_return
enumSpecifier()
6181 throws RecognitionException
{
6182 CTFParser
.enumSpecifier_return retval
= new CTFParser
.enumSpecifier_return();
6183 retval
.start
= input
.LT(1);
6185 CommonTree root_0
= null;
6187 Token ENUMTOK104
= null;
6188 CTFParser
.enumName_return enumName105
= null;
6190 CTFParser
.enumContainerType_return enumContainerType106
= null;
6192 CTFParser
.enumBody_return enumBody107
= null;
6194 CTFParser
.enumBody_return enumBody108
= null;
6196 CTFParser
.enumContainerType_return enumContainerType109
= null;
6198 CTFParser
.enumBody_return enumBody110
= null;
6200 CTFParser
.enumBody_return enumBody111
= null;
6202 CommonTree ENUMTOK104_tree
= null;
6203 RewriteRuleTokenStream stream_ENUMTOK
= new RewriteRuleTokenStream(
6204 adaptor
, "token ENUMTOK");
6205 RewriteRuleSubtreeStream stream_enumName
= new RewriteRuleSubtreeStream(
6206 adaptor
, "rule enumName");
6207 RewriteRuleSubtreeStream stream_enumContainerType
= new RewriteRuleSubtreeStream(
6208 adaptor
, "rule enumContainerType");
6209 RewriteRuleSubtreeStream stream_enumBody
= new RewriteRuleSubtreeStream(
6210 adaptor
, "rule enumBody");
6212 enter("enumSpecifier");
6215 // Grammar/CTFParser.g:649:1: ( ENUMTOK ( ( enumName (
6216 // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
6217 // enumBody | enumBody ) ) -> ^( ENUM ( enumName )? (
6218 // enumContainerType )? ( enumBody )? ) )
6219 // Grammar/CTFParser.g:650:2: ENUMTOK ( ( enumName (
6220 // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
6221 // enumBody | enumBody ) )
6223 ENUMTOK104
= (Token
) match(input
, ENUMTOK
,
6224 FOLLOW_ENUMTOK_in_enumSpecifier2225
);
6228 if (state
.backtracking
== 0) {
6229 stream_ENUMTOK
.add(ENUMTOK104
);
6232 // Grammar/CTFParser.g:651:2: ( ( enumName ( enumContainerType
6233 // enumBody | enumBody | ) ) | ( enumContainerType enumBody |
6236 int LA34_0
= input
.LA(1);
6238 if ((LA34_0
== IDENTIFIER
)) {
6240 } else if (((LA34_0
== COLON
) || (LA34_0
== LCURL
))) {
6243 if (state
.backtracking
> 0) {
6244 state
.failed
= true;
6247 NoViableAltException nvae
= new NoViableAltException("",
6254 // Grammar/CTFParser.g:653:3: ( enumName ( enumContainerType
6255 // enumBody | enumBody | ) )
6257 // Grammar/CTFParser.g:653:3: ( enumName ( enumContainerType
6258 // enumBody | enumBody | ) )
6259 // Grammar/CTFParser.g:654:4: enumName ( enumContainerType
6260 // enumBody | enumBody | )
6262 pushFollow(FOLLOW_enumName_in_enumSpecifier2240
);
6263 enumName105
= enumName();
6269 if (state
.backtracking
== 0) {
6270 stream_enumName
.add(enumName105
.getTree());
6272 // Grammar/CTFParser.g:655:4: ( enumContainerType
6273 // enumBody | enumBody | )
6275 alt32
= dfa32
.predict(input
);
6278 // Grammar/CTFParser.g:656:5: enumContainerType enumBody
6280 pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2251
);
6281 enumContainerType106
= enumContainerType();
6287 if (state
.backtracking
== 0) {
6288 stream_enumContainerType
6289 .add(enumContainerType106
.getTree());
6291 pushFollow(FOLLOW_enumBody_in_enumSpecifier2253
);
6292 enumBody107
= enumBody();
6298 if (state
.backtracking
== 0) {
6299 stream_enumBody
.add(enumBody107
.getTree());
6305 // Grammar/CTFParser.g:658:5: enumBody
6307 pushFollow(FOLLOW_enumBody_in_enumSpecifier2265
);
6308 enumBody108
= enumBody();
6314 if (state
.backtracking
== 0) {
6315 stream_enumBody
.add(enumBody108
.getTree());
6327 // Grammar/CTFParser.g:665:3: ( enumContainerType enumBody |
6330 // Grammar/CTFParser.g:665:3: ( enumContainerType enumBody |
6333 int LA33_0
= input
.LA(1);
6335 if ((LA33_0
== COLON
)) {
6337 } else if ((LA33_0
== LCURL
)) {
6340 if (state
.backtracking
> 0) {
6341 state
.failed
= true;
6344 NoViableAltException nvae
= new NoViableAltException(
6351 // Grammar/CTFParser.g:666:4: enumContainerType enumBody
6353 pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2300
);
6354 enumContainerType109
= enumContainerType();
6360 if (state
.backtracking
== 0) {
6361 stream_enumContainerType
.add(enumContainerType109
6364 pushFollow(FOLLOW_enumBody_in_enumSpecifier2302
);
6365 enumBody110
= enumBody();
6371 if (state
.backtracking
== 0) {
6372 stream_enumBody
.add(enumBody110
.getTree());
6378 // Grammar/CTFParser.g:668:4: enumBody
6380 pushFollow(FOLLOW_enumBody_in_enumSpecifier2311
);
6381 enumBody111
= enumBody();
6387 if (state
.backtracking
== 0) {
6388 stream_enumBody
.add(enumBody111
.getTree());
6402 // elements: enumContainerType, enumName, enumBody
6404 // rule labels: retval
6405 // token list labels:
6406 // rule list labels:
6408 if (state
.backtracking
== 0) {
6409 retval
.tree
= root_0
;
6410 // RewriteRuleSubtreeStream stream_retval =
6411 new RewriteRuleSubtreeStream(
6412 adaptor
, "rule retval",
6413 retval
!= null ? retval
.tree
: null);
6415 root_0
= (CommonTree
) adaptor
.nil();
6416 // 670:4: -> ^( ENUM ( enumName )? ( enumContainerType )? (
6419 // Grammar/CTFParser.g:670:7: ^( ENUM ( enumName )? (
6420 // enumContainerType )? ( enumBody )? )
6422 CommonTree root_1
= (CommonTree
) adaptor
.nil();
6423 root_1
= (CommonTree
) adaptor
.becomeRoot(
6424 adaptor
.create(ENUM
, "ENUM"), root_1
);
6426 // Grammar/CTFParser.g:670:14: ( enumName )?
6427 if (stream_enumName
.hasNext()) {
6428 adaptor
.addChild(root_1
,
6429 stream_enumName
.nextTree());
6432 stream_enumName
.reset();
6433 // Grammar/CTFParser.g:670:24: ( enumContainerType
6435 if (stream_enumContainerType
.hasNext()) {
6436 adaptor
.addChild(root_1
,
6437 stream_enumContainerType
.nextTree());
6440 stream_enumContainerType
.reset();
6441 // Grammar/CTFParser.g:670:43: ( enumBody )?
6442 if (stream_enumBody
.hasNext()) {
6443 adaptor
.addChild(root_1
,
6444 stream_enumBody
.nextTree());
6447 stream_enumBody
.reset();
6449 adaptor
.addChild(root_0
, root_1
);
6454 retval
.tree
= root_0
;
6458 retval
.stop
= input
.LT(-1);
6460 if (state
.backtracking
== 0) {
6462 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
6463 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
6466 if (state
.backtracking
== 0) {
6468 exit("enumSpecifier");
6473 catch (RecognitionException e
) {
6480 // $ANTLR end "enumSpecifier"
6482 public static class enumName_return
extends ParserRuleReturnScope
{
6486 public Object
getTree() {
6491 // $ANTLR start "enumName"
6492 // Grammar/CTFParser.g:673:1: enumName : IDENTIFIER -> ^( ENUM_NAME
6494 public final CTFParser
.enumName_return
enumName()
6495 throws RecognitionException
{
6496 CTFParser
.enumName_return retval
= new CTFParser
.enumName_return();
6497 retval
.start
= input
.LT(1);
6499 CommonTree root_0
= null;
6501 Token IDENTIFIER112
= null;
6503 CommonTree IDENTIFIER112_tree
= null;
6504 RewriteRuleTokenStream stream_IDENTIFIER
= new RewriteRuleTokenStream(
6505 adaptor
, "token IDENTIFIER");
6510 // Grammar/CTFParser.g:681:1: ( IDENTIFIER -> ^( ENUM_NAME
6512 // Grammar/CTFParser.g:682:3: IDENTIFIER
6514 IDENTIFIER112
= (Token
) match(input
, IDENTIFIER
,
6515 FOLLOW_IDENTIFIER_in_enumName2356
);
6519 if (state
.backtracking
== 0) {
6520 stream_IDENTIFIER
.add(IDENTIFIER112
);
6524 // elements: IDENTIFIER
6526 // rule labels: retval
6527 // token list labels:
6528 // rule list labels:
6530 if (state
.backtracking
== 0) {
6531 retval
.tree
= root_0
;
6532 // RewriteRuleSubtreeStream stream_retval =
6533 new RewriteRuleSubtreeStream(
6534 adaptor
, "rule retval",
6535 retval
!= null ? retval
.tree
: null);
6537 root_0
= (CommonTree
) adaptor
.nil();
6538 // 682:14: -> ^( ENUM_NAME IDENTIFIER )
6540 // Grammar/CTFParser.g:682:17: ^( ENUM_NAME IDENTIFIER )
6542 CommonTree root_1
= (CommonTree
) adaptor
.nil();
6543 root_1
= (CommonTree
) adaptor
.becomeRoot(
6544 adaptor
.create(ENUM_NAME
, "ENUM_NAME"),
6547 adaptor
.addChild(root_1
,
6548 stream_IDENTIFIER
.nextNode());
6550 adaptor
.addChild(root_0
, root_1
);
6555 retval
.tree
= root_0
;
6559 retval
.stop
= input
.LT(-1);
6561 if (state
.backtracking
== 0) {
6563 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
6564 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
6567 if (state
.backtracking
== 0) {
6569 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
6575 catch (RecognitionException e
) {
6582 // $ANTLR end "enumName"
6584 public static class enumBody_return
extends ParserRuleReturnScope
{
6588 public Object
getTree() {
6593 // $ANTLR start "enumBody"
6594 // Grammar/CTFParser.g:685:1: enumBody : LCURL enumeratorList ( SEPARATOR
6595 // RCURL | RCURL ) -> ^( ENUM_BODY enumeratorList ) ;
6596 public final CTFParser
.enumBody_return
enumBody()
6597 throws RecognitionException
{
6598 CTFParser
.enumBody_return retval
= new CTFParser
.enumBody_return();
6599 retval
.start
= input
.LT(1);
6601 CommonTree root_0
= null;
6603 Token LCURL113
= null;
6604 Token SEPARATOR115
= null;
6605 Token RCURL116
= null;
6606 Token RCURL117
= null;
6607 CTFParser
.enumeratorList_return enumeratorList114
= null;
6609 CommonTree LCURL113_tree
= null;
6610 CommonTree SEPARATOR115_tree
= null;
6611 CommonTree RCURL116_tree
= null;
6612 CommonTree RCURL117_tree
= null;
6613 RewriteRuleTokenStream stream_LCURL
= new RewriteRuleTokenStream(
6614 adaptor
, "token LCURL");
6615 RewriteRuleTokenStream stream_SEPARATOR
= new RewriteRuleTokenStream(
6616 adaptor
, "token SEPARATOR");
6617 RewriteRuleTokenStream stream_RCURL
= new RewriteRuleTokenStream(
6618 adaptor
, "token RCURL");
6619 RewriteRuleSubtreeStream stream_enumeratorList
= new RewriteRuleSubtreeStream(
6620 adaptor
, "rule enumeratorList");
6625 // Grammar/CTFParser.g:692:1: ( LCURL enumeratorList ( SEPARATOR
6626 // RCURL | RCURL ) -> ^( ENUM_BODY enumeratorList ) )
6627 // Grammar/CTFParser.g:693:3: LCURL enumeratorList ( SEPARATOR RCURL
6630 LCURL113
= (Token
) match(input
, LCURL
,
6631 FOLLOW_LCURL_in_enumBody2389
);
6635 if (state
.backtracking
== 0) {
6636 stream_LCURL
.add(LCURL113
);
6639 pushFollow(FOLLOW_enumeratorList_in_enumBody2391
);
6640 enumeratorList114
= enumeratorList();
6646 if (state
.backtracking
== 0) {
6647 stream_enumeratorList
.add(enumeratorList114
.getTree());
6649 // Grammar/CTFParser.g:693:24: ( SEPARATOR RCURL | RCURL )
6651 int LA35_0
= input
.LA(1);
6653 if ((LA35_0
== SEPARATOR
)) {
6655 } else if ((LA35_0
== RCURL
)) {
6658 if (state
.backtracking
> 0) {
6659 state
.failed
= true;
6662 NoViableAltException nvae
= new NoViableAltException("",
6669 // Grammar/CTFParser.g:693:25: SEPARATOR RCURL
6671 SEPARATOR115
= (Token
) match(input
, SEPARATOR
,
6672 FOLLOW_SEPARATOR_in_enumBody2394
);
6676 if (state
.backtracking
== 0) {
6677 stream_SEPARATOR
.add(SEPARATOR115
);
6680 RCURL116
= (Token
) match(input
, RCURL
,
6681 FOLLOW_RCURL_in_enumBody2396
);
6685 if (state
.backtracking
== 0) {
6686 stream_RCURL
.add(RCURL116
);
6692 // Grammar/CTFParser.g:693:43: RCURL
6694 RCURL117
= (Token
) match(input
, RCURL
,
6695 FOLLOW_RCURL_in_enumBody2400
);
6699 if (state
.backtracking
== 0) {
6700 stream_RCURL
.add(RCURL117
);
6709 // elements: enumeratorList
6711 // rule labels: retval
6712 // token list labels:
6713 // rule list labels:
6715 if (state
.backtracking
== 0) {
6716 retval
.tree
= root_0
;
6717 // RewriteRuleSubtreeStream stream_retval =
6718 new RewriteRuleSubtreeStream(
6719 adaptor
, "rule retval",
6720 retval
!= null ? retval
.tree
: null);
6722 root_0
= (CommonTree
) adaptor
.nil();
6723 // 693:50: -> ^( ENUM_BODY enumeratorList )
6725 // Grammar/CTFParser.g:693:53: ^( ENUM_BODY
6728 CommonTree root_1
= (CommonTree
) adaptor
.nil();
6729 root_1
= (CommonTree
) adaptor
.becomeRoot(
6730 adaptor
.create(ENUM_BODY
, "ENUM_BODY"),
6733 adaptor
.addChild(root_1
,
6734 stream_enumeratorList
.nextTree());
6736 adaptor
.addChild(root_0
, root_1
);
6741 retval
.tree
= root_0
;
6745 retval
.stop
= input
.LT(-1);
6747 if (state
.backtracking
== 0) {
6749 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
6750 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
6753 if (state
.backtracking
== 0) {
6760 catch (RecognitionException e
) {
6767 // $ANTLR end "enumBody"
6769 public static class enumContainerType_return
extends ParserRuleReturnScope
{
6773 public Object
getTree() {
6778 // $ANTLR start "enumContainerType"
6779 // Grammar/CTFParser.g:696:1: enumContainerType : COLON
6780 // declarationSpecifiers -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers ) ;
6781 public final CTFParser
.enumContainerType_return
enumContainerType()
6782 throws RecognitionException
{
6783 CTFParser
.enumContainerType_return retval
= new CTFParser
.enumContainerType_return();
6784 retval
.start
= input
.LT(1);
6786 CommonTree root_0
= null;
6788 Token COLON118
= null;
6789 CTFParser
.declarationSpecifiers_return declarationSpecifiers119
= null;
6791 CommonTree COLON118_tree
= null;
6792 RewriteRuleTokenStream stream_COLON
= new RewriteRuleTokenStream(
6793 adaptor
, "token COLON");
6794 RewriteRuleSubtreeStream stream_declarationSpecifiers
= new RewriteRuleSubtreeStream(
6795 adaptor
, "rule declarationSpecifiers");
6797 enter("enumContainerType");
6800 // Grammar/CTFParser.g:703:1: ( COLON declarationSpecifiers -> ^(
6801 // ENUM_CONTAINER_TYPE declarationSpecifiers ) )
6802 // Grammar/CTFParser.g:704:3: COLON declarationSpecifiers
6804 COLON118
= (Token
) match(input
, COLON
,
6805 FOLLOW_COLON_in_enumContainerType2432
);
6809 if (state
.backtracking
== 0) {
6810 stream_COLON
.add(COLON118
);
6813 pushFollow(FOLLOW_declarationSpecifiers_in_enumContainerType2434
);
6814 declarationSpecifiers119
= declarationSpecifiers();
6820 if (state
.backtracking
== 0) {
6821 stream_declarationSpecifiers
.add(declarationSpecifiers119
6826 // elements: declarationSpecifiers
6828 // rule labels: retval
6829 // token list labels:
6830 // rule list labels:
6832 if (state
.backtracking
== 0) {
6833 retval
.tree
= root_0
;
6834 // RewriteRuleSubtreeStream stream_retval =
6835 new RewriteRuleSubtreeStream(
6836 adaptor
, "rule retval",
6837 retval
!= null ? retval
.tree
: null);
6839 root_0
= (CommonTree
) adaptor
.nil();
6840 // 704:31: -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
6842 // Grammar/CTFParser.g:704:34: ^( ENUM_CONTAINER_TYPE
6843 // declarationSpecifiers )
6845 CommonTree root_1
= (CommonTree
) adaptor
.nil();
6846 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
6847 .create(ENUM_CONTAINER_TYPE
,
6848 "ENUM_CONTAINER_TYPE"), root_1
);
6850 adaptor
.addChild(root_1
,
6851 stream_declarationSpecifiers
.nextTree());
6853 adaptor
.addChild(root_0
, root_1
);
6858 retval
.tree
= root_0
;
6862 retval
.stop
= input
.LT(-1);
6864 if (state
.backtracking
== 0) {
6866 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
6867 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
6870 if (state
.backtracking
== 0) {
6872 exit("enumContainerType");
6877 catch (RecognitionException e
) {
6883 // $ANTLR end "enumContainerType"
6885 public static class enumeratorList_return
extends ParserRuleReturnScope
{
6889 public Object
getTree() {
6894 // $ANTLR start "enumeratorList"
6895 // Grammar/CTFParser.g:707:1: enumeratorList : enumerator ( SEPARATOR
6896 // enumerator )* -> ( ^( ENUM_ENUMERATOR enumerator ) )+ ;
6897 public final CTFParser
.enumeratorList_return
enumeratorList()
6898 throws RecognitionException
{
6899 CTFParser
.enumeratorList_return retval
= new CTFParser
.enumeratorList_return();
6900 retval
.start
= input
.LT(1);
6902 CommonTree root_0
= null;
6904 Token SEPARATOR121
= null;
6905 CTFParser
.enumerator_return enumerator120
= null;
6907 CTFParser
.enumerator_return enumerator122
= null;
6909 CommonTree SEPARATOR121_tree
= null;
6910 RewriteRuleTokenStream stream_SEPARATOR
= new RewriteRuleTokenStream(
6911 adaptor
, "token SEPARATOR");
6912 RewriteRuleSubtreeStream stream_enumerator
= new RewriteRuleSubtreeStream(
6913 adaptor
, "rule enumerator");
6915 enter("enumeratorList");
6918 // Grammar/CTFParser.g:714:1: ( enumerator ( SEPARATOR enumerator )*
6919 // -> ( ^( ENUM_ENUMERATOR enumerator ) )+ )
6920 // Grammar/CTFParser.g:715:3: enumerator ( SEPARATOR enumerator )*
6922 pushFollow(FOLLOW_enumerator_in_enumeratorList2465
);
6923 enumerator120
= enumerator();
6929 if (state
.backtracking
== 0) {
6930 stream_enumerator
.add(enumerator120
.getTree());
6932 // Grammar/CTFParser.g:715:14: ( SEPARATOR enumerator )*
6935 int LA36_0
= input
.LA(1);
6937 if ((LA36_0
== SEPARATOR
)) {
6938 int LA36_1
= input
.LA(2);
6940 if (((LA36_1
== ALIGNTOK
) || (LA36_1
== EVENTTOK
)
6941 || (LA36_1
== SIGNEDTOK
)
6942 || (LA36_1
== STRINGTOK
)
6943 || (LA36_1
== STRING_LITERAL
) || (LA36_1
== IDENTIFIER
))) {
6951 // Grammar/CTFParser.g:715:15: SEPARATOR enumerator
6953 SEPARATOR121
= (Token
) match(input
, SEPARATOR
,
6954 FOLLOW_SEPARATOR_in_enumeratorList2468
);
6958 if (state
.backtracking
== 0) {
6959 stream_SEPARATOR
.add(SEPARATOR121
);
6962 pushFollow(FOLLOW_enumerator_in_enumeratorList2470
);
6963 enumerator122
= enumerator();
6969 if (state
.backtracking
== 0) {
6970 stream_enumerator
.add(enumerator122
.getTree());
6982 // elements: enumerator
6984 // rule labels: retval
6985 // token list labels:
6986 // rule list labels:
6988 if (state
.backtracking
== 0) {
6989 retval
.tree
= root_0
;
6990 // RewriteRuleSubtreeStream stream_retval =
6991 new RewriteRuleSubtreeStream(
6992 adaptor
, "rule retval",
6993 retval
!= null ? retval
.tree
: null);
6995 root_0
= (CommonTree
) adaptor
.nil();
6996 // 715:38: -> ( ^( ENUM_ENUMERATOR enumerator ) )+
6998 if (!(stream_enumerator
.hasNext())) {
6999 throw new RewriteEarlyExitException();
7001 while (stream_enumerator
.hasNext()) {
7002 // Grammar/CTFParser.g:715:42: ^( ENUM_ENUMERATOR
7005 CommonTree root_1
= (CommonTree
) adaptor
.nil();
7006 root_1
= (CommonTree
) adaptor
.becomeRoot(
7007 adaptor
.create(ENUM_ENUMERATOR
,
7008 "ENUM_ENUMERATOR"), root_1
);
7010 adaptor
.addChild(root_1
,
7011 stream_enumerator
.nextTree());
7013 adaptor
.addChild(root_0
, root_1
);
7017 stream_enumerator
.reset();
7021 retval
.tree
= root_0
;
7025 retval
.stop
= input
.LT(-1);
7027 if (state
.backtracking
== 0) {
7029 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
7030 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
7033 if (state
.backtracking
== 0) {
7035 exit("enumeratorList");
7040 catch (RecognitionException e
) {
7047 // $ANTLR end "enumeratorList"
7049 public static class enumerator_return
extends ParserRuleReturnScope
{
7053 public Object
getTree() {
7058 // $ANTLR start "enumerator"
7059 // Grammar/CTFParser.g:718:1: enumerator : enumConstant ( enumeratorValue )?
7061 public final CTFParser
.enumerator_return
enumerator()
7062 throws RecognitionException
{
7063 CTFParser
.enumerator_return retval
= new CTFParser
.enumerator_return();
7064 retval
.start
= input
.LT(1);
7066 CommonTree root_0
= null;
7068 CTFParser
.enumConstant_return enumConstant123
= null;
7070 CTFParser
.enumeratorValue_return enumeratorValue124
= null;
7072 enter("enumerator");
7075 // Grammar/CTFParser.g:725:1: ( enumConstant ( enumeratorValue )? )
7076 // Grammar/CTFParser.g:726:3: enumConstant ( enumeratorValue )?
7078 root_0
= (CommonTree
) adaptor
.nil();
7080 pushFollow(FOLLOW_enumConstant_in_enumerator2506
);
7081 enumConstant123
= enumConstant();
7087 if (state
.backtracking
== 0) {
7088 adaptor
.addChild(root_0
, enumConstant123
.getTree());
7090 // Grammar/CTFParser.g:726:16: ( enumeratorValue )?
7092 int LA37_0
= input
.LA(1);
7094 if ((LA37_0
== ASSIGNMENT
)) {
7099 // Grammar/CTFParser.g:726:16: enumeratorValue
7101 pushFollow(FOLLOW_enumeratorValue_in_enumerator2508
);
7102 enumeratorValue124
= enumeratorValue();
7108 if (state
.backtracking
== 0) {
7109 adaptor
.addChild(root_0
, enumeratorValue124
.getTree());
7119 retval
.stop
= input
.LT(-1);
7121 if (state
.backtracking
== 0) {
7123 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
7124 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
7127 if (state
.backtracking
== 0) {
7134 catch (RecognitionException e
) {
7141 // $ANTLR end "enumerator"
7143 public static class enumeratorValue_return
extends ParserRuleReturnScope
{
7147 public Object
getTree() {
7152 // $ANTLR start "enumeratorValue"
7153 // Grammar/CTFParser.g:729:1: enumeratorValue : ASSIGNMENT e1=
7154 // unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression ->
7155 // ^( ENUM_VALUE_RANGE $e1 $e2) ) ;
7156 public final CTFParser
.enumeratorValue_return
enumeratorValue()
7157 throws RecognitionException
{
7158 CTFParser
.enumeratorValue_return retval
= new CTFParser
.enumeratorValue_return();
7159 retval
.start
= input
.LT(1);
7161 CommonTree root_0
= null;
7163 Token ASSIGNMENT125
= null;
7164 Token ELIPSES126
= null;
7165 CTFParser
.unaryExpression_return e1
= null;
7167 CTFParser
.unaryExpression_return e2
= null;
7169 CommonTree ASSIGNMENT125_tree
= null;
7170 CommonTree ELIPSES126_tree
= null;
7171 RewriteRuleTokenStream stream_ASSIGNMENT
= new RewriteRuleTokenStream(
7172 adaptor
, "token ASSIGNMENT");
7173 RewriteRuleTokenStream stream_ELIPSES
= new RewriteRuleTokenStream(
7174 adaptor
, "token ELIPSES");
7175 RewriteRuleSubtreeStream stream_unaryExpression
= new RewriteRuleSubtreeStream(
7176 adaptor
, "rule unaryExpression");
7178 enter("enumeratorValue");
7181 // Grammar/CTFParser.g:736:1: ( ASSIGNMENT e1= unaryExpression ( ->
7182 // ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^(
7183 // ENUM_VALUE_RANGE $e1 $e2) ) )
7184 // Grammar/CTFParser.g:737:3: ASSIGNMENT e1= unaryExpression ( -> ^(
7185 // ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^(
7186 // ENUM_VALUE_RANGE $e1 $e2) )
7188 ASSIGNMENT125
= (Token
) match(input
, ASSIGNMENT
,
7189 FOLLOW_ASSIGNMENT_in_enumeratorValue2532
);
7193 if (state
.backtracking
== 0) {
7194 stream_ASSIGNMENT
.add(ASSIGNMENT125
);
7197 pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2536
);
7198 e1
= unaryExpression();
7204 if (state
.backtracking
== 0) {
7205 stream_unaryExpression
.add(e1
.getTree());
7207 // Grammar/CTFParser.g:738:3: ( -> ^( ENUM_VALUE $e1) | ELIPSES
7208 // e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) )
7210 int LA38_0
= input
.LA(1);
7212 if (((LA38_0
== SEPARATOR
) || (LA38_0
== RCURL
))) {
7214 } else if ((LA38_0
== ELIPSES
)) {
7217 if (state
.backtracking
> 0) {
7218 state
.failed
= true;
7221 NoViableAltException nvae
= new NoViableAltException("",
7228 // Grammar/CTFParser.g:739:5:
7234 // rule labels: retval, e1
7235 // token list labels:
7236 // rule list labels:
7238 if (state
.backtracking
== 0) {
7239 retval
.tree
= root_0
;
7240 // RewriteRuleSubtreeStream stream_retval =
7241 new RewriteRuleSubtreeStream(
7242 adaptor
, "rule retval",
7243 retval
!= null ? retval
.tree
: null);
7244 RewriteRuleSubtreeStream stream_e1
= new RewriteRuleSubtreeStream(
7245 adaptor
, "rule e1", e1
!= null ? e1
.tree
: null);
7247 root_0
= (CommonTree
) adaptor
.nil();
7248 // 739:5: -> ^( ENUM_VALUE $e1)
7250 // Grammar/CTFParser.g:739:8: ^( ENUM_VALUE $e1)
7252 CommonTree root_1
= (CommonTree
) adaptor
.nil();
7253 root_1
= (CommonTree
) adaptor
7254 .becomeRoot(adaptor
.create(ENUM_VALUE
,
7255 "ENUM_VALUE"), root_1
);
7257 adaptor
.addChild(root_1
, stream_e1
.nextTree());
7259 adaptor
.addChild(root_0
, root_1
);
7264 retval
.tree
= root_0
;
7269 // Grammar/CTFParser.g:740:7: ELIPSES e2= unaryExpression
7271 ELIPSES126
= (Token
) match(input
, ELIPSES
,
7272 FOLLOW_ELIPSES_in_enumeratorValue2562
);
7276 if (state
.backtracking
== 0) {
7277 stream_ELIPSES
.add(ELIPSES126
);
7280 pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2566
);
7281 e2
= unaryExpression();
7287 if (state
.backtracking
== 0) {
7288 stream_unaryExpression
.add(e2
.getTree());
7294 // rule labels: retval, e1, e2
7295 // token list labels:
7296 // rule list labels:
7298 if (state
.backtracking
== 0) {
7299 retval
.tree
= root_0
;
7300 // RewriteRuleSubtreeStream stream_retval =
7301 new RewriteRuleSubtreeStream(
7302 adaptor
, "rule retval",
7303 retval
!= null ? retval
.tree
: null);
7304 RewriteRuleSubtreeStream stream_e1
= new RewriteRuleSubtreeStream(
7305 adaptor
, "rule e1", e1
!= null ? e1
.tree
: null);
7306 RewriteRuleSubtreeStream stream_e2
= new RewriteRuleSubtreeStream(
7307 adaptor
, "rule e2", e2
!= null ? e2
.tree
: null);
7309 root_0
= (CommonTree
) adaptor
.nil();
7310 // 740:34: -> ^( ENUM_VALUE_RANGE $e1 $e2)
7312 // Grammar/CTFParser.g:740:37: ^( ENUM_VALUE_RANGE
7315 CommonTree root_1
= (CommonTree
) adaptor
.nil();
7316 root_1
= (CommonTree
) adaptor
.becomeRoot(
7317 adaptor
.create(ENUM_VALUE_RANGE
,
7318 "ENUM_VALUE_RANGE"), root_1
);
7320 adaptor
.addChild(root_1
, stream_e1
.nextTree());
7321 adaptor
.addChild(root_1
, stream_e2
.nextTree());
7323 adaptor
.addChild(root_0
, root_1
);
7328 retval
.tree
= root_0
;
7337 retval
.stop
= input
.LT(-1);
7339 if (state
.backtracking
== 0) {
7341 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
7342 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
7345 if (state
.backtracking
== 0) {
7347 exit("enumeratorValue");
7352 catch (RecognitionException e
) {
7359 // $ANTLR end "enumeratorValue"
7361 public static class declarator_return
extends ParserRuleReturnScope
{
7365 public Object
getTree() {
7370 // $ANTLR start "declarator"
7371 // Grammar/CTFParser.g:745:1: declarator : ( pointer )* directDeclarator ->
7372 // ^( TYPE_DECLARATOR ( pointer )* directDeclarator ) ;
7373 public final CTFParser
.declarator_return
declarator()
7374 throws RecognitionException
{
7375 CTFParser
.declarator_return retval
= new CTFParser
.declarator_return();
7376 retval
.start
= input
.LT(1);
7378 CommonTree root_0
= null;
7380 CTFParser
.pointer_return pointer127
= null;
7382 CTFParser
.directDeclarator_return directDeclarator128
= null;
7384 RewriteRuleSubtreeStream stream_directDeclarator
= new RewriteRuleSubtreeStream(
7385 adaptor
, "rule directDeclarator");
7386 RewriteRuleSubtreeStream stream_pointer
= new RewriteRuleSubtreeStream(
7387 adaptor
, "rule pointer");
7389 enter("declarator");
7392 // Grammar/CTFParser.g:752:1: ( ( pointer )* directDeclarator -> ^(
7393 // TYPE_DECLARATOR ( pointer )* directDeclarator ) )
7394 // Grammar/CTFParser.g:753:3: ( pointer )* directDeclarator
7396 // Grammar/CTFParser.g:753:3: ( pointer )*
7399 int LA39_0
= input
.LA(1);
7401 if ((LA39_0
== POINTER
)) {
7407 // Grammar/CTFParser.g:753:3: pointer
7409 pushFollow(FOLLOW_pointer_in_declarator2608
);
7410 pointer127
= pointer();
7416 if (state
.backtracking
== 0) {
7417 stream_pointer
.add(pointer127
.getTree());
7428 pushFollow(FOLLOW_directDeclarator_in_declarator2611
);
7429 directDeclarator128
= directDeclarator();
7435 if (state
.backtracking
== 0) {
7436 stream_directDeclarator
.add(directDeclarator128
.getTree());
7440 // elements: directDeclarator, pointer
7442 // rule labels: retval
7443 // token list labels:
7444 // rule list labels:
7446 if (state
.backtracking
== 0) {
7447 retval
.tree
= root_0
;
7448 // RewriteRuleSubtreeStream stream_retval =
7449 new RewriteRuleSubtreeStream(
7450 adaptor
, "rule retval",
7451 retval
!= null ? retval
.tree
: null);
7453 root_0
= (CommonTree
) adaptor
.nil();
7454 // 753:29: -> ^( TYPE_DECLARATOR ( pointer )*
7455 // directDeclarator )
7457 // Grammar/CTFParser.g:753:32: ^( TYPE_DECLARATOR (
7458 // pointer )* directDeclarator )
7460 CommonTree root_1
= (CommonTree
) adaptor
.nil();
7461 root_1
= (CommonTree
) adaptor
.becomeRoot(
7462 adaptor
.create(TYPE_DECLARATOR
,
7463 "TYPE_DECLARATOR"), root_1
);
7465 // Grammar/CTFParser.g:753:50: ( pointer )*
7466 while (stream_pointer
.hasNext()) {
7467 adaptor
.addChild(root_1
,
7468 stream_pointer
.nextTree());
7471 stream_pointer
.reset();
7472 adaptor
.addChild(root_1
,
7473 stream_directDeclarator
.nextTree());
7475 adaptor
.addChild(root_0
, root_1
);
7480 retval
.tree
= root_0
;
7484 retval
.stop
= input
.LT(-1);
7486 if (state
.backtracking
== 0) {
7488 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
7489 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
7492 if (state
.backtracking
== 0) {
7499 catch (RecognitionException e
) {
7506 // $ANTLR end "declarator"
7508 public static class directDeclarator_return
extends ParserRuleReturnScope
{
7512 public Object
getTree() {
7517 // $ANTLR start "directDeclarator"
7518 // Grammar/CTFParser.g:756:1: directDeclarator : ( IDENTIFIER ) (
7519 // directDeclaratorSuffix )* ;
7520 public final CTFParser
.directDeclarator_return
directDeclarator()
7521 throws RecognitionException
{
7522 CTFParser
.directDeclarator_return retval
= new CTFParser
.directDeclarator_return();
7523 retval
.start
= input
.LT(1);
7525 CommonTree root_0
= null;
7527 Token IDENTIFIER129
= null;
7528 CTFParser
.directDeclaratorSuffix_return directDeclaratorSuffix130
= null;
7530 CommonTree IDENTIFIER129_tree
= null;
7532 enter("directDeclarator");
7535 // Grammar/CTFParser.g:763:1: ( ( IDENTIFIER ) (
7536 // directDeclaratorSuffix )* )
7537 // Grammar/CTFParser.g:764:3: ( IDENTIFIER ) (
7538 // directDeclaratorSuffix )*
7540 root_0
= (CommonTree
) adaptor
.nil();
7542 // Grammar/CTFParser.g:764:3: ( IDENTIFIER )
7543 // Grammar/CTFParser.g:765:6: IDENTIFIER
7545 IDENTIFIER129
= (Token
) match(input
, IDENTIFIER
,
7546 FOLLOW_IDENTIFIER_in_directDeclarator2655
);
7550 if (state
.backtracking
== 0) {
7551 IDENTIFIER129_tree
= (CommonTree
) adaptor
7552 .create(IDENTIFIER129
);
7553 adaptor
.addChild(root_0
, IDENTIFIER129_tree
);
7555 if (state
.backtracking
== 0) {
7557 addTypeName((IDENTIFIER129
!= null ? IDENTIFIER129
7558 .getText() : null));
7561 if (state
.backtracking
== 0) {
7562 debug_print((IDENTIFIER129
!= null ? IDENTIFIER129
7563 .getText() : null));
7568 // Grammar/CTFParser.g:768:2: ( directDeclaratorSuffix )*
7571 int LA40_0
= input
.LA(1);
7573 if ((LA40_0
== OPENBRAC
)) {
7579 // Grammar/CTFParser.g:768:2: directDeclaratorSuffix
7581 pushFollow(FOLLOW_directDeclaratorSuffix_in_directDeclarator2673
);
7582 directDeclaratorSuffix130
= directDeclaratorSuffix();
7588 if (state
.backtracking
== 0) {
7589 adaptor
.addChild(root_0
,
7590 directDeclaratorSuffix130
.getTree());
7603 retval
.stop
= input
.LT(-1);
7605 if (state
.backtracking
== 0) {
7607 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
7608 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
7611 if (state
.backtracking
== 0) {
7613 exit("directDeclarator");
7618 catch (RecognitionException e
) {
7625 // $ANTLR end "directDeclarator"
7627 public static class directDeclaratorSuffix_return
extends
7628 ParserRuleReturnScope
{
7632 public Object
getTree() {
7637 // $ANTLR start "directDeclaratorSuffix"
7638 // Grammar/CTFParser.g:771:1: directDeclaratorSuffix : OPENBRAC
7639 // directDeclaratorLength CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) ;
7640 public final CTFParser
.directDeclaratorSuffix_return
directDeclaratorSuffix()
7641 throws RecognitionException
{
7642 CTFParser
.directDeclaratorSuffix_return retval
= new CTFParser
.directDeclaratorSuffix_return();
7643 retval
.start
= input
.LT(1);
7645 CommonTree root_0
= null;
7647 Token OPENBRAC131
= null;
7648 Token CLOSEBRAC133
= null;
7649 CTFParser
.directDeclaratorLength_return directDeclaratorLength132
= null;
7651 CommonTree OPENBRAC131_tree
= null;
7652 CommonTree CLOSEBRAC133_tree
= null;
7653 RewriteRuleTokenStream stream_OPENBRAC
= new RewriteRuleTokenStream(
7654 adaptor
, "token OPENBRAC");
7655 RewriteRuleTokenStream stream_CLOSEBRAC
= new RewriteRuleTokenStream(
7656 adaptor
, "token CLOSEBRAC");
7657 RewriteRuleSubtreeStream stream_directDeclaratorLength
= new RewriteRuleSubtreeStream(
7658 adaptor
, "rule directDeclaratorLength");
7660 // Grammar/CTFParser.g:771:23: ( OPENBRAC directDeclaratorLength
7661 // CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) )
7662 // Grammar/CTFParser.g:772:3: OPENBRAC directDeclaratorLength
7665 OPENBRAC131
= (Token
) match(input
, OPENBRAC
,
7666 FOLLOW_OPENBRAC_in_directDeclaratorSuffix2686
);
7670 if (state
.backtracking
== 0) {
7671 stream_OPENBRAC
.add(OPENBRAC131
);
7674 pushFollow(FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2688
);
7675 directDeclaratorLength132
= directDeclaratorLength();
7681 if (state
.backtracking
== 0) {
7682 stream_directDeclaratorLength
.add(directDeclaratorLength132
7685 CLOSEBRAC133
= (Token
) match(input
, CLOSEBRAC
,
7686 FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2690
);
7690 if (state
.backtracking
== 0) {
7691 stream_CLOSEBRAC
.add(CLOSEBRAC133
);
7695 // elements: directDeclaratorLength
7697 // rule labels: retval
7698 // token list labels:
7699 // rule list labels:
7701 if (state
.backtracking
== 0) {
7702 retval
.tree
= root_0
;
7703 // RewriteRuleSubtreeStream stream_retval =
7704 new RewriteRuleSubtreeStream(
7705 adaptor
, "rule retval",
7706 retval
!= null ? retval
.tree
: null);
7708 root_0
= (CommonTree
) adaptor
.nil();
7709 // 772:45: -> ^( LENGTH directDeclaratorLength )
7711 // Grammar/CTFParser.g:772:48: ^( LENGTH
7712 // directDeclaratorLength )
7714 CommonTree root_1
= (CommonTree
) adaptor
.nil();
7715 root_1
= (CommonTree
) adaptor
.becomeRoot(
7716 adaptor
.create(LENGTH
, "LENGTH"), root_1
);
7718 adaptor
.addChild(root_1
,
7719 stream_directDeclaratorLength
.nextTree());
7721 adaptor
.addChild(root_0
, root_1
);
7726 retval
.tree
= root_0
;
7730 retval
.stop
= input
.LT(-1);
7732 if (state
.backtracking
== 0) {
7734 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
7735 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
7740 catch (RecognitionException e
) {
7747 // $ANTLR end "directDeclaratorSuffix"
7749 public static class directDeclaratorLength_return
extends
7750 ParserRuleReturnScope
{
7754 public Object
getTree() {
7759 // $ANTLR start "directDeclaratorLength"
7760 // Grammar/CTFParser.g:775:1: directDeclaratorLength : unaryExpression ;
7761 public final CTFParser
.directDeclaratorLength_return
directDeclaratorLength()
7762 throws RecognitionException
{
7763 CTFParser
.directDeclaratorLength_return retval
= new CTFParser
.directDeclaratorLength_return();
7764 retval
.start
= input
.LT(1);
7766 CommonTree root_0
= null;
7768 CTFParser
.unaryExpression_return unaryExpression134
= null;
7771 // Grammar/CTFParser.g:775:24: ( unaryExpression )
7772 // Grammar/CTFParser.g:776:3: unaryExpression
7774 root_0
= (CommonTree
) adaptor
.nil();
7776 pushFollow(FOLLOW_unaryExpression_in_directDeclaratorLength2711
);
7777 unaryExpression134
= unaryExpression();
7783 if (state
.backtracking
== 0) {
7784 adaptor
.addChild(root_0
, unaryExpression134
.getTree());
7789 retval
.stop
= input
.LT(-1);
7791 if (state
.backtracking
== 0) {
7793 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
7794 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
7799 catch (RecognitionException e
) {
7806 // $ANTLR end "directDeclaratorLength"
7808 public static class abstractDeclarator_return
extends ParserRuleReturnScope
{
7812 public Object
getTree() {
7817 // $ANTLR start "abstractDeclarator"
7818 // Grammar/CTFParser.g:780:1: abstractDeclarator : ( ( ( pointer )+ (
7819 // directAbstractDeclarator )? ) -> ^( TYPE_DECLARATOR ( pointer )+ (
7820 // directAbstractDeclarator )? ) | directAbstractDeclarator -> ^(
7821 // TYPE_DECLARATOR directAbstractDeclarator ) );
7822 public final CTFParser
.abstractDeclarator_return
abstractDeclarator()
7823 throws RecognitionException
{
7824 CTFParser
.abstractDeclarator_return retval
= new CTFParser
.abstractDeclarator_return();
7825 retval
.start
= input
.LT(1);
7827 CommonTree root_0
= null;
7829 CTFParser
.pointer_return pointer135
= null;
7831 CTFParser
.directAbstractDeclarator_return directAbstractDeclarator136
= null;
7833 CTFParser
.directAbstractDeclarator_return directAbstractDeclarator137
= null;
7835 RewriteRuleSubtreeStream stream_pointer
= new RewriteRuleSubtreeStream(
7836 adaptor
, "rule pointer");
7837 RewriteRuleSubtreeStream stream_directAbstractDeclarator
= new RewriteRuleSubtreeStream(
7838 adaptor
, "rule directAbstractDeclarator");
7840 enter("abstractDeclarator");
7843 // Grammar/CTFParser.g:787:1: ( ( ( pointer )+ (
7844 // directAbstractDeclarator )? ) -> ^( TYPE_DECLARATOR ( pointer )+
7845 // ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^(
7846 // TYPE_DECLARATOR directAbstractDeclarator ) )
7848 int LA43_0
= input
.LA(1);
7850 if ((LA43_0
== POINTER
)) {
7852 } else if (((LA43_0
== LPAREN
) || (LA43_0
== IDENTIFIER
))) {
7855 if (state
.backtracking
> 0) {
7856 state
.failed
= true;
7859 NoViableAltException nvae
= new NoViableAltException("", 43, 0,
7866 // Grammar/CTFParser.g:788:5: ( ( pointer )+ (
7867 // directAbstractDeclarator )? )
7869 // Grammar/CTFParser.g:788:5: ( ( pointer )+ (
7870 // directAbstractDeclarator )? )
7871 // Grammar/CTFParser.g:788:6: ( pointer )+ (
7872 // directAbstractDeclarator )?
7874 // Grammar/CTFParser.g:788:6: ( pointer )+
7878 int LA41_0
= input
.LA(1);
7880 if ((LA41_0
== POINTER
)) {
7886 // Grammar/CTFParser.g:788:6: pointer
7888 pushFollow(FOLLOW_pointer_in_abstractDeclarator2742
);
7889 pointer135
= pointer();
7895 if (state
.backtracking
== 0) {
7896 stream_pointer
.add(pointer135
.getTree());
7906 if (state
.backtracking
> 0) {
7907 state
.failed
= true;
7910 EarlyExitException eee
= new EarlyExitException(41,
7917 // Grammar/CTFParser.g:788:15: ( directAbstractDeclarator )?
7919 int LA42_0
= input
.LA(1);
7921 if (((LA42_0
== LPAREN
) || (LA42_0
== IDENTIFIER
))) {
7926 // Grammar/CTFParser.g:788:15: directAbstractDeclarator
7928 pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2745
);
7929 directAbstractDeclarator136
= directAbstractDeclarator();
7935 if (state
.backtracking
== 0) {
7936 stream_directAbstractDeclarator
7937 .add(directAbstractDeclarator136
.getTree());
7948 // elements: pointer, directAbstractDeclarator
7950 // rule labels: retval
7951 // token list labels:
7952 // rule list labels:
7954 if (state
.backtracking
== 0) {
7955 retval
.tree
= root_0
;
7956 // RewriteRuleSubtreeStream stream_retval =
7957 new RewriteRuleSubtreeStream(
7958 adaptor
, "rule retval",
7959 retval
!= null ? retval
.tree
: null);
7961 root_0
= (CommonTree
) adaptor
.nil();
7962 // 788:42: -> ^( TYPE_DECLARATOR ( pointer )+ (
7963 // directAbstractDeclarator )? )
7965 // Grammar/CTFParser.g:788:45: ^( TYPE_DECLARATOR (
7966 // pointer )+ ( directAbstractDeclarator )? )
7968 CommonTree root_1
= (CommonTree
) adaptor
.nil();
7969 root_1
= (CommonTree
) adaptor
.becomeRoot(
7970 adaptor
.create(TYPE_DECLARATOR
,
7971 "TYPE_DECLARATOR"), root_1
);
7973 if (!(stream_pointer
.hasNext())) {
7974 throw new RewriteEarlyExitException();
7976 while (stream_pointer
.hasNext()) {
7977 adaptor
.addChild(root_1
,
7978 stream_pointer
.nextTree());
7981 stream_pointer
.reset();
7982 // Grammar/CTFParser.g:788:72: (
7983 // directAbstractDeclarator )?
7984 if (stream_directAbstractDeclarator
.hasNext()) {
7985 adaptor
.addChild(root_1
,
7986 stream_directAbstractDeclarator
7990 stream_directAbstractDeclarator
.reset();
7992 adaptor
.addChild(root_0
, root_1
);
7997 retval
.tree
= root_0
;
8002 // Grammar/CTFParser.g:789:5: directAbstractDeclarator
8004 pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2765
);
8005 directAbstractDeclarator137
= directAbstractDeclarator();
8011 if (state
.backtracking
== 0) {
8012 stream_directAbstractDeclarator
8013 .add(directAbstractDeclarator137
.getTree());
8017 // elements: directAbstractDeclarator
8019 // rule labels: retval
8020 // token list labels:
8021 // rule list labels:
8023 if (state
.backtracking
== 0) {
8024 retval
.tree
= root_0
;
8025 // RewriteRuleSubtreeStream stream_retval =
8026 new RewriteRuleSubtreeStream(
8027 adaptor
, "rule retval",
8028 retval
!= null ? retval
.tree
: null);
8030 root_0
= (CommonTree
) adaptor
.nil();
8031 // 789:30: -> ^( TYPE_DECLARATOR directAbstractDeclarator )
8033 // Grammar/CTFParser.g:789:33: ^( TYPE_DECLARATOR
8034 // directAbstractDeclarator )
8036 CommonTree root_1
= (CommonTree
) adaptor
.nil();
8037 root_1
= (CommonTree
) adaptor
.becomeRoot(
8038 adaptor
.create(TYPE_DECLARATOR
,
8039 "TYPE_DECLARATOR"), root_1
);
8041 adaptor
.addChild(root_1
,
8042 stream_directAbstractDeclarator
.nextTree());
8044 adaptor
.addChild(root_0
, root_1
);
8049 retval
.tree
= root_0
;
8055 retval
.stop
= input
.LT(-1);
8057 if (state
.backtracking
== 0) {
8059 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
8060 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
8063 if (state
.backtracking
== 0) {
8065 exit("abstractDeclarator");
8070 catch (RecognitionException e
) {
8077 // $ANTLR end "abstractDeclarator"
8079 public static class directAbstractDeclarator_return
extends
8080 ParserRuleReturnScope
{
8084 public Object
getTree() {
8089 // $ANTLR start "directAbstractDeclarator"
8090 // Grammar/CTFParser.g:796:1: directAbstractDeclarator : ( IDENTIFIER | (
8091 // LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
8093 public final CTFParser
.directAbstractDeclarator_return
directAbstractDeclarator()
8094 throws RecognitionException
{
8095 CTFParser
.directAbstractDeclarator_return retval
= new CTFParser
.directAbstractDeclarator_return();
8096 retval
.start
= input
.LT(1);
8098 CommonTree root_0
= null;
8100 Token IDENTIFIER138
= null;
8101 Token LPAREN139
= null;
8102 Token RPAREN141
= null;
8103 Token OPENBRAC142
= null;
8104 Token CLOSEBRAC144
= null;
8105 CTFParser
.abstractDeclarator_return abstractDeclarator140
= null;
8107 CTFParser
.unaryExpression_return unaryExpression143
= null;
8109 CommonTree IDENTIFIER138_tree
= null;
8110 CommonTree LPAREN139_tree
= null;
8111 CommonTree RPAREN141_tree
= null;
8112 CommonTree OPENBRAC142_tree
= null;
8113 CommonTree CLOSEBRAC144_tree
= null;
8115 enter("directAbstractDeclarator");
8118 // Grammar/CTFParser.g:804:1: ( ( IDENTIFIER | ( LPAREN
8119 // abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
8121 // Grammar/CTFParser.g:805:3: ( IDENTIFIER | ( LPAREN
8122 // abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
8125 root_0
= (CommonTree
) adaptor
.nil();
8127 // Grammar/CTFParser.g:805:3: ( IDENTIFIER | ( LPAREN
8128 // abstractDeclarator RPAREN ) )
8130 int LA44_0
= input
.LA(1);
8132 if ((LA44_0
== IDENTIFIER
)) {
8134 } else if ((LA44_0
== LPAREN
)) {
8137 if (state
.backtracking
> 0) {
8138 state
.failed
= true;
8141 NoViableAltException nvae
= new NoViableAltException("",
8148 // Grammar/CTFParser.g:806:6: IDENTIFIER
8150 IDENTIFIER138
= (Token
) match(input
, IDENTIFIER
,
8151 FOLLOW_IDENTIFIER_in_directAbstractDeclarator2805
);
8155 if (state
.backtracking
== 0) {
8156 IDENTIFIER138_tree
= (CommonTree
) adaptor
8157 .create(IDENTIFIER138
);
8158 adaptor
.addChild(root_0
, IDENTIFIER138_tree
);
8164 // Grammar/CTFParser.g:807:7: ( LPAREN abstractDeclarator RPAREN
8167 // Grammar/CTFParser.g:807:7: ( LPAREN abstractDeclarator
8169 // Grammar/CTFParser.g:807:8: LPAREN abstractDeclarator
8172 LPAREN139
= (Token
) match(input
, LPAREN
,
8173 FOLLOW_LPAREN_in_directAbstractDeclarator2814
);
8177 if (state
.backtracking
== 0) {
8178 LPAREN139_tree
= (CommonTree
) adaptor
8180 adaptor
.addChild(root_0
, LPAREN139_tree
);
8182 pushFollow(FOLLOW_abstractDeclarator_in_directAbstractDeclarator2816
);
8183 abstractDeclarator140
= abstractDeclarator();
8189 if (state
.backtracking
== 0) {
8190 adaptor
.addChild(root_0
,
8191 abstractDeclarator140
.getTree());
8193 RPAREN141
= (Token
) match(input
, RPAREN
,
8194 FOLLOW_RPAREN_in_directAbstractDeclarator2818
);
8198 if (state
.backtracking
== 0) {
8199 RPAREN141_tree
= (CommonTree
) adaptor
8201 adaptor
.addChild(root_0
, RPAREN141_tree
);
8211 // Grammar/CTFParser.g:809:3: ( OPENBRAC ( unaryExpression )?
8214 int LA46_0
= input
.LA(1);
8216 if ((LA46_0
== OPENBRAC
)) {
8221 // Grammar/CTFParser.g:810:5: OPENBRAC ( unaryExpression )?
8224 OPENBRAC142
= (Token
) match(input
, OPENBRAC
,
8225 FOLLOW_OPENBRAC_in_directAbstractDeclarator2833
);
8229 if (state
.backtracking
== 0) {
8230 OPENBRAC142_tree
= (CommonTree
) adaptor
8231 .create(OPENBRAC142
);
8232 adaptor
.addChild(root_0
, OPENBRAC142_tree
);
8234 // Grammar/CTFParser.g:810:14: ( unaryExpression )?
8236 int LA45_0
= input
.LA(1);
8238 if (((LA45_0
== ALIGNTOK
) || (LA45_0
== EVENTTOK
)
8239 || ((LA45_0
>= SIGNEDTOK
) && (LA45_0
<= STRINGTOK
))
8240 || (LA45_0
== TRACETOK
)
8241 || ((LA45_0
>= ENVTOK
) && (LA45_0
<= CLOCKTOK
))
8242 || (LA45_0
== SIGN
) || (LA45_0
== OCTAL_LITERAL
)
8243 || (LA45_0
== DECIMAL_LITERAL
)
8244 || (LA45_0
== HEX_LITERAL
)
8245 || (LA45_0
== CHARACTER_LITERAL
)
8246 || (LA45_0
== STRING_LITERAL
) || (LA45_0
== IDENTIFIER
))) {
8251 // Grammar/CTFParser.g:810:14: unaryExpression
8253 pushFollow(FOLLOW_unaryExpression_in_directAbstractDeclarator2835
);
8254 unaryExpression143
= unaryExpression();
8260 if (state
.backtracking
== 0) {
8261 adaptor
.addChild(root_0
,
8262 unaryExpression143
.getTree());
8270 CLOSEBRAC144
= (Token
) match(input
, CLOSEBRAC
,
8271 FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2838
);
8275 if (state
.backtracking
== 0) {
8276 CLOSEBRAC144_tree
= (CommonTree
) adaptor
8277 .create(CLOSEBRAC144
);
8278 adaptor
.addChild(root_0
, CLOSEBRAC144_tree
);
8288 retval
.stop
= input
.LT(-1);
8290 if (state
.backtracking
== 0) {
8292 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
8293 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
8296 if (state
.backtracking
== 0) {
8298 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
8299 exit("directAbstractDeclarator");
8304 catch (RecognitionException e
) {
8311 // $ANTLR end "directAbstractDeclarator"
8313 public static class pointer_return
extends ParserRuleReturnScope
{
8317 public Object
getTree() {
8322 // $ANTLR start "pointer"
8323 // Grammar/CTFParser.g:814:1: pointer : POINTER ( typeQualifierList )? -> ^(
8324 // POINTER ( typeQualifierList )? ) ;
8325 public final CTFParser
.pointer_return
pointer() throws RecognitionException
{
8326 CTFParser
.pointer_return retval
= new CTFParser
.pointer_return();
8327 retval
.start
= input
.LT(1);
8329 CommonTree root_0
= null;
8331 Token POINTER145
= null;
8332 CTFParser
.typeQualifierList_return typeQualifierList146
= null;
8334 CommonTree POINTER145_tree
= null;
8335 RewriteRuleTokenStream stream_POINTER
= new RewriteRuleTokenStream(
8336 adaptor
, "token POINTER");
8337 RewriteRuleSubtreeStream stream_typeQualifierList
= new RewriteRuleSubtreeStream(
8338 adaptor
, "rule typeQualifierList");
8343 // Grammar/CTFParser.g:822:1: ( POINTER ( typeQualifierList )? -> ^(
8344 // POINTER ( typeQualifierList )? ) )
8345 // Grammar/CTFParser.g:823:3: POINTER ( typeQualifierList )?
8347 POINTER145
= (Token
) match(input
, POINTER
,
8348 FOLLOW_POINTER_in_pointer2866
);
8352 if (state
.backtracking
== 0) {
8353 stream_POINTER
.add(POINTER145
);
8356 // Grammar/CTFParser.g:823:11: ( typeQualifierList )?
8358 int LA47_0
= input
.LA(1);
8360 if ((LA47_0
== CONSTTOK
)) {
8365 // Grammar/CTFParser.g:823:11: typeQualifierList
8367 pushFollow(FOLLOW_typeQualifierList_in_pointer2868
);
8368 typeQualifierList146
= typeQualifierList();
8374 if (state
.backtracking
== 0) {
8375 stream_typeQualifierList
.add(typeQualifierList146
8385 // elements: typeQualifierList, POINTER
8387 // rule labels: retval
8388 // token list labels:
8389 // rule list labels:
8391 if (state
.backtracking
== 0) {
8392 retval
.tree
= root_0
;
8393 // RewriteRuleSubtreeStream stream_retval =
8394 new RewriteRuleSubtreeStream(
8395 adaptor
, "rule retval",
8396 retval
!= null ? retval
.tree
: null);
8398 root_0
= (CommonTree
) adaptor
.nil();
8399 // 823:30: -> ^( POINTER ( typeQualifierList )? )
8401 // Grammar/CTFParser.g:823:33: ^( POINTER (
8402 // typeQualifierList )? )
8404 CommonTree root_1
= (CommonTree
) adaptor
.nil();
8405 root_1
= (CommonTree
) adaptor
.becomeRoot(
8406 stream_POINTER
.nextNode(), root_1
);
8408 // Grammar/CTFParser.g:823:43: ( typeQualifierList
8410 if (stream_typeQualifierList
.hasNext()) {
8411 adaptor
.addChild(root_1
,
8412 stream_typeQualifierList
.nextTree());
8415 stream_typeQualifierList
.reset();
8417 adaptor
.addChild(root_0
, root_1
);
8422 retval
.tree
= root_0
;
8426 retval
.stop
= input
.LT(-1);
8428 if (state
.backtracking
== 0) {
8430 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
8431 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
8434 if (state
.backtracking
== 0) {
8436 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
8442 catch (RecognitionException e
) {
8449 // $ANTLR end "pointer"
8451 public static class typeQualifierList_return
extends ParserRuleReturnScope
{
8455 public Object
getTree() {
8460 // $ANTLR start "typeQualifierList"
8461 // Grammar/CTFParser.g:826:1: typeQualifierList : ( typeQualifier )+ ;
8462 public final CTFParser
.typeQualifierList_return
typeQualifierList()
8463 throws RecognitionException
{
8464 CTFParser
.typeQualifierList_return retval
= new CTFParser
.typeQualifierList_return();
8465 retval
.start
= input
.LT(1);
8467 CommonTree root_0
= null;
8469 CTFParser
.typeQualifier_return typeQualifier147
= null;
8472 // Grammar/CTFParser.g:826:19: ( ( typeQualifier )+ )
8473 // Grammar/CTFParser.g:827:3: ( typeQualifier )+
8475 root_0
= (CommonTree
) adaptor
.nil();
8477 // Grammar/CTFParser.g:827:3: ( typeQualifier )+
8481 int LA48_0
= input
.LA(1);
8483 if ((LA48_0
== CONSTTOK
)) {
8489 // Grammar/CTFParser.g:827:3: typeQualifier
8491 pushFollow(FOLLOW_typeQualifier_in_typeQualifierList2891
);
8492 typeQualifier147
= typeQualifier();
8498 if (state
.backtracking
== 0) {
8499 adaptor
.addChild(root_0
, typeQualifier147
.getTree());
8509 if (state
.backtracking
> 0) {
8510 state
.failed
= true;
8513 EarlyExitException eee
= new EarlyExitException(48,
8522 retval
.stop
= input
.LT(-1);
8524 if (state
.backtracking
== 0) {
8526 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
8527 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
8532 catch (RecognitionException e
) {
8539 // $ANTLR end "typeQualifierList"
8541 public static class typedefName_return
extends ParserRuleReturnScope
{
8545 public Object
getTree() {
8550 // $ANTLR start "typedefName"
8551 // Grammar/CTFParser.g:830:1: typedefName : {...}? IDENTIFIER ;
8552 public final CTFParser
.typedefName_return
typedefName()
8553 throws RecognitionException
{
8554 CTFParser
.typedefName_return retval
= new CTFParser
.typedefName_return();
8555 retval
.start
= input
.LT(1);
8557 CommonTree root_0
= null;
8559 Token IDENTIFIER148
= null;
8561 CommonTree IDENTIFIER148_tree
= null;
8563 enter("typedefName");
8566 // Grammar/CTFParser.g:838:1: ({...}? IDENTIFIER )
8567 // Grammar/CTFParser.g:839:3: {...}? IDENTIFIER
8569 root_0
= (CommonTree
) adaptor
.nil();
8571 if (!((inTypealiasAlias() || isTypeName(input
.LT(1).getText())))) {
8572 if (state
.backtracking
> 0) {
8573 state
.failed
= true;
8576 throw new FailedPredicateException(input
, "typedefName",
8577 "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
8579 IDENTIFIER148
= (Token
) match(input
, IDENTIFIER
,
8580 FOLLOW_IDENTIFIER_in_typedefName2917
);
8584 if (state
.backtracking
== 0) {
8585 IDENTIFIER148_tree
= (CommonTree
) adaptor
8586 .create(IDENTIFIER148
);
8587 adaptor
.addChild(root_0
, IDENTIFIER148_tree
);
8589 if (state
.backtracking
== 0) {
8590 if ((inTypedef() || inTypealiasAlias())
8591 && !isTypeName((IDENTIFIER148
!= null ? IDENTIFIER148
8592 .getText() : null))) {
8593 addTypeName((IDENTIFIER148
!= null ? IDENTIFIER148
8594 .getText() : null));
8600 retval
.stop
= input
.LT(-1);
8602 if (state
.backtracking
== 0) {
8604 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
8605 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
8608 if (state
.backtracking
== 0) {
8610 debug_print("typedefName: "
8611 + input
.toString(retval
.start
, input
.LT(-1)));
8612 exit("typedefName");
8617 catch (RecognitionException e
) {
8624 // $ANTLR end "typedefName"
8626 public static class typealiasTarget_return
extends ParserRuleReturnScope
{
8630 public Object
getTree() {
8635 // $ANTLR start "typealiasTarget"
8636 // Grammar/CTFParser.g:842:1: typealiasTarget : declarationSpecifiers (
8637 // abstractDeclaratorList )? ;
8638 public final CTFParser
.typealiasTarget_return
typealiasTarget()
8639 throws RecognitionException
{
8640 CTFParser
.typealiasTarget_return retval
= new CTFParser
.typealiasTarget_return();
8641 retval
.start
= input
.LT(1);
8643 CommonTree root_0
= null;
8645 CTFParser
.declarationSpecifiers_return declarationSpecifiers149
= null;
8647 CTFParser
.abstractDeclaratorList_return abstractDeclaratorList150
= null;
8649 enter("typealiasTarget");
8652 // Grammar/CTFParser.g:855:1: ( declarationSpecifiers (
8653 // abstractDeclaratorList )? )
8654 // Grammar/CTFParser.g:856:3: declarationSpecifiers (
8655 // abstractDeclaratorList )?
8657 root_0
= (CommonTree
) adaptor
.nil();
8659 pushFollow(FOLLOW_declarationSpecifiers_in_typealiasTarget2945
);
8660 declarationSpecifiers149
= declarationSpecifiers();
8666 if (state
.backtracking
== 0) {
8667 adaptor
.addChild(root_0
, declarationSpecifiers149
.getTree());
8669 // Grammar/CTFParser.g:856:25: ( abstractDeclaratorList )?
8671 int LA49_0
= input
.LA(1);
8673 if (((LA49_0
== LPAREN
) || (LA49_0
== POINTER
) || (LA49_0
== IDENTIFIER
))) {
8678 // Grammar/CTFParser.g:856:25: abstractDeclaratorList
8680 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasTarget2947
);
8681 abstractDeclaratorList150
= abstractDeclaratorList();
8687 if (state
.backtracking
== 0) {
8688 adaptor
.addChild(root_0
,
8689 abstractDeclaratorList150
.getTree());
8699 retval
.stop
= input
.LT(-1);
8701 if (state
.backtracking
== 0) {
8703 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
8704 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
8707 if (state
.backtracking
== 0) {
8709 exit("typealiasTarget");
8714 catch (RecognitionException e
) {
8721 // $ANTLR end "typealiasTarget"
8723 public static class typealiasAlias_return
extends ParserRuleReturnScope
{
8727 public Object
getTree() {
8732 // $ANTLR start "typealiasAlias"
8733 // Grammar/CTFParser.g:859:1: typealiasAlias : ( abstractDeclaratorList | (
8734 // declarationSpecifiers ( abstractDeclaratorList )? ) ) ;
8735 public final CTFParser
.typealiasAlias_return
typealiasAlias()
8736 throws RecognitionException
{
8737 CTFParser
.typealiasAlias_return retval
= new CTFParser
.typealiasAlias_return();
8738 retval
.start
= input
.LT(1);
8740 CommonTree root_0
= null;
8742 CTFParser
.abstractDeclaratorList_return abstractDeclaratorList151
= null;
8744 CTFParser
.declarationSpecifiers_return declarationSpecifiers152
= null;
8746 CTFParser
.abstractDeclaratorList_return abstractDeclaratorList153
= null;
8748 enter("typealiasAlias");
8752 // Grammar/CTFParser.g:874:1: ( ( abstractDeclaratorList | (
8753 // declarationSpecifiers ( abstractDeclaratorList )? ) ) )
8754 // Grammar/CTFParser.g:875:3: ( abstractDeclaratorList | (
8755 // declarationSpecifiers ( abstractDeclaratorList )? ) )
8757 root_0
= (CommonTree
) adaptor
.nil();
8759 // Grammar/CTFParser.g:875:3: ( abstractDeclaratorList | (
8760 // declarationSpecifiers ( abstractDeclaratorList )? ) )
8762 switch (input
.LA(1)) {
8769 int LA51_2
= input
.LA(2);
8771 if ((!(((inTypealiasAlias() || isTypeName(input
.LT(1)
8774 } else if (((inTypealiasAlias() || isTypeName(input
.LT(1)
8778 if (state
.backtracking
> 0) {
8779 state
.failed
= true;
8782 NoViableAltException nvae
= new NoViableAltException(
8793 case FLOATINGPOINTTOK
:
8808 case IMAGINARYTOK
: {
8813 if (state
.backtracking
> 0) {
8814 state
.failed
= true;
8817 NoViableAltException nvae
= new NoViableAltException("",
8825 // Grammar/CTFParser.g:876:3: abstractDeclaratorList
8827 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias2980
);
8828 abstractDeclaratorList151
= abstractDeclaratorList();
8834 if (state
.backtracking
== 0) {
8835 adaptor
.addChild(root_0
,
8836 abstractDeclaratorList151
.getTree());
8842 // Grammar/CTFParser.g:878:3: ( declarationSpecifiers (
8843 // abstractDeclaratorList )? )
8845 // Grammar/CTFParser.g:878:3: ( declarationSpecifiers (
8846 // abstractDeclaratorList )? )
8847 // Grammar/CTFParser.g:878:4: declarationSpecifiers (
8848 // abstractDeclaratorList )?
8850 pushFollow(FOLLOW_declarationSpecifiers_in_typealiasAlias2989
);
8851 declarationSpecifiers152
= declarationSpecifiers();
8857 if (state
.backtracking
== 0) {
8858 adaptor
.addChild(root_0
,
8859 declarationSpecifiers152
.getTree());
8861 // Grammar/CTFParser.g:878:26: ( abstractDeclaratorList
8864 int LA50_0
= input
.LA(1);
8866 if (((LA50_0
== LPAREN
) || (LA50_0
== POINTER
) || (LA50_0
== IDENTIFIER
))) {
8871 // Grammar/CTFParser.g:878:26: abstractDeclaratorList
8873 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias2991
);
8874 abstractDeclaratorList153
= abstractDeclaratorList();
8880 if (state
.backtracking
== 0) {
8881 adaptor
.addChild(root_0
,
8882 abstractDeclaratorList153
.getTree());
8899 retval
.stop
= input
.LT(-1);
8901 if (state
.backtracking
== 0) {
8903 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
8904 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
8907 if (state
.backtracking
== 0) {
8909 exit("typealiasAlias");
8910 typealiasAliasOff();
8915 catch (RecognitionException e
) {
8922 // $ANTLR end "typealiasAlias"
8924 public static class typealiasDecl_return
extends ParserRuleReturnScope
{
8928 public Object
getTree() {
8933 // $ANTLR start "typealiasDecl"
8934 // Grammar/CTFParser.g:882:1: typealiasDecl : TYPEALIASTOK typealiasTarget
8935 // TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^( TYPEALIAS_TARGET
8936 // typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) ) ;
8937 public final CTFParser
.typealiasDecl_return
typealiasDecl()
8938 throws RecognitionException
{
8939 CTFParser
.typealiasDecl_return retval
= new CTFParser
.typealiasDecl_return();
8940 retval
.start
= input
.LT(1);
8942 CommonTree root_0
= null;
8944 Token TYPEALIASTOK154
= null;
8945 Token TYPE_ASSIGNMENT156
= null;
8946 CTFParser
.typealiasTarget_return typealiasTarget155
= null;
8948 CTFParser
.typealiasAlias_return typealiasAlias157
= null;
8950 CommonTree TYPEALIASTOK154_tree
= null;
8951 CommonTree TYPE_ASSIGNMENT156_tree
= null;
8952 RewriteRuleTokenStream stream_TYPE_ASSIGNMENT
= new RewriteRuleTokenStream(
8953 adaptor
, "token TYPE_ASSIGNMENT");
8954 RewriteRuleTokenStream stream_TYPEALIASTOK
= new RewriteRuleTokenStream(
8955 adaptor
, "token TYPEALIASTOK");
8956 RewriteRuleSubtreeStream stream_typealiasAlias
= new RewriteRuleSubtreeStream(
8957 adaptor
, "rule typealiasAlias");
8958 RewriteRuleSubtreeStream stream_typealiasTarget
= new RewriteRuleSubtreeStream(
8959 adaptor
, "rule typealiasTarget");
8961 enter("typealiasDecl");
8964 // Grammar/CTFParser.g:889:1: ( TYPEALIASTOK typealiasTarget
8965 // TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^(
8966 // TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS
8967 // typealiasAlias ) ) )
8968 // Grammar/CTFParser.g:890:3: TYPEALIASTOK typealiasTarget
8969 // TYPE_ASSIGNMENT typealiasAlias
8971 TYPEALIASTOK154
= (Token
) match(input
, TYPEALIASTOK
,
8972 FOLLOW_TYPEALIASTOK_in_typealiasDecl3023
);
8976 if (state
.backtracking
== 0) {
8977 stream_TYPEALIASTOK
.add(TYPEALIASTOK154
);
8980 pushFollow(FOLLOW_typealiasTarget_in_typealiasDecl3025
);
8981 typealiasTarget155
= typealiasTarget();
8987 if (state
.backtracking
== 0) {
8988 stream_typealiasTarget
.add(typealiasTarget155
.getTree());
8990 TYPE_ASSIGNMENT156
= (Token
) match(input
, TYPE_ASSIGNMENT
,
8991 FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3027
);
8995 if (state
.backtracking
== 0) {
8996 stream_TYPE_ASSIGNMENT
.add(TYPE_ASSIGNMENT156
);
8999 pushFollow(FOLLOW_typealiasAlias_in_typealiasDecl3029
);
9000 typealiasAlias157
= typealiasAlias();
9006 if (state
.backtracking
== 0) {
9007 stream_typealiasAlias
.add(typealiasAlias157
.getTree());
9011 // elements: typealiasTarget, typealiasAlias
9013 // rule labels: retval
9014 // token list labels:
9015 // rule list labels:
9017 if (state
.backtracking
== 0) {
9018 retval
.tree
= root_0
;
9019 // RewriteRuleSubtreeStream stream_retval =
9020 new RewriteRuleSubtreeStream(
9021 adaptor
, "rule retval",
9022 retval
!= null ? retval
.tree
: null);
9024 root_0
= (CommonTree
) adaptor
.nil();
9025 // 891:3: -> ^( TYPEALIAS ^( TYPEALIAS_TARGET
9026 // typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
9028 // Grammar/CTFParser.g:891:6: ^( TYPEALIAS ^(
9029 // TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS
9030 // typealiasAlias ) )
9032 CommonTree root_1
= (CommonTree
) adaptor
.nil();
9033 root_1
= (CommonTree
) adaptor
.becomeRoot(
9034 adaptor
.create(TYPEALIAS
, "TYPEALIAS"),
9037 // Grammar/CTFParser.g:891:18: ^( TYPEALIAS_TARGET
9038 // typealiasTarget )
9040 CommonTree root_2
= (CommonTree
) adaptor
.nil();
9041 root_2
= (CommonTree
) adaptor
.becomeRoot(
9042 adaptor
.create(TYPEALIAS_TARGET
,
9043 "TYPEALIAS_TARGET"), root_2
);
9045 adaptor
.addChild(root_2
,
9046 stream_typealiasTarget
.nextTree());
9048 adaptor
.addChild(root_1
, root_2
);
9050 // Grammar/CTFParser.g:891:54: ^( TYPEALIAS_ALIAS
9053 CommonTree root_2
= (CommonTree
) adaptor
.nil();
9054 root_2
= (CommonTree
) adaptor
.becomeRoot(
9055 adaptor
.create(TYPEALIAS_ALIAS
,
9056 "TYPEALIAS_ALIAS"), root_2
);
9058 adaptor
.addChild(root_2
,
9059 stream_typealiasAlias
.nextTree());
9061 adaptor
.addChild(root_1
, root_2
);
9064 adaptor
.addChild(root_0
, root_1
);
9069 retval
.tree
= root_0
;
9073 retval
.stop
= input
.LT(-1);
9075 if (state
.backtracking
== 0) {
9077 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
9078 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
9081 if (state
.backtracking
== 0) {
9083 exit("typealiasDecl");
9088 catch (RecognitionException e
) {
9095 // $ANTLR end "typealiasDecl"
9097 public static class ctfKeyword_return
extends ParserRuleReturnScope
{
9101 public Object
getTree() {
9106 // $ANTLR start "ctfKeyword"
9107 // Grammar/CTFParser.g:897:1: ctfKeyword : ( ALIGNTOK | EVENTTOK | SIGNEDTOK
9109 public final CTFParser
.ctfKeyword_return
ctfKeyword()
9110 throws RecognitionException
{
9111 CTFParser
.ctfKeyword_return retval
= new CTFParser
.ctfKeyword_return();
9112 retval
.start
= input
.LT(1);
9114 CommonTree root_0
= null;
9116 Token set158
= null;
9118 CommonTree set158_tree
= null;
9120 enter("ctfKeyword");
9123 // Grammar/CTFParser.g:905:1: ( ALIGNTOK | EVENTTOK | SIGNEDTOK |
9125 // Grammar/CTFParser.g:
9127 root_0
= (CommonTree
) adaptor
.nil();
9129 set158
= input
.LT(1);
9130 if ((input
.LA(1) == ALIGNTOK
) || (input
.LA(1) == EVENTTOK
)
9131 || (input
.LA(1) == SIGNEDTOK
)
9132 || (input
.LA(1) == STRINGTOK
)) {
9134 if (state
.backtracking
== 0) {
9135 adaptor
.addChild(root_0
, adaptor
.create(set158
));
9137 state
.errorRecovery
= false;
9138 state
.failed
= false;
9140 if (state
.backtracking
> 0) {
9141 state
.failed
= true;
9144 MismatchedSetException mse
= new MismatchedSetException(
9151 retval
.stop
= input
.LT(-1);
9153 if (state
.backtracking
== 0) {
9155 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
9156 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
9159 if (state
.backtracking
== 0) {
9161 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
9167 catch (RecognitionException e
) {
9174 // $ANTLR end "ctfKeyword"
9176 public static class ctfSpecifier_return
extends ParserRuleReturnScope
{
9180 public Object
getTree() {
9185 // $ANTLR start "ctfSpecifier"
9186 // Grammar/CTFParser.g:912:1: ctfSpecifier : ( ctfSpecifierHead ctfBody ->
9187 // ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION
9188 // typealiasDecl ) );
9189 public final CTFParser
.ctfSpecifier_return
ctfSpecifier()
9190 throws RecognitionException
{
9191 CTFParser
.ctfSpecifier_return retval
= new CTFParser
.ctfSpecifier_return();
9192 retval
.start
= input
.LT(1);
9194 CommonTree root_0
= null;
9196 CTFParser
.ctfSpecifierHead_return ctfSpecifierHead159
= null;
9198 CTFParser
.ctfBody_return ctfBody160
= null;
9200 CTFParser
.typealiasDecl_return typealiasDecl161
= null;
9202 RewriteRuleSubtreeStream stream_ctfSpecifierHead
= new RewriteRuleSubtreeStream(
9203 adaptor
, "rule ctfSpecifierHead");
9204 RewriteRuleSubtreeStream stream_typealiasDecl
= new RewriteRuleSubtreeStream(
9205 adaptor
, "rule typealiasDecl");
9206 RewriteRuleSubtreeStream stream_ctfBody
= new RewriteRuleSubtreeStream(
9207 adaptor
, "rule ctfBody");
9209 enter("ctfSpecifier");
9212 // Grammar/CTFParser.g:919:3: ( ctfSpecifierHead ctfBody -> ^(
9213 // ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION
9214 // typealiasDecl ) )
9216 int LA52_0
= input
.LA(1);
9218 if (((LA52_0
== EVENTTOK
) || (LA52_0
== STREAMTOK
)
9219 || (LA52_0
== TRACETOK
) || ((LA52_0
>= ENVTOK
) && (LA52_0
<= CLOCKTOK
)))) {
9221 } else if ((LA52_0
== TYPEALIASTOK
)) {
9224 if (state
.backtracking
> 0) {
9225 state
.failed
= true;
9228 NoViableAltException nvae
= new NoViableAltException("", 52, 0,
9235 // Grammar/CTFParser.g:921:3: ctfSpecifierHead ctfBody
9237 pushFollow(FOLLOW_ctfSpecifierHead_in_ctfSpecifier3123
);
9238 ctfSpecifierHead159
= ctfSpecifierHead();
9244 if (state
.backtracking
== 0) {
9245 stream_ctfSpecifierHead
.add(ctfSpecifierHead159
.getTree());
9247 pushFollow(FOLLOW_ctfBody_in_ctfSpecifier3125
);
9248 ctfBody160
= ctfBody();
9254 if (state
.backtracking
== 0) {
9255 stream_ctfBody
.add(ctfBody160
.getTree());
9259 // elements: ctfBody, ctfSpecifierHead
9261 // rule labels: retval
9262 // token list labels:
9263 // rule list labels:
9265 if (state
.backtracking
== 0) {
9266 retval
.tree
= root_0
;
9267 // RewriteRuleSubtreeStream stream_retval =
9268 new RewriteRuleSubtreeStream(
9269 adaptor
, "rule retval",
9270 retval
!= null ? retval
.tree
: null);
9272 root_0
= (CommonTree
) adaptor
.nil();
9273 // 921:28: -> ^( ctfSpecifierHead ctfBody )
9275 // Grammar/CTFParser.g:921:31: ^( ctfSpecifierHead
9278 CommonTree root_1
= (CommonTree
) adaptor
.nil();
9279 root_1
= (CommonTree
) adaptor
.becomeRoot(
9280 stream_ctfSpecifierHead
.nextNode(), root_1
);
9282 adaptor
.addChild(root_1
, stream_ctfBody
.nextTree());
9284 adaptor
.addChild(root_0
, root_1
);
9289 retval
.tree
= root_0
;
9294 // Grammar/CTFParser.g:924:3: typealiasDecl
9296 pushFollow(FOLLOW_typealiasDecl_in_ctfSpecifier3144
);
9297 typealiasDecl161
= typealiasDecl();
9303 if (state
.backtracking
== 0) {
9304 stream_typealiasDecl
.add(typealiasDecl161
.getTree());
9308 // elements: typealiasDecl
9310 // rule labels: retval
9311 // token list labels:
9312 // rule list labels:
9314 if (state
.backtracking
== 0) {
9315 retval
.tree
= root_0
;
9316 // RewriteRuleSubtreeStream stream_retval =
9317 new RewriteRuleSubtreeStream(
9318 adaptor
, "rule retval",
9319 retval
!= null ? retval
.tree
: null);
9321 root_0
= (CommonTree
) adaptor
.nil();
9322 // 924:17: -> ^( DECLARATION typealiasDecl )
9324 // Grammar/CTFParser.g:924:20: ^( DECLARATION
9327 CommonTree root_1
= (CommonTree
) adaptor
.nil();
9328 root_1
= (CommonTree
) adaptor
.becomeRoot(
9329 adaptor
.create(DECLARATION
, "DECLARATION"),
9332 adaptor
.addChild(root_1
,
9333 stream_typealiasDecl
.nextTree());
9335 adaptor
.addChild(root_0
, root_1
);
9340 retval
.tree
= root_0
;
9346 retval
.stop
= input
.LT(-1);
9348 if (state
.backtracking
== 0) {
9350 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
9351 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
9354 if (state
.backtracking
== 0) {
9356 exit("ctfSpecifier");
9361 catch (RecognitionException e
) {
9368 // $ANTLR end "ctfSpecifier"
9370 public static class ctfSpecifierHead_return
extends ParserRuleReturnScope
{
9374 public Object
getTree() {
9379 // $ANTLR start "ctfSpecifierHead"
9380 // Grammar/CTFParser.g:927:1: ctfSpecifierHead : ( EVENTTOK -> EVENT |
9381 // STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK ->
9383 public final CTFParser
.ctfSpecifierHead_return
ctfSpecifierHead()
9384 throws RecognitionException
{
9385 CTFParser
.ctfSpecifierHead_return retval
= new CTFParser
.ctfSpecifierHead_return();
9386 retval
.start
= input
.LT(1);
9388 CommonTree root_0
= null;
9390 Token EVENTTOK162
= null;
9391 Token STREAMTOK163
= null;
9392 Token TRACETOK164
= null;
9393 Token ENVTOK165
= null;
9394 Token CLOCKTOK166
= null;
9396 CommonTree EVENTTOK162_tree
= null;
9397 CommonTree STREAMTOK163_tree
= null;
9398 CommonTree TRACETOK164_tree
= null;
9399 CommonTree ENVTOK165_tree
= null;
9400 CommonTree CLOCKTOK166_tree
= null;
9401 RewriteRuleTokenStream stream_EVENTTOK
= new RewriteRuleTokenStream(
9402 adaptor
, "token EVENTTOK");
9403 RewriteRuleTokenStream stream_STREAMTOK
= new RewriteRuleTokenStream(
9404 adaptor
, "token STREAMTOK");
9405 RewriteRuleTokenStream stream_ENVTOK
= new RewriteRuleTokenStream(
9406 adaptor
, "token ENVTOK");
9407 RewriteRuleTokenStream stream_CLOCKTOK
= new RewriteRuleTokenStream(
9408 adaptor
, "token CLOCKTOK");
9409 RewriteRuleTokenStream stream_TRACETOK
= new RewriteRuleTokenStream(
9410 adaptor
, "token TRACETOK");
9412 enter("ctfSpecifierHead");
9415 // Grammar/CTFParser.g:935:1: ( EVENTTOK -> EVENT | STREAMTOK ->
9416 // STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK )
9418 switch (input
.LA(1)) {
9440 if (state
.backtracking
> 0) {
9441 state
.failed
= true;
9444 NoViableAltException nvae
= new NoViableAltException("", 53, 0,
9452 // Grammar/CTFParser.g:936:4: EVENTTOK
9454 EVENTTOK162
= (Token
) match(input
, EVENTTOK
,
9455 FOLLOW_EVENTTOK_in_ctfSpecifierHead3176
);
9459 if (state
.backtracking
== 0) {
9460 stream_EVENTTOK
.add(EVENTTOK162
);
9466 // rule labels: retval
9467 // token list labels:
9468 // rule list labels:
9470 if (state
.backtracking
== 0) {
9471 retval
.tree
= root_0
;
9472 RewriteRuleSubtreeStream stream_retval
= new RewriteRuleSubtreeStream(
9473 adaptor
, "rule retval",
9474 retval
!= null ? retval
.tree
: null);
9476 root_0
= (CommonTree
) adaptor
.nil();
9479 adaptor
.addChild(root_0
, adaptor
.create(EVENT
, "EVENT"));
9483 retval
.tree
= root_0
;
9488 // Grammar/CTFParser.g:937:4: STREAMTOK
9490 STREAMTOK163
= (Token
) match(input
, STREAMTOK
,
9491 FOLLOW_STREAMTOK_in_ctfSpecifierHead3185
);
9495 if (state
.backtracking
== 0) {
9496 stream_STREAMTOK
.add(STREAMTOK163
);
9502 // rule labels: retval
9503 // token list labels:
9504 // rule list labels:
9506 if (state
.backtracking
== 0) {
9507 retval
.tree
= root_0
;
9508 RewriteRuleSubtreeStream stream_retval
= new RewriteRuleSubtreeStream(
9509 adaptor
, "rule retval",
9510 retval
!= null ? retval
.tree
: null);
9512 root_0
= (CommonTree
) adaptor
.nil();
9513 // 937:14: -> STREAM
9515 adaptor
.addChild(root_0
,
9516 adaptor
.create(STREAM
, "STREAM"));
9520 retval
.tree
= root_0
;
9525 // Grammar/CTFParser.g:938:4: TRACETOK
9527 TRACETOK164
= (Token
) match(input
, TRACETOK
,
9528 FOLLOW_TRACETOK_in_ctfSpecifierHead3194
);
9532 if (state
.backtracking
== 0) {
9533 stream_TRACETOK
.add(TRACETOK164
);
9539 // rule labels: retval
9540 // token list labels:
9541 // rule list labels:
9543 if (state
.backtracking
== 0) {
9544 retval
.tree
= root_0
;
9545 // RewriteRuleSubtreeStream stream_retval =
9546 new RewriteRuleSubtreeStream(
9547 adaptor
, "rule retval",
9548 retval
!= null ? retval
.tree
: null);
9550 root_0
= (CommonTree
) adaptor
.nil();
9553 adaptor
.addChild(root_0
, adaptor
.create(TRACE
, "TRACE"));
9557 retval
.tree
= root_0
;
9562 // Grammar/CTFParser.g:939:4: ENVTOK
9564 ENVTOK165
= (Token
) match(input
, ENVTOK
,
9565 FOLLOW_ENVTOK_in_ctfSpecifierHead3203
);
9569 if (state
.backtracking
== 0) {
9570 stream_ENVTOK
.add(ENVTOK165
);
9576 // rule labels: retval
9577 // token list labels:
9578 // rule list labels:
9580 if (state
.backtracking
== 0) {
9581 retval
.tree
= root_0
;
9582 // RewriteRuleSubtreeStream stream_retval =
9583 new RewriteRuleSubtreeStream(
9584 adaptor
, "rule retval",
9585 retval
!= null ? retval
.tree
: null);
9587 root_0
= (CommonTree
) adaptor
.nil();
9590 adaptor
.addChild(root_0
, adaptor
.create(ENV
, "ENV"));
9594 retval
.tree
= root_0
;
9599 // Grammar/CTFParser.g:940:4: CLOCKTOK
9601 CLOCKTOK166
= (Token
) match(input
, CLOCKTOK
,
9602 FOLLOW_CLOCKTOK_in_ctfSpecifierHead3212
);
9606 if (state
.backtracking
== 0) {
9607 stream_CLOCKTOK
.add(CLOCKTOK166
);
9613 // rule labels: retval
9614 // token list labels:
9615 // rule list labels:
9617 if (state
.backtracking
== 0) {
9618 retval
.tree
= root_0
;
9619 // RewriteRuleSubtreeStream stream_retval =
9620 new RewriteRuleSubtreeStream(
9621 adaptor
, "rule retval",
9622 retval
!= null ? retval
.tree
: null);
9624 root_0
= (CommonTree
) adaptor
.nil();
9627 adaptor
.addChild(root_0
, adaptor
.create(CLOCK
, "CLOCK"));
9631 retval
.tree
= root_0
;
9637 retval
.stop
= input
.LT(-1);
9639 if (state
.backtracking
== 0) {
9641 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
9642 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
9645 if (state
.backtracking
== 0) {
9647 debug_print(input
.toString(retval
.start
, input
.LT(-1)));
9648 exit("ctfSpecifierHead");
9653 catch (RecognitionException e
) {
9660 // $ANTLR end "ctfSpecifierHead"
9662 public static class ctfTypeSpecifier_return
extends ParserRuleReturnScope
{
9666 public Object
getTree() {
9671 // $ANTLR start "ctfTypeSpecifier"
9672 // Grammar/CTFParser.g:943:1: ctfTypeSpecifier : ( FLOATINGPOINTTOK ctfBody
9673 // -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER (
9674 // ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) );
9675 public final CTFParser
.ctfTypeSpecifier_return
ctfTypeSpecifier()
9676 throws RecognitionException
{
9677 CTFParser
.ctfTypeSpecifier_return retval
= new CTFParser
.ctfTypeSpecifier_return();
9678 retval
.start
= input
.LT(1);
9680 CommonTree root_0
= null;
9682 Token FLOATINGPOINTTOK167
= null;
9683 Token INTEGERTOK169
= null;
9684 Token STRINGTOK171
= null;
9685 CTFParser
.ctfBody_return ctfBody168
= null;
9687 CTFParser
.ctfBody_return ctfBody170
= null;
9689 CTFParser
.ctfBody_return ctfBody172
= null;
9691 CommonTree FLOATINGPOINTTOK167_tree
= null;
9692 CommonTree INTEGERTOK169_tree
= null;
9693 CommonTree STRINGTOK171_tree
= null;
9694 RewriteRuleTokenStream stream_FLOATINGPOINTTOK
= new RewriteRuleTokenStream(
9695 adaptor
, "token FLOATINGPOINTTOK");
9696 RewriteRuleTokenStream stream_STRINGTOK
= new RewriteRuleTokenStream(
9697 adaptor
, "token STRINGTOK");
9698 RewriteRuleTokenStream stream_INTEGERTOK
= new RewriteRuleTokenStream(
9699 adaptor
, "token INTEGERTOK");
9700 RewriteRuleSubtreeStream stream_ctfBody
= new RewriteRuleSubtreeStream(
9701 adaptor
, "rule ctfBody");
9703 enter("ctfTypeSpecifier");
9706 // Grammar/CTFParser.g:950:1: ( FLOATINGPOINTTOK ctfBody -> ^(
9707 // FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER
9708 // ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )?
9711 switch (input
.LA(1)) {
9712 case FLOATINGPOINTTOK
: {
9725 if (state
.backtracking
> 0) {
9726 state
.failed
= true;
9729 NoViableAltException nvae
= new NoViableAltException("", 55, 0,
9737 // Grammar/CTFParser.g:952:5: FLOATINGPOINTTOK ctfBody
9739 FLOATINGPOINTTOK167
= (Token
) match(input
, FLOATINGPOINTTOK
,
9740 FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3246
);
9744 if (state
.backtracking
== 0) {
9745 stream_FLOATINGPOINTTOK
.add(FLOATINGPOINTTOK167
);
9748 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3248
);
9749 ctfBody168
= ctfBody();
9755 if (state
.backtracking
== 0) {
9756 stream_ctfBody
.add(ctfBody168
.getTree());
9760 // elements: ctfBody
9762 // rule labels: retval
9763 // token list labels:
9764 // rule list labels:
9766 if (state
.backtracking
== 0) {
9767 retval
.tree
= root_0
;
9768 // RewriteRuleSubtreeStream stream_retval =
9769 new RewriteRuleSubtreeStream(
9770 adaptor
, "rule retval",
9771 retval
!= null ? retval
.tree
: null);
9773 root_0
= (CommonTree
) adaptor
.nil();
9774 // 952:30: -> ^( FLOATING_POINT ( ctfBody )? )
9776 // Grammar/CTFParser.g:952:33: ^( FLOATING_POINT (
9779 CommonTree root_1
= (CommonTree
) adaptor
.nil();
9780 root_1
= (CommonTree
) adaptor
.becomeRoot(adaptor
9781 .create(FLOATING_POINT
, "FLOATING_POINT"),
9784 // Grammar/CTFParser.g:952:50: ( ctfBody )?
9785 if (stream_ctfBody
.hasNext()) {
9786 adaptor
.addChild(root_1
,
9787 stream_ctfBody
.nextTree());
9790 stream_ctfBody
.reset();
9792 adaptor
.addChild(root_0
, root_1
);
9797 retval
.tree
= root_0
;
9802 // Grammar/CTFParser.g:953:5: INTEGERTOK ctfBody
9804 INTEGERTOK169
= (Token
) match(input
, INTEGERTOK
,
9805 FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3263
);
9809 if (state
.backtracking
== 0) {
9810 stream_INTEGERTOK
.add(INTEGERTOK169
);
9813 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3265
);
9814 ctfBody170
= ctfBody();
9820 if (state
.backtracking
== 0) {
9821 stream_ctfBody
.add(ctfBody170
.getTree());
9825 // elements: ctfBody
9827 // rule labels: retval
9828 // token list labels:
9829 // rule list labels:
9831 if (state
.backtracking
== 0) {
9832 retval
.tree
= root_0
;
9833 // RewriteRuleSubtreeStream stream_retval =
9834 new RewriteRuleSubtreeStream(
9835 adaptor
, "rule retval",
9836 retval
!= null ? retval
.tree
: null);
9838 root_0
= (CommonTree
) adaptor
.nil();
9839 // 953:24: -> ^( INTEGER ( ctfBody )? )
9841 // Grammar/CTFParser.g:953:27: ^( INTEGER ( ctfBody )? )
9843 CommonTree root_1
= (CommonTree
) adaptor
.nil();
9844 root_1
= (CommonTree
) adaptor
.becomeRoot(
9845 adaptor
.create(INTEGER
, "INTEGER"), root_1
);
9847 // Grammar/CTFParser.g:953:37: ( ctfBody )?
9848 if (stream_ctfBody
.hasNext()) {
9849 adaptor
.addChild(root_1
,
9850 stream_ctfBody
.nextTree());
9853 stream_ctfBody
.reset();
9855 adaptor
.addChild(root_0
, root_1
);
9860 retval
.tree
= root_0
;
9865 // Grammar/CTFParser.g:954:5: STRINGTOK ( ctfBody )?
9867 STRINGTOK171
= (Token
) match(input
, STRINGTOK
,
9868 FOLLOW_STRINGTOK_in_ctfTypeSpecifier3280
);
9872 if (state
.backtracking
== 0) {
9873 stream_STRINGTOK
.add(STRINGTOK171
);
9876 // Grammar/CTFParser.g:954:15: ( ctfBody )?
9878 alt54
= dfa54
.predict(input
);
9881 // Grammar/CTFParser.g:954:15: ctfBody
9883 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3282
);
9884 ctfBody172
= ctfBody();
9890 if (state
.backtracking
== 0) {
9891 stream_ctfBody
.add(ctfBody172
.getTree());
9900 // elements: ctfBody
9902 // rule labels: retval
9903 // token list labels:
9904 // rule list labels:
9906 if (state
.backtracking
== 0) {
9907 retval
.tree
= root_0
;
9908 // RewriteRuleSubtreeStream stream_retval =
9909 new RewriteRuleSubtreeStream(
9910 adaptor
, "rule retval",
9911 retval
!= null ? retval
.tree
: null);
9913 root_0
= (CommonTree
) adaptor
.nil();
9914 // 954:24: -> ^( STRING ( ctfBody )? )
9916 // Grammar/CTFParser.g:954:27: ^( STRING ( ctfBody )? )
9918 CommonTree root_1
= (CommonTree
) adaptor
.nil();
9919 root_1
= (CommonTree
) adaptor
.becomeRoot(
9920 adaptor
.create(STRING
, "STRING"), root_1
);
9922 // Grammar/CTFParser.g:954:36: ( ctfBody )?
9923 if (stream_ctfBody
.hasNext()) {
9924 adaptor
.addChild(root_1
,
9925 stream_ctfBody
.nextTree());
9928 stream_ctfBody
.reset();
9930 adaptor
.addChild(root_0
, root_1
);
9935 retval
.tree
= root_0
;
9941 retval
.stop
= input
.LT(-1);
9943 if (state
.backtracking
== 0) {
9945 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
9946 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
9949 if (state
.backtracking
== 0) {
9951 exit("ctfTypeSpecifier");
9956 catch (RecognitionException e
) {
9963 // $ANTLR end "ctfTypeSpecifier"
9965 public static class ctfBody_return
extends ParserRuleReturnScope
{
9969 public Object
getTree() {
9974 // $ANTLR start "ctfBody"
9975 // Grammar/CTFParser.g:957:1: ctfBody : LCURL ( ctfAssignmentExpressionList
9976 // )? RCURL -> ( ctfAssignmentExpressionList )? ;
9977 public final CTFParser
.ctfBody_return
ctfBody() throws RecognitionException
{
9978 Symbols_stack
.push(new Symbols_scope());
9980 CTFParser
.ctfBody_return retval
= new CTFParser
.ctfBody_return();
9981 retval
.start
= input
.LT(1);
9983 CommonTree root_0
= null;
9985 Token LCURL173
= null;
9986 Token RCURL175
= null;
9987 CTFParser
.ctfAssignmentExpressionList_return ctfAssignmentExpressionList174
= null;
9989 CommonTree LCURL173_tree
= null;
9990 CommonTree RCURL175_tree
= null;
9991 RewriteRuleTokenStream stream_LCURL
= new RewriteRuleTokenStream(
9992 adaptor
, "token LCURL");
9993 RewriteRuleTokenStream stream_RCURL
= new RewriteRuleTokenStream(
9994 adaptor
, "token RCURL");
9995 RewriteRuleSubtreeStream stream_ctfAssignmentExpressionList
= new RewriteRuleSubtreeStream(
9996 adaptor
, "rule ctfAssignmentExpressionList");
9999 debug_print("Scope push " + +Symbols_stack
.size());
10000 ((Symbols_scope
) Symbols_stack
.peek()).types
= new HashSet
<String
>();
10003 // Grammar/CTFParser.g:968:1: ( LCURL ( ctfAssignmentExpressionList
10004 // )? RCURL -> ( ctfAssignmentExpressionList )? )
10005 // Grammar/CTFParser.g:969:3: LCURL ( ctfAssignmentExpressionList )?
10008 LCURL173
= (Token
) match(input
, LCURL
,
10009 FOLLOW_LCURL_in_ctfBody3320
);
10010 if (state
.failed
) {
10013 if (state
.backtracking
== 0) {
10014 stream_LCURL
.add(LCURL173
);
10017 // Grammar/CTFParser.g:969:9: ( ctfAssignmentExpressionList )?
10019 int LA56_0
= input
.LA(1);
10021 if ((((LA56_0
>= ALIGNTOK
) && (LA56_0
<= CLOCKTOK
))
10022 || (LA56_0
== SIGN
) || (LA56_0
== OCTAL_LITERAL
)
10023 || (LA56_0
== DECIMAL_LITERAL
)
10024 || (LA56_0
== HEX_LITERAL
)
10025 || (LA56_0
== CHARACTER_LITERAL
)
10026 || (LA56_0
== STRING_LITERAL
) || (LA56_0
== IDENTIFIER
))) {
10031 // Grammar/CTFParser.g:969:9: ctfAssignmentExpressionList
10033 pushFollow(FOLLOW_ctfAssignmentExpressionList_in_ctfBody3322
);
10034 ctfAssignmentExpressionList174
= ctfAssignmentExpressionList();
10037 if (state
.failed
) {
10040 if (state
.backtracking
== 0) {
10041 stream_ctfAssignmentExpressionList
10042 .add(ctfAssignmentExpressionList174
.getTree());
10050 RCURL175
= (Token
) match(input
, RCURL
,
10051 FOLLOW_RCURL_in_ctfBody3325
);
10052 if (state
.failed
) {
10055 if (state
.backtracking
== 0) {
10056 stream_RCURL
.add(RCURL175
);
10060 // elements: ctfAssignmentExpressionList
10062 // rule labels: retval
10063 // token list labels:
10064 // rule list labels:
10065 // wildcard labels:
10066 if (state
.backtracking
== 0) {
10067 retval
.tree
= root_0
;
10068 // RewriteRuleSubtreeStream stream_retval =
10069 new RewriteRuleSubtreeStream(
10070 adaptor
, "rule retval",
10071 retval
!= null ? retval
.tree
: null);
10073 root_0
= (CommonTree
) adaptor
.nil();
10074 // 969:44: -> ( ctfAssignmentExpressionList )?
10076 // Grammar/CTFParser.g:969:47: (
10077 // ctfAssignmentExpressionList )?
10078 if (stream_ctfAssignmentExpressionList
.hasNext()) {
10079 adaptor
.addChild(root_0
,
10080 stream_ctfAssignmentExpressionList
10084 stream_ctfAssignmentExpressionList
.reset();
10088 retval
.tree
= root_0
;
10092 retval
.stop
= input
.LT(-1);
10094 if (state
.backtracking
== 0) {
10096 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
10097 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
10100 if (state
.backtracking
== 0) {
10102 debug_print("Scope pop " + +Symbols_stack
.size());
10108 catch (RecognitionException e
) {
10111 Symbols_stack
.pop();
10117 // $ANTLR end "ctfBody"
10119 public static class ctfAssignmentExpressionList_return
extends
10120 ParserRuleReturnScope
{
10124 public Object
getTree() {
10129 // $ANTLR start "ctfAssignmentExpressionList"
10130 // Grammar/CTFParser.g:972:1: ctfAssignmentExpressionList : (
10131 // ctfAssignmentExpression TERM )+ ;
10132 public final CTFParser
.ctfAssignmentExpressionList_return
ctfAssignmentExpressionList()
10133 throws RecognitionException
{
10134 CTFParser
.ctfAssignmentExpressionList_return retval
= new CTFParser
.ctfAssignmentExpressionList_return();
10135 retval
.start
= input
.LT(1);
10137 CommonTree root_0
= null;
10139 Token TERM177
= null;
10140 CTFParser
.ctfAssignmentExpression_return ctfAssignmentExpression176
= null;
10142 CommonTree TERM177_tree
= null;
10145 // Grammar/CTFParser.g:972:29: ( ( ctfAssignmentExpression TERM )+ )
10146 // Grammar/CTFParser.g:973:3: ( ctfAssignmentExpression TERM )+
10148 root_0
= (CommonTree
) adaptor
.nil();
10150 // Grammar/CTFParser.g:973:3: ( ctfAssignmentExpression TERM )+
10154 int LA57_0
= input
.LA(1);
10156 if ((((LA57_0
>= ALIGNTOK
) && (LA57_0
<= CLOCKTOK
))
10157 || (LA57_0
== SIGN
) || (LA57_0
== OCTAL_LITERAL
)
10158 || (LA57_0
== DECIMAL_LITERAL
)
10159 || (LA57_0
== HEX_LITERAL
)
10160 || (LA57_0
== CHARACTER_LITERAL
)
10161 || (LA57_0
== STRING_LITERAL
) || (LA57_0
== IDENTIFIER
))) {
10167 // Grammar/CTFParser.g:973:4: ctfAssignmentExpression TERM
10169 pushFollow(FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3344
);
10170 ctfAssignmentExpression176
= ctfAssignmentExpression();
10173 if (state
.failed
) {
10176 if (state
.backtracking
== 0) {
10177 adaptor
.addChild(root_0
,
10178 ctfAssignmentExpression176
.getTree());
10180 TERM177
= (Token
) match(input
, TERM
,
10181 FOLLOW_TERM_in_ctfAssignmentExpressionList3346
);
10182 if (state
.failed
) {
10193 if (state
.backtracking
> 0) {
10194 state
.failed
= true;
10197 EarlyExitException eee
= new EarlyExitException(57,
10206 retval
.stop
= input
.LT(-1);
10208 if (state
.backtracking
== 0) {
10210 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
10211 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
10216 catch (RecognitionException e
) {
10223 // $ANTLR end "ctfAssignmentExpressionList"
10225 public static class ctfAssignmentExpression_return
extends
10226 ParserRuleReturnScope
{
10230 public Object
getTree() {
10235 // $ANTLR start "ctfAssignmentExpression"
10236 // Grammar/CTFParser.g:977:1: ctfAssignmentExpression : ( (left=
10237 // unaryExpression ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
10238 // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
10239 // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^(
10240 // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
10241 // TYPE_SPECIFIER_LIST $right2) ) ) ) ) | ( declarationSpecifiers {...}?
10242 // declaratorList ) -> ^( TYPEDEF declaratorList declarationSpecifiers ) |
10243 // typealiasDecl );
10244 public final CTFParser
.ctfAssignmentExpression_return
ctfAssignmentExpression()
10245 throws RecognitionException
{
10246 CTFParser
.ctfAssignmentExpression_return retval
= new CTFParser
.ctfAssignmentExpression_return();
10247 retval
.start
= input
.LT(1);
10249 CommonTree root_0
= null;
10251 Token assignment
= null;
10252 Token type_assignment
= null;
10253 CTFParser
.unaryExpression_return left
= null;
10255 CTFParser
.unaryExpression_return right1
= null;
10257 CTFParser
.typeSpecifier_return right2
= null;
10259 CTFParser
.declarationSpecifiers_return declarationSpecifiers178
= null;
10261 CTFParser
.declaratorList_return declaratorList179
= null;
10263 CTFParser
.typealiasDecl_return typealiasDecl180
= null;
10265 CommonTree assignment_tree
= null;
10266 CommonTree type_assignment_tree
= null;
10267 RewriteRuleTokenStream stream_ASSIGNMENT
= new RewriteRuleTokenStream(
10268 adaptor
, "token ASSIGNMENT");
10269 RewriteRuleTokenStream stream_TYPE_ASSIGNMENT
= new RewriteRuleTokenStream(
10270 adaptor
, "token TYPE_ASSIGNMENT");
10271 RewriteRuleSubtreeStream stream_declaratorList
= new RewriteRuleSubtreeStream(
10272 adaptor
, "rule declaratorList");
10273 RewriteRuleSubtreeStream stream_unaryExpression
= new RewriteRuleSubtreeStream(
10274 adaptor
, "rule unaryExpression");
10275 RewriteRuleSubtreeStream stream_declarationSpecifiers
= new RewriteRuleSubtreeStream(
10276 adaptor
, "rule declarationSpecifiers");
10277 RewriteRuleSubtreeStream stream_typeSpecifier
= new RewriteRuleSubtreeStream(
10278 adaptor
, "rule typeSpecifier");
10280 enter("ctfAssignmentExpression");
10283 // Grammar/CTFParser.g:987:1: ( (left= unaryExpression (
10284 // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
10285 // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
10286 // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^(
10287 // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
10288 // TYPE_SPECIFIER_LIST $right2) ) ) ) ) | ( declarationSpecifiers
10289 // {...}? declaratorList ) -> ^( TYPEDEF declaratorList
10290 // declarationSpecifiers ) | typealiasDecl )
10292 switch (input
.LA(1)) {
10294 int LA59_1
= input
.LA(2);
10296 if ((((LA59_1
>= CONSTTOK
) && (LA59_1
<= ENUMTOK
))
10297 || ((LA59_1
>= FLOATINGPOINTTOK
) && (LA59_1
<= SIGNEDTOK
))
10298 || ((LA59_1
>= STRINGTOK
) && (LA59_1
<= STRUCTTOK
))
10299 || ((LA59_1
>= TYPEDEFTOK
) && (LA59_1
<= IMAGINARYTOK
))
10300 || (LA59_1
== POINTER
) || (LA59_1
== IDENTIFIER
))
10301 && ((inTypealiasAlias() || isTypeName(input
.LT(1)
10304 } else if ((((LA59_1
>= ASSIGNMENT
) && (LA59_1
<= TYPE_ASSIGNMENT
))
10305 || (LA59_1
== OPENBRAC
) || ((LA59_1
>= ARROW
) && (LA59_1
<= DOT
)))) {
10308 if (state
.backtracking
> 0) {
10309 state
.failed
= true;
10312 NoViableAltException nvae
= new NoViableAltException("",
10326 case OCTAL_LITERAL
:
10327 case DECIMAL_LITERAL
:
10329 case CHARACTER_LITERAL
:
10330 case STRING_LITERAL
: {
10335 switch (input
.LA(2)) {
10337 case TYPE_ASSIGNMENT
:
10348 case FLOATINGPOINTTOK
:
10373 if (state
.backtracking
> 0) {
10374 state
.failed
= true;
10377 NoViableAltException nvae
= new NoViableAltException("",
10389 case FLOATINGPOINTTOK
:
10402 case IMAGINARYTOK
: {
10407 switch (input
.LA(2)) {
10409 case TYPE_ASSIGNMENT
:
10420 case FLOATINGPOINTTOK
:
10446 if (state
.backtracking
> 0) {
10447 state
.failed
= true;
10450 NoViableAltException nvae
= new NoViableAltException("",
10458 case TYPEALIASTOK
: {
10463 if (state
.backtracking
> 0) {
10464 state
.failed
= true;
10467 NoViableAltException nvae
= new NoViableAltException("", 59, 0,
10475 // Grammar/CTFParser.g:988:3: (left= unaryExpression ( (assignment=
10476 // ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^(
10477 // CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment=
10478 // TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE
10479 // ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) )
10482 // Grammar/CTFParser.g:988:3: (left= unaryExpression (
10483 // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
10484 // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
10485 // | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
10486 // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
10487 // TYPE_SPECIFIER_LIST $right2) ) ) ) )
10488 // Grammar/CTFParser.g:989:5: left= unaryExpression (
10489 // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
10490 // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
10491 // | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
10492 // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
10493 // TYPE_SPECIFIER_LIST $right2) ) ) )
10495 pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3381
);
10496 left
= unaryExpression();
10499 if (state
.failed
) {
10502 if (state
.backtracking
== 0) {
10503 stream_unaryExpression
.add(left
.getTree());
10505 // Grammar/CTFParser.g:990:5: ( (assignment= ASSIGNMENT
10506 // right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^(
10507 // CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
10508 // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
10509 // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT
10510 // ^( TYPE_SPECIFIER_LIST $right2) ) ) )
10512 int LA58_0
= input
.LA(1);
10514 if ((LA58_0
== ASSIGNMENT
)) {
10516 } else if ((LA58_0
== TYPE_ASSIGNMENT
)) {
10519 if (state
.backtracking
> 0) {
10520 state
.failed
= true;
10523 NoViableAltException nvae
= new NoViableAltException(
10530 // Grammar/CTFParser.g:991:9: (assignment= ASSIGNMENT
10531 // right1= unaryExpression )
10533 // Grammar/CTFParser.g:991:9: (assignment= ASSIGNMENT
10534 // right1= unaryExpression )
10535 // Grammar/CTFParser.g:991:10: assignment= ASSIGNMENT
10536 // right1= unaryExpression
10538 assignment
= (Token
) match(input
, ASSIGNMENT
,
10539 FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3400
);
10540 if (state
.failed
) {
10543 if (state
.backtracking
== 0) {
10544 stream_ASSIGNMENT
.add(assignment
);
10547 pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3404
);
10548 right1
= unaryExpression();
10551 if (state
.failed
) {
10554 if (state
.backtracking
== 0) {
10555 stream_unaryExpression
.add(right1
.getTree());
10561 // elements: right1, left
10563 // rule labels: retval, left, right1
10564 // token list labels:
10565 // rule list labels:
10566 // wildcard labels:
10567 if (state
.backtracking
== 0) {
10568 retval
.tree
= root_0
;
10569 RewriteRuleSubtreeStream stream_retval
= new RewriteRuleSubtreeStream(
10570 adaptor
, "rule retval",
10571 retval
!= null ? retval
.tree
: null);
10572 RewriteRuleSubtreeStream stream_left
= new RewriteRuleSubtreeStream(
10573 adaptor
, "rule left",
10574 left
!= null ? left
.tree
: null);
10575 RewriteRuleSubtreeStream stream_right1
= new RewriteRuleSubtreeStream(
10576 adaptor
, "rule right1",
10577 right1
!= null ? right1
.tree
: null);
10579 root_0
= (CommonTree
) adaptor
.nil();
10580 // 991:56: -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT
10581 // $left) ^( CTF_RIGHT $right1) )
10583 // Grammar/CTFParser.g:991:59: ^(
10584 // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^(
10585 // CTF_RIGHT $right1) )
10587 CommonTree root_1
= (CommonTree
) adaptor
10589 root_1
= (CommonTree
) adaptor
.becomeRoot(
10590 adaptor
.create(CTF_EXPRESSION_VAL
,
10591 "CTF_EXPRESSION_VAL"),
10594 // Grammar/CTFParser.g:991:80: ^( CTF_LEFT
10597 CommonTree root_2
= (CommonTree
) adaptor
10599 root_2
= (CommonTree
) adaptor
10600 .becomeRoot(adaptor
.create(
10601 CTF_LEFT
, "CTF_LEFT"),
10604 adaptor
.addChild(root_2
,
10605 stream_left
.nextTree());
10607 adaptor
.addChild(root_1
, root_2
);
10609 // Grammar/CTFParser.g:991:98: ^( CTF_RIGHT
10612 CommonTree root_2
= (CommonTree
) adaptor
10614 root_2
= (CommonTree
) adaptor
10621 adaptor
.addChild(root_2
,
10622 stream_right1
.nextTree());
10624 adaptor
.addChild(root_1
, root_2
);
10627 adaptor
.addChild(root_0
, root_1
);
10632 retval
.tree
= root_0
;
10637 // Grammar/CTFParser.g:992:9: (type_assignment=
10638 // TYPE_ASSIGNMENT right2= typeSpecifier )
10640 // Grammar/CTFParser.g:992:9: (type_assignment=
10641 // TYPE_ASSIGNMENT right2= typeSpecifier )
10642 // Grammar/CTFParser.g:992:10: type_assignment=
10643 // TYPE_ASSIGNMENT right2= typeSpecifier
10645 type_assignment
= (Token
) match(input
,
10647 FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3438
);
10648 if (state
.failed
) {
10651 if (state
.backtracking
== 0) {
10652 stream_TYPE_ASSIGNMENT
.add(type_assignment
);
10655 pushFollow(FOLLOW_typeSpecifier_in_ctfAssignmentExpression3443
);
10656 right2
= typeSpecifier();
10659 if (state
.failed
) {
10662 if (state
.backtracking
== 0) {
10663 stream_typeSpecifier
.add(right2
.getTree());
10669 // elements: left, right2
10671 // rule labels: retval, left, right2
10672 // token list labels:
10673 // rule list labels:
10674 // wildcard labels:
10675 if (state
.backtracking
== 0) {
10676 retval
.tree
= root_0
;
10677 RewriteRuleSubtreeStream stream_retval
= new RewriteRuleSubtreeStream(
10678 adaptor
, "rule retval",
10679 retval
!= null ? retval
.tree
: null);
10680 RewriteRuleSubtreeStream stream_left
= new RewriteRuleSubtreeStream(
10681 adaptor
, "rule left",
10682 left
!= null ? left
.tree
: null);
10683 RewriteRuleSubtreeStream stream_right2
= new RewriteRuleSubtreeStream(
10684 adaptor
, "rule right2",
10685 right2
!= null ? right2
.tree
: null);
10687 root_0
= (CommonTree
) adaptor
.nil();
10688 // 992:65: -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT
10689 // $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST
10692 // Grammar/CTFParser.g:992:68: ^(
10693 // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^(
10694 // CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
10696 CommonTree root_1
= (CommonTree
) adaptor
10698 root_1
= (CommonTree
) adaptor
.becomeRoot(
10699 adaptor
.create(CTF_EXPRESSION_TYPE
,
10700 "CTF_EXPRESSION_TYPE"),
10703 // Grammar/CTFParser.g:992:90: ^( CTF_LEFT
10706 CommonTree root_2
= (CommonTree
) adaptor
10708 root_2
= (CommonTree
) adaptor
10709 .becomeRoot(adaptor
.create(
10710 CTF_LEFT
, "CTF_LEFT"),
10713 adaptor
.addChild(root_2
,
10714 stream_left
.nextTree());
10716 adaptor
.addChild(root_1
, root_2
);
10718 // Grammar/CTFParser.g:992:108: ^( CTF_RIGHT
10719 // ^( TYPE_SPECIFIER_LIST $right2) )
10721 CommonTree root_2
= (CommonTree
) adaptor
10723 root_2
= (CommonTree
) adaptor
10730 // Grammar/CTFParser.g:992:120: ^(
10731 // TYPE_SPECIFIER_LIST $right2)
10733 CommonTree root_3
= (CommonTree
) adaptor
10735 root_3
= (CommonTree
) adaptor
10738 TYPE_SPECIFIER_LIST
,
10739 "TYPE_SPECIFIER_LIST"),
10742 adaptor
.addChild(root_3
,
10743 stream_right2
.nextTree());
10745 adaptor
.addChild(root_2
, root_3
);
10748 adaptor
.addChild(root_1
, root_2
);
10751 adaptor
.addChild(root_0
, root_1
);
10756 retval
.tree
= root_0
;
10768 // Grammar/CTFParser.g:998:5: ( declarationSpecifiers {...}?
10769 // declaratorList )
10771 // Grammar/CTFParser.g:998:5: ( declarationSpecifiers {...}?
10772 // declaratorList )
10773 // Grammar/CTFParser.g:998:6: declarationSpecifiers {...}?
10776 pushFollow(FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3493
);
10777 declarationSpecifiers178
= declarationSpecifiers();
10780 if (state
.failed
) {
10783 if (state
.backtracking
== 0) {
10784 stream_declarationSpecifiers
10785 .add(declarationSpecifiers178
.getTree());
10787 if (!((inTypedef()))) {
10788 if (state
.backtracking
> 0) {
10789 state
.failed
= true;
10792 throw new FailedPredicateException(input
,
10793 "ctfAssignmentExpression", "inTypedef()");
10795 pushFollow(FOLLOW_declaratorList_in_ctfAssignmentExpression3497
);
10796 declaratorList179
= declaratorList();
10799 if (state
.failed
) {
10802 if (state
.backtracking
== 0) {
10803 stream_declaratorList
.add(declaratorList179
.getTree());
10809 // elements: declaratorList, declarationSpecifiers
10811 // rule labels: retval
10812 // token list labels:
10813 // rule list labels:
10814 // wildcard labels:
10815 if (state
.backtracking
== 0) {
10816 retval
.tree
= root_0
;
10817 RewriteRuleSubtreeStream stream_retval
= new RewriteRuleSubtreeStream(
10818 adaptor
, "rule retval",
10819 retval
!= null ? retval
.tree
: null);
10821 root_0
= (CommonTree
) adaptor
.nil();
10822 // 999:5: -> ^( TYPEDEF declaratorList declarationSpecifiers
10825 // Grammar/CTFParser.g:999:8: ^( TYPEDEF declaratorList
10826 // declarationSpecifiers )
10828 CommonTree root_1
= (CommonTree
) adaptor
.nil();
10829 root_1
= (CommonTree
) adaptor
.becomeRoot(
10830 adaptor
.create(TYPEDEF
, "TYPEDEF"), root_1
);
10832 adaptor
.addChild(root_1
,
10833 stream_declaratorList
.nextTree());
10834 adaptor
.addChild(root_1
,
10835 stream_declarationSpecifiers
.nextTree());
10837 adaptor
.addChild(root_0
, root_1
);
10842 retval
.tree
= root_0
;
10847 // Grammar/CTFParser.g:1002:5: typealiasDecl
10849 root_0
= (CommonTree
) adaptor
.nil();
10851 pushFollow(FOLLOW_typealiasDecl_in_ctfAssignmentExpression3525
);
10852 typealiasDecl180
= typealiasDecl();
10855 if (state
.failed
) {
10858 if (state
.backtracking
== 0) {
10859 adaptor
.addChild(root_0
, typealiasDecl180
.getTree());
10866 retval
.stop
= input
.LT(-1);
10868 if (state
.backtracking
== 0) {
10870 retval
.tree
= (CommonTree
) adaptor
.rulePostProcessing(root_0
);
10871 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
,
10874 if (state
.backtracking
== 0) {
10879 exit("ctfAssignmentExpression");
10884 catch (RecognitionException e
) {
10891 // $ANTLR end "ctfAssignmentExpression"
10893 // $ANTLR start synpred1_CTFParser
10894 public final void synpred1_CTFParser_fragment() throws RecognitionException
{
10895 // Grammar/CTFParser.g:250:5: ( IDENTIFIER )
10896 // Grammar/CTFParser.g:250:6: IDENTIFIER
10898 match(input
, IDENTIFIER
, FOLLOW_IDENTIFIER_in_synpred1_CTFParser470
);
10899 if (state
.failed
) {
10906 // $ANTLR end synpred1_CTFParser
10908 // $ANTLR start synpred2_CTFParser
10909 public final void synpred2_CTFParser_fragment() throws RecognitionException
{
10910 // Grammar/CTFParser.g:251:5: ( ctfKeyword )
10911 // Grammar/CTFParser.g:251:6: ctfKeyword
10913 pushFollow(FOLLOW_ctfKeyword_in_synpred2_CTFParser492
);
10917 if (state
.failed
) {
10924 // $ANTLR end synpred2_CTFParser
10926 // $ANTLR start synpred3_CTFParser
10927 public final void synpred3_CTFParser_fragment() throws RecognitionException
{
10928 // Grammar/CTFParser.g:252:5: ( STRING_LITERAL )
10929 // Grammar/CTFParser.g:252:6: STRING_LITERAL
10931 match(input
, STRING_LITERAL
,
10932 FOLLOW_STRING_LITERAL_in_synpred3_CTFParser512
);
10933 if (state
.failed
) {
10940 // $ANTLR end synpred3_CTFParser
10944 public final boolean synpred2_CTFParser() {
10945 state
.backtracking
++;
10946 int start
= input
.mark();
10948 synpred2_CTFParser_fragment(); // can never throw exception
10949 } catch (RecognitionException re
) {
10950 if(System
.err
!= null) {//findbugs
10951 System
.err
.println("impossible: " + re
);
10954 boolean success
= !state
.failed
;
10955 input
.rewind(start
);
10956 state
.backtracking
--;
10957 state
.failed
= false;
10961 public final boolean synpred1_CTFParser() {
10962 state
.backtracking
++;
10963 int start
= input
.mark();
10965 synpred1_CTFParser_fragment(); // can never throw exception
10966 } catch (RecognitionException re
) {
10967 if( System
.err
!= null ) {//findbugs
10968 System
.err
.println("impossible: " + re
);
10971 boolean success
= !state
.failed
;
10972 input
.rewind(start
);
10973 state
.backtracking
--;
10974 state
.failed
= false;
10978 public final boolean synpred3_CTFParser() {
10979 state
.backtracking
++;
10980 int start
= input
.mark();
10982 synpred3_CTFParser_fragment(); // can never throw exception
10983 } catch (RecognitionException re
) {
10984 if( System
.err
!= null ) { //findbugs
10985 System
.err
.println("impossible: " + re
);
10988 boolean success
= !state
.failed
;
10989 input
.rewind(start
);
10990 state
.backtracking
--;
10991 state
.failed
= false;
10995 protected DFA10 dfa10
= new DFA10(this);
10996 protected DFA17 dfa17
= new DFA17(this);
10997 protected DFA24 dfa24
= new DFA24(this);
10998 protected DFA32 dfa32
= new DFA32(this);
10999 protected DFA54 dfa54
= new DFA54(this);
11000 static final String DFA10_eotS
= "\16\uffff";
11001 static final String DFA10_eofS
= "\16\uffff";
11002 static final String DFA10_minS
= "\1\4\15\uffff";
11003 static final String DFA10_maxS
= "\1\116\15\uffff";
11004 static final String DFA10_acceptS
= "\1\uffff\2\1\7\uffff\1\2\3\uffff";
11005 static final String DFA10_specialS
= "\16\uffff}>";
11006 static final String
[] DFA10_transitionS
= {
11007 "\1\1\4\uffff\1\2\6\uffff\1\1\1\12\1\1\1\uffff\1\12\10\uffff"
11008 + "\2\12\22\uffff\1\1\4\uffff\1\1\1\uffff\1\1\2\uffff\1\1\10\uffff"
11009 + "\1\1\2\uffff\1\1\6\uffff\1\1", "", "", "", "", "", "",
11010 "", "", "", "", "", "", "" };
11012 static final short[] DFA10_eot
= DFA
.unpackEncodedString(DFA10_eotS
);
11013 static final short[] DFA10_eof
= DFA
.unpackEncodedString(DFA10_eofS
);
11014 static final char[] DFA10_min
= DFA
11015 .unpackEncodedStringToUnsignedChars(DFA10_minS
);
11016 static final char[] DFA10_max
= DFA
11017 .unpackEncodedStringToUnsignedChars(DFA10_maxS
);
11018 static final short[] DFA10_accept
= DFA
.unpackEncodedString(DFA10_acceptS
);
11019 static final short[] DFA10_special
= DFA
11020 .unpackEncodedString(DFA10_specialS
);
11021 static final short[][] DFA10_transition
;
11024 int numStates
= DFA10_transitionS
.length
;
11025 DFA10_transition
= new short[numStates
][];
11026 for (int i
= 0; i
< numStates
; i
++) {
11027 DFA10_transition
[i
] = DFA
.unpackEncodedString(DFA10_transitionS
[i
]);
11031 class DFA10
extends DFA
{
11033 public DFA10(BaseRecognizer recognizer
) {
11034 this.recognizer
= recognizer
;
11035 this.decisionNumber
= 10;
11036 this.eot
= DFA10_eot
;
11037 this.eof
= DFA10_eof
;
11038 this.min
= DFA10_min
;
11039 this.max
= DFA10_max
;
11040 this.accept
= DFA10_accept
;
11041 this.special
= DFA10_special
;
11042 this.transition
= DFA10_transition
;
11046 public String
getDescription() {
11047 return "281:1: postfixExpression : ( ( primaryExpression ) ( postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) ( postfixExpressionSuffix )+ ) );";
11051 static final String DFA17_eotS
= "\22\uffff";
11052 static final String DFA17_eofS
= "\22\uffff";
11053 static final String DFA17_minS
= "\1\6\21\uffff";
11054 static final String DFA17_maxS
= "\1\116\21\uffff";
11055 static final String DFA17_acceptS
= "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"
11056 + "\15\1\16\1\17\1\20\1\21";
11057 static final String DFA17_specialS
= "\1\0\21\uffff}>";
11058 static final String
[] DFA17_transitionS
= {
11059 "\1\7\1\10\1\17\1\uffff\1\20\1\1\1\20\1\2\1\3\1\4\1\5\1\uffff"
11060 + "\1\20\1\15\3\uffff\1\6\1\16\1\11\1\12\1\13\1\14\61\uffff\1\21",
11061 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" };
11063 static final short[] DFA17_eot
= DFA
.unpackEncodedString(DFA17_eotS
);
11064 static final short[] DFA17_eof
= DFA
.unpackEncodedString(DFA17_eofS
);
11065 static final char[] DFA17_min
= DFA
11066 .unpackEncodedStringToUnsignedChars(DFA17_minS
);
11067 static final char[] DFA17_max
= DFA
11068 .unpackEncodedStringToUnsignedChars(DFA17_maxS
);
11069 static final short[] DFA17_accept
= DFA
.unpackEncodedString(DFA17_acceptS
);
11070 static final short[] DFA17_special
= DFA
11071 .unpackEncodedString(DFA17_specialS
);
11072 static final short[][] DFA17_transition
;
11075 int numStates
= DFA17_transitionS
.length
;
11076 DFA17_transition
= new short[numStates
][];
11077 for (int i
= 0; i
< numStates
; i
++) {
11078 DFA17_transition
[i
] = DFA
.unpackEncodedString(DFA17_transitionS
[i
]);
11082 class DFA17
extends DFA
{
11084 public DFA17(BaseRecognizer recognizer
) {
11085 this.recognizer
= recognizer
;
11086 this.decisionNumber
= 17;
11087 this.eot
= DFA17_eot
;
11088 this.eof
= DFA17_eof
;
11089 this.min
= DFA17_min
;
11090 this.max
= DFA17_max
;
11091 this.accept
= DFA17_accept
;
11092 this.special
= DFA17_special
;
11093 this.transition
= DFA17_transition
;
11097 public String
getDescription() {
11098 return "384:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName );";
11101 @SuppressWarnings({ "synthetic-access" })
11103 public int specialStateTransition(final int inputS
, IntStream _input
)
11104 throws NoViableAltException
{
11105 TokenStream input
= (TokenStream
) _input
;
11110 int LA17_0
= input
.LA(1);
11112 int index17_0
= input
.index();
11115 if ((LA17_0
== FLOATTOK
)) {
11119 else if ((LA17_0
== INTTOK
)) {
11123 else if ((LA17_0
== LONGTOK
)) {
11127 else if ((LA17_0
== SHORTTOK
)) {
11131 else if ((LA17_0
== SIGNEDTOK
)) {
11135 else if ((LA17_0
== UNSIGNEDTOK
)) {
11139 else if ((LA17_0
== CHARTOK
)) {
11143 else if ((LA17_0
== DOUBLETOK
)) {
11147 else if ((LA17_0
== VOIDTOK
)) {
11151 else if ((LA17_0
== BOOLTOK
)) {
11155 else if ((LA17_0
== COMPLEXTOK
)) {
11159 else if ((LA17_0
== IMAGINARYTOK
)) {
11163 else if ((LA17_0
== STRUCTTOK
)) {
11167 else if ((LA17_0
== VARIANTTOK
)) {
11171 else if ((LA17_0
== ENUMTOK
)) {
11175 else if (((LA17_0
== FLOATINGPOINTTOK
)
11176 || (LA17_0
== INTEGERTOK
) || (LA17_0
== STRINGTOK
))) {
11180 else if ((LA17_0
== IDENTIFIER
)
11181 && ((inTypealiasAlias() || isTypeName(input
.LT(1)
11186 input
.seek(index17_0
);
11192 if (state
.backtracking
> 0) {
11193 state
.failed
= true;
11196 NoViableAltException nvae
= new NoViableAltException(
11197 getDescription(), 17, _s
, input
);
11203 static final String DFA24_eotS
= "\6\uffff";
11204 static final String DFA24_eofS
= "\6\uffff";
11205 static final String DFA24_minS
= "\1\60\1\5\1\0\1\5\2\uffff";
11206 static final String DFA24_maxS
= "\2\116\1\0\1\116\2\uffff";
11207 static final String DFA24_acceptS
= "\4\uffff\1\1\1\2";
11208 static final String DFA24_specialS
= "\2\uffff\1\0\3\uffff}>";
11209 static final String
[] DFA24_transitionS
= { "\1\1\35\uffff\1\2",
11210 "\1\3\52\uffff\1\1\35\uffff\1\2", "\1\uffff",
11211 "\1\3\52\uffff\1\1\35\uffff\1\2", "", "" };
11213 static final short[] DFA24_eot
= DFA
.unpackEncodedString(DFA24_eotS
);
11214 static final short[] DFA24_eof
= DFA
.unpackEncodedString(DFA24_eofS
);
11215 static final char[] DFA24_min
= DFA
11216 .unpackEncodedStringToUnsignedChars(DFA24_minS
);
11217 static final char[] DFA24_max
= DFA
11218 .unpackEncodedStringToUnsignedChars(DFA24_maxS
);
11219 static final short[] DFA24_accept
= DFA
.unpackEncodedString(DFA24_acceptS
);
11220 static final short[] DFA24_special
= DFA
11221 .unpackEncodedString(DFA24_specialS
);
11222 static final short[][] DFA24_transition
;
11225 int numStates
= DFA24_transitionS
.length
;
11226 DFA24_transition
= new short[numStates
][];
11227 for (int i
= 0; i
< numStates
; i
++) {
11228 DFA24_transition
[i
] = DFA
.unpackEncodedString(DFA24_transitionS
[i
]);
11232 class DFA24
extends DFA
{
11234 public DFA24(BaseRecognizer recognizer
) {
11235 this.recognizer
= recognizer
;
11236 this.decisionNumber
= 24;
11237 this.eot
= DFA24_eot
;
11238 this.eof
= DFA24_eof
;
11239 this.min
= DFA24_min
;
11240 this.max
= DFA24_max
;
11241 this.accept
= DFA24_accept
;
11242 this.special
= DFA24_special
;
11243 this.transition
= DFA24_transition
;
11247 public String
getDescription() {
11248 return "521:7: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )";
11252 public int specialStateTransition(int s
, IntStream _input
)
11253 throws NoViableAltException
{
11254 TokenStream input
= (TokenStream
) _input
;
11258 int LA24_2
= input
.LA(1);
11260 int index24_2
= input
.index();
11263 if (((inTypedef()))) {
11271 input
.seek(index24_2
);
11277 if (state
.backtracking
> 0) {
11278 state
.failed
= true;
11281 NoViableAltException nvae
= new NoViableAltException(
11282 getDescription(), 24, _s
, input
);
11288 static final String DFA32_eotS
= "\35\uffff";
11289 static final String DFA32_eofS
= "\1\3\34\uffff";
11290 static final String DFA32_minS
= "\1\5\34\uffff";
11291 static final String DFA32_maxS
= "\1\116\34\uffff";
11292 static final String DFA32_acceptS
= "\1\uffff\1\1\1\2\1\3\31\uffff";
11293 static final String DFA32_specialS
= "\35\uffff}>";
11294 static final String
[] DFA32_transitionS
= {
11295 "\4\3\1\uffff\7\3\1\uffff\2\3\2\uffff\7\3\6\uffff\1\1\2\uffff"
11296 + "\1\3\4\uffff\1\3\1\uffff\1\2\1\uffff\2\3\35\uffff\1\3",
11297 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
11298 "", "", "", "", "", "", "", "", "", "", "" };
11300 static final short[] DFA32_eot
= DFA
.unpackEncodedString(DFA32_eotS
);
11301 static final short[] DFA32_eof
= DFA
.unpackEncodedString(DFA32_eofS
);
11302 static final char[] DFA32_min
= DFA
11303 .unpackEncodedStringToUnsignedChars(DFA32_minS
);
11304 static final char[] DFA32_max
= DFA
11305 .unpackEncodedStringToUnsignedChars(DFA32_maxS
);
11306 static final short[] DFA32_accept
= DFA
.unpackEncodedString(DFA32_acceptS
);
11307 static final short[] DFA32_special
= DFA
11308 .unpackEncodedString(DFA32_specialS
);
11309 static final short[][] DFA32_transition
;
11312 int numStates
= DFA32_transitionS
.length
;
11313 DFA32_transition
= new short[numStates
][];
11314 for (int i
= 0; i
< numStates
; i
++) {
11315 DFA32_transition
[i
] = DFA
.unpackEncodedString(DFA32_transitionS
[i
]);
11319 class DFA32
extends DFA
{
11321 public DFA32(BaseRecognizer recognizer
) {
11322 this.recognizer
= recognizer
;
11323 this.decisionNumber
= 32;
11324 this.eot
= DFA32_eot
;
11325 this.eof
= DFA32_eof
;
11326 this.min
= DFA32_min
;
11327 this.max
= DFA32_max
;
11328 this.accept
= DFA32_accept
;
11329 this.special
= DFA32_special
;
11330 this.transition
= DFA32_transition
;
11334 public String
getDescription() {
11335 return "655:4: ( enumContainerType enumBody | enumBody | )";
11339 static final String DFA54_eotS
= "\34\uffff";
11340 static final String DFA54_eofS
= "\1\2\33\uffff";
11341 static final String DFA54_minS
= "\1\5\33\uffff";
11342 static final String DFA54_maxS
= "\1\116\33\uffff";
11343 static final String DFA54_acceptS
= "\1\uffff\1\1\1\2\31\uffff";
11344 static final String DFA54_specialS
= "\34\uffff}>";
11345 static final String
[] DFA54_transitionS
= {
11346 "\4\2\1\uffff\7\2\1\uffff\2\2\2\uffff\7\2\11\uffff\1\2\4\uffff"
11347 + "\1\2\1\uffff\1\1\1\uffff\2\2\35\uffff\1\2", "", "", "",
11348 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
11349 "", "", "", "", "", "", "" };
11351 static final short[] DFA54_eot
= DFA
.unpackEncodedString(DFA54_eotS
);
11352 static final short[] DFA54_eof
= DFA
.unpackEncodedString(DFA54_eofS
);
11353 static final char[] DFA54_min
= DFA
11354 .unpackEncodedStringToUnsignedChars(DFA54_minS
);
11355 static final char[] DFA54_max
= DFA
11356 .unpackEncodedStringToUnsignedChars(DFA54_maxS
);
11357 static final short[] DFA54_accept
= DFA
.unpackEncodedString(DFA54_acceptS
);
11358 static final short[] DFA54_special
= DFA
11359 .unpackEncodedString(DFA54_specialS
);
11360 static final short[][] DFA54_transition
;
11363 int numStates
= DFA54_transitionS
.length
;
11364 DFA54_transition
= new short[numStates
][];
11365 for (int i
= 0; i
< numStates
; i
++) {
11366 DFA54_transition
[i
] = DFA
.unpackEncodedString(DFA54_transitionS
[i
]);
11370 class DFA54
extends DFA
{
11372 public DFA54(BaseRecognizer recognizer
) {
11373 this.recognizer
= recognizer
;
11374 this.decisionNumber
= 54;
11375 this.eot
= DFA54_eot
;
11376 this.eof
= DFA54_eof
;
11377 this.min
= DFA54_min
;
11378 this.max
= DFA54_max
;
11379 this.accept
= DFA54_accept
;
11380 this.special
= DFA54_special
;
11381 this.transition
= DFA54_transition
;
11385 public String
getDescription() {
11386 return "954:15: ( ctfBody )?";
11390 public static final BitSet FOLLOW_declaration_in_parse321
= new BitSet(
11391 new long[] { 0x000000007FFFFFE0L
, 0x0000000000004000L
});
11392 public static final BitSet FOLLOW_EOF_in_parse324
= new BitSet(
11393 new long[] { 0x0000000000000002L
});
11394 public static final BitSet FOLLOW_SIGN_in_numberLiteral357
= new BitSet(
11395 new long[] { 0x0942000000000000L
});
11396 public static final BitSet FOLLOW_HEX_LITERAL_in_numberLiteral362
= new BitSet(
11397 new long[] { 0x0000000000000002L
});
11398 public static final BitSet FOLLOW_DECIMAL_LITERAL_in_numberLiteral379
= new BitSet(
11399 new long[] { 0x0000000000000002L
});
11400 public static final BitSet FOLLOW_OCTAL_LITERAL_in_numberLiteral396
= new BitSet(
11401 new long[] { 0x0000000000000002L
});
11402 public static final BitSet FOLLOW_numberLiteral_in_constant432
= new BitSet(
11403 new long[] { 0x0000000000000002L
});
11404 public static final BitSet FOLLOW_enumConstant_in_constant438
= new BitSet(
11405 new long[] { 0x0000000000000002L
});
11406 public static final BitSet FOLLOW_CHARACTER_LITERAL_in_constant444
= new BitSet(
11407 new long[] { 0x0000000000000002L
});
11408 public static final BitSet FOLLOW_IDENTIFIER_in_primaryExpression475
= new BitSet(
11409 new long[] { 0x0000000000000002L
});
11410 public static final BitSet FOLLOW_ctfKeyword_in_primaryExpression497
= new BitSet(
11411 new long[] { 0x0000000000000002L
});
11412 public static final BitSet FOLLOW_STRING_LITERAL_in_primaryExpression517
= new BitSet(
11413 new long[] { 0x0000000000000002L
});
11414 public static final BitSet FOLLOW_constant_in_primaryExpression538
= new BitSet(
11415 new long[] { 0x0000000000000002L
});
11416 public static final BitSet FOLLOW_DOT_in_reference564
= new BitSet(
11417 new long[] { 0x0000000000000000L
, 0x0000000000004000L
});
11418 public static final BitSet FOLLOW_ARROW_in_reference570
= new BitSet(
11419 new long[] { 0x0000000000000000L
, 0x0000000000004000L
});
11420 public static final BitSet FOLLOW_IDENTIFIER_in_reference573
= new BitSet(
11421 new long[] { 0x0000000000000002L
});
11422 public static final BitSet FOLLOW_OPENBRAC_in_postfixExpressionSuffix612
= new BitSet(
11423 new long[] { 0x0942000060170210L
, 0x0000000000004090L
});
11424 public static final BitSet FOLLOW_unaryExpression_in_postfixExpressionSuffix614
= new BitSet(
11425 new long[] { 0x0000040000000000L
});
11426 public static final BitSet FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix616
= new BitSet(
11427 new long[] { 0x0000000000000002L
});
11428 public static final BitSet FOLLOW_reference_in_postfixExpressionSuffix624
= new BitSet(
11429 new long[] { 0x0000000000000002L
});
11430 public static final BitSet FOLLOW_primaryExpression_in_postfixExpression648
= new BitSet(
11431 new long[] { 0x000C020000000002L
});
11432 public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression652
= new BitSet(
11433 new long[] { 0x000C020000000002L
});
11434 public static final BitSet FOLLOW_ctfSpecifierHead_in_postfixExpression661
= new BitSet(
11435 new long[] { 0x000C020000000000L
});
11436 public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression666
= new BitSet(
11437 new long[] { 0x000C020000000002L
});
11438 public static final BitSet FOLLOW_postfixExpression_in_unaryExpression700
= new BitSet(
11439 new long[] { 0x0000000000000002L
});
11440 public static final BitSet FOLLOW_STRING_LITERAL_in_enumConstant725
= new BitSet(
11441 new long[] { 0x0000000000000002L
});
11442 public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant741
= new BitSet(
11443 new long[] { 0x0000000000000002L
});
11444 public static final BitSet FOLLOW_ctfKeyword_in_enumConstant757
= new BitSet(
11445 new long[] { 0x0000000000000002L
});
11446 public static final BitSet FOLLOW_declarationSpecifiers_in_declaration790
= new BitSet(
11447 new long[] { 0x0001800000000000L
, 0x0000000000004000L
});
11448 public static final BitSet FOLLOW_declaratorList_in_declaration792
= new BitSet(
11449 new long[] { 0x0000800000000000L
});
11450 public static final BitSet FOLLOW_TERM_in_declaration795
= new BitSet(
11451 new long[] { 0x0000000000000002L
});
11452 public static final BitSet FOLLOW_ctfSpecifier_in_declaration844
= new BitSet(
11453 new long[] { 0x0000800000000000L
});
11454 public static final BitSet FOLLOW_TERM_in_declaration846
= new BitSet(
11455 new long[] { 0x0000000000000002L
});
11456 public static final BitSet FOLLOW_storageClassSpecifier_in_declarationSpecifiers891
= new BitSet(
11457 new long[] { 0x000000001FCDFDE2L
, 0x0000000000004000L
});
11458 public static final BitSet FOLLOW_typeQualifier_in_declarationSpecifiers898
= new BitSet(
11459 new long[] { 0x000000001FCDFDE2L
, 0x0000000000004000L
});
11460 public static final BitSet FOLLOW_typeSpecifier_in_declarationSpecifiers905
= new BitSet(
11461 new long[] { 0x000000001FCDFDE2L
, 0x0000000000004000L
});
11462 public static final BitSet FOLLOW_declarator_in_declaratorList946
= new BitSet(
11463 new long[] { 0x0000000400000002L
});
11464 public static final BitSet FOLLOW_SEPARATOR_in_declaratorList949
= new BitSet(
11465 new long[] { 0x0001000000000000L
, 0x0000000000004000L
});
11466 public static final BitSet FOLLOW_declarator_in_declaratorList951
= new BitSet(
11467 new long[] { 0x0000000400000002L
});
11468 public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList985
= new BitSet(
11469 new long[] { 0x0000000400000002L
});
11470 public static final BitSet FOLLOW_SEPARATOR_in_abstractDeclaratorList988
= new BitSet(
11471 new long[] { 0x0001080000000000L
, 0x0000000000004000L
});
11472 public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList990
= new BitSet(
11473 new long[] { 0x0000000400000002L
});
11474 public static final BitSet FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1014
= new BitSet(
11475 new long[] { 0x0000000000000002L
});
11476 public static final BitSet FOLLOW_FLOATTOK_in_typeSpecifier1040
= new BitSet(
11477 new long[] { 0x0000000000000002L
});
11478 public static final BitSet FOLLOW_INTTOK_in_typeSpecifier1046
= new BitSet(
11479 new long[] { 0x0000000000000002L
});
11480 public static final BitSet FOLLOW_LONGTOK_in_typeSpecifier1052
= new BitSet(
11481 new long[] { 0x0000000000000002L
});
11482 public static final BitSet FOLLOW_SHORTTOK_in_typeSpecifier1058
= new BitSet(
11483 new long[] { 0x0000000000000002L
});
11484 public static final BitSet FOLLOW_SIGNEDTOK_in_typeSpecifier1064
= new BitSet(
11485 new long[] { 0x0000000000000002L
});
11486 public static final BitSet FOLLOW_UNSIGNEDTOK_in_typeSpecifier1070
= new BitSet(
11487 new long[] { 0x0000000000000002L
});
11488 public static final BitSet FOLLOW_CHARTOK_in_typeSpecifier1076
= new BitSet(
11489 new long[] { 0x0000000000000002L
});
11490 public static final BitSet FOLLOW_DOUBLETOK_in_typeSpecifier1082
= new BitSet(
11491 new long[] { 0x0000000000000002L
});
11492 public static final BitSet FOLLOW_VOIDTOK_in_typeSpecifier1088
= new BitSet(
11493 new long[] { 0x0000000000000002L
});
11494 public static final BitSet FOLLOW_BOOLTOK_in_typeSpecifier1094
= new BitSet(
11495 new long[] { 0x0000000000000002L
});
11496 public static final BitSet FOLLOW_COMPLEXTOK_in_typeSpecifier1100
= new BitSet(
11497 new long[] { 0x0000000000000002L
});
11498 public static final BitSet FOLLOW_IMAGINARYTOK_in_typeSpecifier1106
= new BitSet(
11499 new long[] { 0x0000000000000002L
});
11500 public static final BitSet FOLLOW_structSpecifier_in_typeSpecifier1112
= new BitSet(
11501 new long[] { 0x0000000000000002L
});
11502 public static final BitSet FOLLOW_variantSpecifier_in_typeSpecifier1118
= new BitSet(
11503 new long[] { 0x0000000000000002L
});
11504 public static final BitSet FOLLOW_enumSpecifier_in_typeSpecifier1124
= new BitSet(
11505 new long[] { 0x0000000000000002L
});
11506 public static final BitSet FOLLOW_ctfTypeSpecifier_in_typeSpecifier1130
= new BitSet(
11507 new long[] { 0x0000000000000002L
});
11508 public static final BitSet FOLLOW_typedefName_in_typeSpecifier1140
= new BitSet(
11509 new long[] { 0x0000000000000002L
});
11510 public static final BitSet FOLLOW_CONSTTOK_in_typeQualifier1163
= new BitSet(
11511 new long[] { 0x0000000000000002L
});
11512 public static final BitSet FOLLOW_ALIGNTOK_in_alignAttribute1176
= new BitSet(
11513 new long[] { 0x0000080000000000L
});
11514 public static final BitSet FOLLOW_LPAREN_in_alignAttribute1178
= new BitSet(
11515 new long[] { 0x0942000060170210L
, 0x0000000000004090L
});
11516 public static final BitSet FOLLOW_unaryExpression_in_alignAttribute1180
= new BitSet(
11517 new long[] { 0x0000100000000000L
});
11518 public static final BitSet FOLLOW_RPAREN_in_alignAttribute1182
= new BitSet(
11519 new long[] { 0x0000000000000002L
});
11520 public static final BitSet FOLLOW_LCURL_in_structBody1223
= new BitSet(
11521 new long[] { 0x000040007FFFFFE0L
, 0x0000000000004000L
});
11522 public static final BitSet FOLLOW_structOrVariantDeclarationList_in_structBody1225
= new BitSet(
11523 new long[] { 0x0000400000000000L
});
11524 public static final BitSet FOLLOW_RCURL_in_structBody1228
= new BitSet(
11525 new long[] { 0x0000000000000002L
});
11526 public static final BitSet FOLLOW_STRUCTTOK_in_structSpecifier1266
= new BitSet(
11527 new long[] { 0x0000200000000000L
, 0x0000000000004000L
});
11528 public static final BitSet FOLLOW_structName_in_structSpecifier1288
= new BitSet(
11529 new long[] { 0x0000200000000012L
, 0x0000000000004000L
});
11530 public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1304
= new BitSet(
11531 new long[] { 0x0000000000000002L
});
11532 public static final BitSet FOLLOW_structBody_in_structSpecifier1333
= new BitSet(
11533 new long[] { 0x0000000000000012L
});
11534 public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1358
= new BitSet(
11535 new long[] { 0x0000000000000002L
});
11536 public static final BitSet FOLLOW_structBody_in_structSpecifier1456
= new BitSet(
11537 new long[] { 0x0000000000000012L
});
11538 public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1474
= new BitSet(
11539 new long[] { 0x0000000000000002L
});
11540 public static final BitSet FOLLOW_IDENTIFIER_in_structName1550
= new BitSet(
11541 new long[] { 0x0000000000000002L
});
11542 public static final BitSet FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1581
= new BitSet(
11543 new long[] { 0x000000007FFFFFE2L
, 0x0000000000004000L
});
11544 public static final BitSet FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1619
= new BitSet(
11545 new long[] { 0x0001000000000000L
, 0x0000000000004000L
});
11546 public static final BitSet FOLLOW_declaratorList_in_structOrVariantDeclaration1651
= new BitSet(
11547 new long[] { 0x0000800000000000L
});
11548 public static final BitSet FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1685
= new BitSet(
11549 new long[] { 0x0000800000000000L
});
11550 public static final BitSet FOLLOW_typealiasDecl_in_structOrVariantDeclaration1735
= new BitSet(
11551 new long[] { 0x0000800000000000L
});
11552 public static final BitSet FOLLOW_TERM_in_structOrVariantDeclaration1747
= new BitSet(
11553 new long[] { 0x0000000000000002L
});
11554 public static final BitSet FOLLOW_typeQualifier_in_specifierQualifierList1771
= new BitSet(
11555 new long[] { 0x000000001FCDFDE2L
, 0x0000000000004000L
});
11556 public static final BitSet FOLLOW_typeSpecifier_in_specifierQualifierList1775
= new BitSet(
11557 new long[] { 0x000000001FCDFDE2L
, 0x0000000000004000L
});
11558 public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1812
= new BitSet(
11559 new long[] { 0x0000000400000002L
});
11560 public static final BitSet FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1815
= new BitSet(
11561 new long[] { 0x0001000000000000L
, 0x0000000000004000L
});
11562 public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1817
= new BitSet(
11563 new long[] { 0x0000000400000002L
});
11564 public static final BitSet FOLLOW_declarator_in_structOrVariantDeclarator1858
= new BitSet(
11565 new long[] { 0x0000000800000002L
});
11566 public static final BitSet FOLLOW_COLON_in_structOrVariantDeclarator1861
= new BitSet(
11567 new long[] { 0x0942000000000000L
});
11568 public static final BitSet FOLLOW_numberLiteral_in_structOrVariantDeclarator1863
= new BitSet(
11569 new long[] { 0x0000000000000002L
});
11570 public static final BitSet FOLLOW_VARIANTTOK_in_variantSpecifier1897
= new BitSet(
11571 new long[] { 0x0000208000000000L
, 0x0000000000004000L
});
11572 public static final BitSet FOLLOW_variantName_in_variantSpecifier1915
= new BitSet(
11573 new long[] { 0x0000208000000000L
, 0x0000000000004000L
});
11574 public static final BitSet FOLLOW_variantTag_in_variantSpecifier1946
= new BitSet(
11575 new long[] { 0x0000208000000002L
, 0x0000000000004000L
});
11576 public static final BitSet FOLLOW_variantBody_in_variantSpecifier1972
= new BitSet(
11577 new long[] { 0x0000000000000002L
});
11578 public static final BitSet FOLLOW_variantBody_in_variantSpecifier2040
= new BitSet(
11579 new long[] { 0x0000000000000002L
});
11580 public static final BitSet FOLLOW_variantTag_in_variantSpecifier2065
= new BitSet(
11581 new long[] { 0x0000208000000000L
, 0x0000000000004000L
});
11582 public static final BitSet FOLLOW_variantBody_in_variantSpecifier2067
= new BitSet(
11583 new long[] { 0x0000000000000002L
});
11584 public static final BitSet FOLLOW_variantBody_in_variantSpecifier2078
= new BitSet(
11585 new long[] { 0x0000000000000002L
});
11586 public static final BitSet FOLLOW_IDENTIFIER_in_variantName2120
= new BitSet(
11587 new long[] { 0x0000000000000002L
});
11588 public static final BitSet FOLLOW_LCURL_in_variantBody2156
= new BitSet(
11589 new long[] { 0x000000007FFFFFE0L
, 0x0000000000004000L
});
11590 public static final BitSet FOLLOW_structOrVariantDeclarationList_in_variantBody2158
= new BitSet(
11591 new long[] { 0x0000400000000000L
});
11592 public static final BitSet FOLLOW_RCURL_in_variantBody2160
= new BitSet(
11593 new long[] { 0x0000000000000002L
});
11594 public static final BitSet FOLLOW_LT_in_variantTag2191
= new BitSet(
11595 new long[] { 0x0000000000000000L
, 0x0000000000004000L
});
11596 public static final BitSet FOLLOW_IDENTIFIER_in_variantTag2193
= new BitSet(
11597 new long[] { 0x0000010000000000L
});
11598 public static final BitSet FOLLOW_GT_in_variantTag2195
= new BitSet(
11599 new long[] { 0x0000000000000002L
});
11600 public static final BitSet FOLLOW_ENUMTOK_in_enumSpecifier2225
= new BitSet(
11601 new long[] { 0x0000200800000000L
, 0x0000000000004000L
});
11602 public static final BitSet FOLLOW_enumName_in_enumSpecifier2240
= new BitSet(
11603 new long[] { 0x0000200800000002L
, 0x0000000000004000L
});
11604 public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2251
= new BitSet(
11605 new long[] { 0x0000200800000000L
, 0x0000000000004000L
});
11606 public static final BitSet FOLLOW_enumBody_in_enumSpecifier2253
= new BitSet(
11607 new long[] { 0x0000000000000002L
});
11608 public static final BitSet FOLLOW_enumBody_in_enumSpecifier2265
= new BitSet(
11609 new long[] { 0x0000000000000002L
});
11610 public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2300
= new BitSet(
11611 new long[] { 0x0000200800000000L
, 0x0000000000004000L
});
11612 public static final BitSet FOLLOW_enumBody_in_enumSpecifier2302
= new BitSet(
11613 new long[] { 0x0000000000000002L
});
11614 public static final BitSet FOLLOW_enumBody_in_enumSpecifier2311
= new BitSet(
11615 new long[] { 0x0000000000000002L
});
11616 public static final BitSet FOLLOW_IDENTIFIER_in_enumName2356
= new BitSet(
11617 new long[] { 0x0000000000000002L
});
11618 public static final BitSet FOLLOW_LCURL_in_enumBody2389
= new BitSet(
11619 new long[] { 0x0000000000050210L
, 0x0000000000004080L
});
11620 public static final BitSet FOLLOW_enumeratorList_in_enumBody2391
= new BitSet(
11621 new long[] { 0x0000400400000000L
});
11622 public static final BitSet FOLLOW_SEPARATOR_in_enumBody2394
= new BitSet(
11623 new long[] { 0x0000400000000000L
});
11624 public static final BitSet FOLLOW_RCURL_in_enumBody2396
= new BitSet(
11625 new long[] { 0x0000000000000002L
});
11626 public static final BitSet FOLLOW_RCURL_in_enumBody2400
= new BitSet(
11627 new long[] { 0x0000000000000002L
});
11628 public static final BitSet FOLLOW_COLON_in_enumContainerType2432
= new BitSet(
11629 new long[] { 0x000000001FCDFDE0L
, 0x0000000000004000L
});
11630 public static final BitSet FOLLOW_declarationSpecifiers_in_enumContainerType2434
= new BitSet(
11631 new long[] { 0x0000000000000002L
});
11632 public static final BitSet FOLLOW_enumerator_in_enumeratorList2465
= new BitSet(
11633 new long[] { 0x0000000400000002L
});
11634 public static final BitSet FOLLOW_SEPARATOR_in_enumeratorList2468
= new BitSet(
11635 new long[] { 0x0000000000050210L
, 0x0000000000004080L
});
11636 public static final BitSet FOLLOW_enumerator_in_enumeratorList2470
= new BitSet(
11637 new long[] { 0x0000000400000002L
});
11638 public static final BitSet FOLLOW_enumConstant_in_enumerator2506
= new BitSet(
11639 new long[] { 0x0000002000000002L
});
11640 public static final BitSet FOLLOW_enumeratorValue_in_enumerator2508
= new BitSet(
11641 new long[] { 0x0000000000000002L
});
11642 public static final BitSet FOLLOW_ASSIGNMENT_in_enumeratorValue2532
= new BitSet(
11643 new long[] { 0x0942000060170210L
, 0x0000000000004090L
});
11644 public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2536
= new BitSet(
11645 new long[] { 0x0000001000000002L
});
11646 public static final BitSet FOLLOW_ELIPSES_in_enumeratorValue2562
= new BitSet(
11647 new long[] { 0x0942000060170210L
, 0x0000000000004090L
});
11648 public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2566
= new BitSet(
11649 new long[] { 0x0000000000000002L
});
11650 public static final BitSet FOLLOW_pointer_in_declarator2608
= new BitSet(
11651 new long[] { 0x0001000000000000L
, 0x0000000000004000L
});
11652 public static final BitSet FOLLOW_directDeclarator_in_declarator2611
= new BitSet(
11653 new long[] { 0x0000000000000002L
});
11654 public static final BitSet FOLLOW_IDENTIFIER_in_directDeclarator2655
= new BitSet(
11655 new long[] { 0x0000020000000002L
});
11656 public static final BitSet FOLLOW_directDeclaratorSuffix_in_directDeclarator2673
= new BitSet(
11657 new long[] { 0x0000020000000002L
});
11658 public static final BitSet FOLLOW_OPENBRAC_in_directDeclaratorSuffix2686
= new BitSet(
11659 new long[] { 0x0942000060170210L
, 0x0000000000004090L
});
11660 public static final BitSet FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2688
= new BitSet(
11661 new long[] { 0x0000040000000000L
});
11662 public static final BitSet FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2690
= new BitSet(
11663 new long[] { 0x0000000000000002L
});
11664 public static final BitSet FOLLOW_unaryExpression_in_directDeclaratorLength2711
= new BitSet(
11665 new long[] { 0x0000000000000002L
});
11666 public static final BitSet FOLLOW_pointer_in_abstractDeclarator2742
= new BitSet(
11667 new long[] { 0x0001080000000002L
, 0x0000000000004000L
});
11668 public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2745
= new BitSet(
11669 new long[] { 0x0000000000000002L
});
11670 public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2765
= new BitSet(
11671 new long[] { 0x0000000000000002L
});
11672 public static final BitSet FOLLOW_IDENTIFIER_in_directAbstractDeclarator2805
= new BitSet(
11673 new long[] { 0x0000020000000002L
});
11674 public static final BitSet FOLLOW_LPAREN_in_directAbstractDeclarator2814
= new BitSet(
11675 new long[] { 0x0001080000000000L
, 0x0000000000004000L
});
11676 public static final BitSet FOLLOW_abstractDeclarator_in_directAbstractDeclarator2816
= new BitSet(
11677 new long[] { 0x0000100000000000L
});
11678 public static final BitSet FOLLOW_RPAREN_in_directAbstractDeclarator2818
= new BitSet(
11679 new long[] { 0x0000020000000002L
});
11680 public static final BitSet FOLLOW_OPENBRAC_in_directAbstractDeclarator2833
= new BitSet(
11681 new long[] { 0x0942040060170210L
, 0x0000000000004090L
});
11682 public static final BitSet FOLLOW_unaryExpression_in_directAbstractDeclarator2835
= new BitSet(
11683 new long[] { 0x0000040000000000L
});
11684 public static final BitSet FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2838
= new BitSet(
11685 new long[] { 0x0000000000000002L
});
11686 public static final BitSet FOLLOW_POINTER_in_pointer2866
= new BitSet(
11687 new long[] { 0x0000000000000022L
});
11688 public static final BitSet FOLLOW_typeQualifierList_in_pointer2868
= new BitSet(
11689 new long[] { 0x0000000000000002L
});
11690 public static final BitSet FOLLOW_typeQualifier_in_typeQualifierList2891
= new BitSet(
11691 new long[] { 0x0000000000000022L
});
11692 public static final BitSet FOLLOW_IDENTIFIER_in_typedefName2917
= new BitSet(
11693 new long[] { 0x0000000000000002L
});
11694 public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasTarget2945
= new BitSet(
11695 new long[] { 0x0001080000000002L
, 0x0000000000004000L
});
11696 public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasTarget2947
= new BitSet(
11697 new long[] { 0x0000000000000002L
});
11698 public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias2980
= new BitSet(
11699 new long[] { 0x0000000000000002L
});
11700 public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasAlias2989
= new BitSet(
11701 new long[] { 0x0001080000000002L
, 0x0000000000004000L
});
11702 public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias2991
= new BitSet(
11703 new long[] { 0x0000000000000002L
});
11704 public static final BitSet FOLLOW_TYPEALIASTOK_in_typealiasDecl3023
= new BitSet(
11705 new long[] { 0x000000001FCDFDE0L
, 0x0000000000004000L
});
11706 public static final BitSet FOLLOW_typealiasTarget_in_typealiasDecl3025
= new BitSet(
11707 new long[] { 0x0000004000000000L
});
11708 public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3027
= new BitSet(
11709 new long[] { 0x000108001FCDFDE0L
, 0x0000000000004000L
});
11710 public static final BitSet FOLLOW_typealiasAlias_in_typealiasDecl3029
= new BitSet(
11711 new long[] { 0x0000000000000002L
});
11712 public static final BitSet FOLLOW_set_in_ctfKeyword0
= new BitSet(
11713 new long[] { 0x0000000000000002L
});
11714 public static final BitSet FOLLOW_ctfSpecifierHead_in_ctfSpecifier3123
= new BitSet(
11715 new long[] { 0x0000200000000000L
});
11716 public static final BitSet FOLLOW_ctfBody_in_ctfSpecifier3125
= new BitSet(
11717 new long[] { 0x0000000000000002L
});
11718 public static final BitSet FOLLOW_typealiasDecl_in_ctfSpecifier3144
= new BitSet(
11719 new long[] { 0x0000000000000002L
});
11720 public static final BitSet FOLLOW_EVENTTOK_in_ctfSpecifierHead3176
= new BitSet(
11721 new long[] { 0x0000000000000002L
});
11722 public static final BitSet FOLLOW_STREAMTOK_in_ctfSpecifierHead3185
= new BitSet(
11723 new long[] { 0x0000000000000002L
});
11724 public static final BitSet FOLLOW_TRACETOK_in_ctfSpecifierHead3194
= new BitSet(
11725 new long[] { 0x0000000000000002L
});
11726 public static final BitSet FOLLOW_ENVTOK_in_ctfSpecifierHead3203
= new BitSet(
11727 new long[] { 0x0000000000000002L
});
11728 public static final BitSet FOLLOW_CLOCKTOK_in_ctfSpecifierHead3212
= new BitSet(
11729 new long[] { 0x0000000000000002L
});
11730 public static final BitSet FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3246
= new BitSet(
11731 new long[] { 0x0000200000000000L
});
11732 public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3248
= new BitSet(
11733 new long[] { 0x0000000000000002L
});
11734 public static final BitSet FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3263
= new BitSet(
11735 new long[] { 0x0000200000000000L
});
11736 public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3265
= new BitSet(
11737 new long[] { 0x0000000000000002L
});
11738 public static final BitSet FOLLOW_STRINGTOK_in_ctfTypeSpecifier3280
= new BitSet(
11739 new long[] { 0x0000200000000002L
});
11740 public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3282
= new BitSet(
11741 new long[] { 0x0000000000000002L
});
11742 public static final BitSet FOLLOW_LCURL_in_ctfBody3320
= new BitSet(
11743 new long[] { 0x094240007FFFFFF0L
, 0x0000000000004090L
});
11744 public static final BitSet FOLLOW_ctfAssignmentExpressionList_in_ctfBody3322
= new BitSet(
11745 new long[] { 0x0000400000000000L
});
11746 public static final BitSet FOLLOW_RCURL_in_ctfBody3325
= new BitSet(
11747 new long[] { 0x0000000000000002L
});
11748 public static final BitSet FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3344
= new BitSet(
11749 new long[] { 0x0000800000000000L
});
11750 public static final BitSet FOLLOW_TERM_in_ctfAssignmentExpressionList3346
= new BitSet(
11751 new long[] { 0x094200007FFFFFF2L
, 0x0000000000004090L
});
11752 public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3381
= new BitSet(
11753 new long[] { 0x0000006000000000L
});
11754 public static final BitSet FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3400
= new BitSet(
11755 new long[] { 0x0942000060170210L
, 0x0000000000004090L
});
11756 public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3404
= new BitSet(
11757 new long[] { 0x0000000000000002L
});
11758 public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3438
= new BitSet(
11759 new long[] { 0x000000001FCDFDE0L
, 0x0000000000004000L
});
11760 public static final BitSet FOLLOW_typeSpecifier_in_ctfAssignmentExpression3443
= new BitSet(
11761 new long[] { 0x0000000000000002L
});
11762 public static final BitSet FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3493
= new BitSet(
11763 new long[] { 0x0001000000000000L
, 0x0000000000004000L
});
11764 public static final BitSet FOLLOW_declaratorList_in_ctfAssignmentExpression3497
= new BitSet(
11765 new long[] { 0x0000000000000002L
});
11766 public static final BitSet FOLLOW_typealiasDecl_in_ctfAssignmentExpression3525
= new BitSet(
11767 new long[] { 0x0000000000000002L
});
11768 public static final BitSet FOLLOW_IDENTIFIER_in_synpred1_CTFParser470
= new BitSet(
11769 new long[] { 0x0000000000000002L
});
11770 public static final BitSet FOLLOW_ctfKeyword_in_synpred2_CTFParser492
= new BitSet(
11771 new long[] { 0x0000000000000002L
});
11772 public static final BitSet FOLLOW_STRING_LITERAL_in_synpred3_CTFParser512
= new BitSet(
11773 new long[] { 0x0000000000000002L
});