1 // $ANTLR 3.5.2 org/eclipse/tracecompass/ctf/parser/CTFParser.g 2015-08-06 19:37:54
3 /*******************************************************************************
4 * Copyright (c) 2010, 2015 Ericsson, Ecole Polytechnique de Montréal and others
6 * All rights reserved. This program and the accompanying materials are
7 * made available under the terms of the Eclipse Public License v1.0 which
8 * accompanies this distribution, and is available at
9 * http://www.eclipse.org/legal/epl-v10.html
12 * Matthew Khouzam - Initial API and implementation
13 * Simon Marchi - Initial API and implementation
14 * Etienne Bergeron - Update to Antlr 3.5 syntax
15 *******************************************************************************/
17 package org
.eclipse
.tracecompass
.ctf
.parser
;
20 import java
.util
.HashSet
;
23 import org
.antlr
.runtime
.*;
24 import java
.util
.Stack
;
25 import java
.util
.List
;
26 import java
.util
.ArrayList
;
28 import java
.util
.HashMap
;
30 import org
.antlr
.runtime
.tree
.*;
33 @SuppressWarnings("all")
34 public class CTFParser
extends Parser
{
35 public static final String
[] tokenNames
= new String
[] {
36 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ALIGNTOK", "ARROW", "ASSIGNMENT",
37 "BACKSLASH", "BOOLTOK", "CHARACTER_LITERAL", "CHARTOK", "CHAR_CONTENT",
38 "CLOCKTOK", "CLOSEBRAC", "COLON", "COMMENT", "COMMENT_CLOSE", "COMMENT_OPEN",
39 "COMPLEXTOK", "CONSTTOK", "DECIMAL_LITERAL", "DIGIT", "DOT", "DOUBLEQUOTE",
40 "DOUBLETOK", "ELIPSES", "ENUMTOK", "ENVTOK", "ESCAPE_SEQUENCE", "EVENTTOK",
41 "FLOATINGPOINTTOK", "FLOATTOK", "GT", "HEXADECIMAL_ESCAPE", "HEX_DIGIT",
42 "HEX_LITERAL", "HEX_PREFIX", "IDENTIFIER", "IMAGINARYTOK", "INFINITYTOK",
43 "INTEGERTOK", "INTEGER_TYPES_SUFFIX", "INTTOK", "LCURL", "LINE_COMMENT",
44 "LONGTOK", "LPAREN", "LT", "NANNUMBERTOK", "NINFINITYTOK", "NONDIGIT",
45 "NONZERO_DIGIT", "OCTAL_ESCAPE", "OCTAL_LITERAL", "OCT_DIGIT", "OCT_PREFIX",
46 "OPENBRAC", "POINTER", "RCURL", "RPAREN", "SEPARATOR", "SHORTTOK", "SIGN",
47 "SIGNEDTOK", "SINGLEQUOTE", "STREAMTOK", "STRINGPREFIX", "STRINGTOK",
48 "STRING_CONTENT", "STRING_LITERAL", "STRUCTTOK", "TERM", "TRACETOK", "TYPEALIASTOK",
49 "TYPEDEFTOK", "TYPE_ASSIGNMENT", "UNICODE_ESCAPE", "UNSIGNEDTOK", "VARIANTTOK",
50 "VOIDTOK", "WS", "ALIGN", "CLOCK", "CTF_EXPRESSION_TYPE", "CTF_EXPRESSION_VAL",
51 "CTF_LEFT", "CTF_RIGHT", "DECLARATION", "DECLARATOR", "ENUM", "ENUM_BODY",
52 "ENUM_CONTAINER_TYPE", "ENUM_ENUMERATOR", "ENUM_NAME", "ENUM_VALUE", "ENUM_VALUE_RANGE",
53 "ENV", "EVENT", "FLOATING_POINT", "INTEGER", "LENGTH", "ROOT", "STREAM",
54 "STRING", "STRUCT", "STRUCT_BODY", "STRUCT_NAME", "SV_DECLARATION", "TRACE",
55 "TYPEALIAS", "TYPEALIAS_ALIAS", "TYPEALIAS_TARGET", "TYPEDEF", "TYPE_DECLARATOR",
56 "TYPE_DECLARATOR_LIST", "TYPE_SPECIFIER_LIST", "UNARY_EXPRESSION_DEC",
57 "UNARY_EXPRESSION_HEX", "UNARY_EXPRESSION_OCT", "UNARY_EXPRESSION_STRING",
58 "UNARY_EXPRESSION_STRING_QUOTES", "VARIANT", "VARIANT_BODY", "VARIANT_NAME",
61 public static final int EOF
=-1;
62 public static final int ALIGNTOK
=4;
63 public static final int ARROW
=5;
64 public static final int ASSIGNMENT
=6;
65 public static final int BACKSLASH
=7;
66 public static final int BOOLTOK
=8;
67 public static final int CHARACTER_LITERAL
=9;
68 public static final int CHARTOK
=10;
69 public static final int CHAR_CONTENT
=11;
70 public static final int CLOCKTOK
=12;
71 public static final int CLOSEBRAC
=13;
72 public static final int COLON
=14;
73 public static final int COMMENT
=15;
74 public static final int COMMENT_CLOSE
=16;
75 public static final int COMMENT_OPEN
=17;
76 public static final int COMPLEXTOK
=18;
77 public static final int CONSTTOK
=19;
78 public static final int DECIMAL_LITERAL
=20;
79 public static final int DIGIT
=21;
80 public static final int DOT
=22;
81 public static final int DOUBLEQUOTE
=23;
82 public static final int DOUBLETOK
=24;
83 public static final int ELIPSES
=25;
84 public static final int ENUMTOK
=26;
85 public static final int ENVTOK
=27;
86 public static final int ESCAPE_SEQUENCE
=28;
87 public static final int EVENTTOK
=29;
88 public static final int FLOATINGPOINTTOK
=30;
89 public static final int FLOATTOK
=31;
90 public static final int GT
=32;
91 public static final int HEXADECIMAL_ESCAPE
=33;
92 public static final int HEX_DIGIT
=34;
93 public static final int HEX_LITERAL
=35;
94 public static final int HEX_PREFIX
=36;
95 public static final int IDENTIFIER
=37;
96 public static final int IMAGINARYTOK
=38;
97 public static final int INFINITYTOK
=39;
98 public static final int INTEGERTOK
=40;
99 public static final int INTEGER_TYPES_SUFFIX
=41;
100 public static final int INTTOK
=42;
101 public static final int LCURL
=43;
102 public static final int LINE_COMMENT
=44;
103 public static final int LONGTOK
=45;
104 public static final int LPAREN
=46;
105 public static final int LT
=47;
106 public static final int NANNUMBERTOK
=48;
107 public static final int NINFINITYTOK
=49;
108 public static final int NONDIGIT
=50;
109 public static final int NONZERO_DIGIT
=51;
110 public static final int OCTAL_ESCAPE
=52;
111 public static final int OCTAL_LITERAL
=53;
112 public static final int OCT_DIGIT
=54;
113 public static final int OCT_PREFIX
=55;
114 public static final int OPENBRAC
=56;
115 public static final int POINTER
=57;
116 public static final int RCURL
=58;
117 public static final int RPAREN
=59;
118 public static final int SEPARATOR
=60;
119 public static final int SHORTTOK
=61;
120 public static final int SIGN
=62;
121 public static final int SIGNEDTOK
=63;
122 public static final int SINGLEQUOTE
=64;
123 public static final int STREAMTOK
=65;
124 public static final int STRINGPREFIX
=66;
125 public static final int STRINGTOK
=67;
126 public static final int STRING_CONTENT
=68;
127 public static final int STRING_LITERAL
=69;
128 public static final int STRUCTTOK
=70;
129 public static final int TERM
=71;
130 public static final int TRACETOK
=72;
131 public static final int TYPEALIASTOK
=73;
132 public static final int TYPEDEFTOK
=74;
133 public static final int TYPE_ASSIGNMENT
=75;
134 public static final int UNICODE_ESCAPE
=76;
135 public static final int UNSIGNEDTOK
=77;
136 public static final int VARIANTTOK
=78;
137 public static final int VOIDTOK
=79;
138 public static final int WS
=80;
139 public static final int ALIGN
=81;
140 public static final int CLOCK
=82;
141 public static final int CTF_EXPRESSION_TYPE
=83;
142 public static final int CTF_EXPRESSION_VAL
=84;
143 public static final int CTF_LEFT
=85;
144 public static final int CTF_RIGHT
=86;
145 public static final int DECLARATION
=87;
146 public static final int DECLARATOR
=88;
147 public static final int ENUM
=89;
148 public static final int ENUM_BODY
=90;
149 public static final int ENUM_CONTAINER_TYPE
=91;
150 public static final int ENUM_ENUMERATOR
=92;
151 public static final int ENUM_NAME
=93;
152 public static final int ENUM_VALUE
=94;
153 public static final int ENUM_VALUE_RANGE
=95;
154 public static final int ENV
=96;
155 public static final int EVENT
=97;
156 public static final int FLOATING_POINT
=98;
157 public static final int INTEGER
=99;
158 public static final int LENGTH
=100;
159 public static final int ROOT
=101;
160 public static final int STREAM
=102;
161 public static final int STRING
=103;
162 public static final int STRUCT
=104;
163 public static final int STRUCT_BODY
=105;
164 public static final int STRUCT_NAME
=106;
165 public static final int SV_DECLARATION
=107;
166 public static final int TRACE
=108;
167 public static final int TYPEALIAS
=109;
168 public static final int TYPEALIAS_ALIAS
=110;
169 public static final int TYPEALIAS_TARGET
=111;
170 public static final int TYPEDEF
=112;
171 public static final int TYPE_DECLARATOR
=113;
172 public static final int TYPE_DECLARATOR_LIST
=114;
173 public static final int TYPE_SPECIFIER_LIST
=115;
174 public static final int UNARY_EXPRESSION_DEC
=116;
175 public static final int UNARY_EXPRESSION_HEX
=117;
176 public static final int UNARY_EXPRESSION_OCT
=118;
177 public static final int UNARY_EXPRESSION_STRING
=119;
178 public static final int UNARY_EXPRESSION_STRING_QUOTES
=120;
179 public static final int VARIANT
=121;
180 public static final int VARIANT_BODY
=122;
181 public static final int VARIANT_NAME
=123;
182 public static final int VARIANT_TAG
=124;
185 public Parser
[] getDelegates() {
186 return new Parser
[] {};
191 protected static class Symbols_scope
{
194 protected Stack
<Symbols_scope
> Symbols_stack
= new Stack
<Symbols_scope
>();
197 public CTFParser(TokenStream input
) {
198 this(input
, new RecognizerSharedState());
200 public CTFParser(TokenStream input
, RecognizerSharedState state
) {
204 protected TreeAdaptor adaptor
= new CommonTreeAdaptor();
206 public void setTreeAdaptor(TreeAdaptor adaptor
) {
207 this.adaptor
= adaptor
;
209 public TreeAdaptor
getTreeAdaptor() {
212 @Override public String
[] getTokenNames() { return CTFParser
.tokenNames
; }
213 @Override public String
getGrammarFileName() { return "org/eclipse/tracecompass/ctf/parser/CTFParser.g"; }
216 public CTFParser(TokenStream input
, boolean verbose
) {
218 this.verbose
= verbose
;
222 * This method is overriden to disable automatic error recovery.
223 * On a mismatched token, it simply re-throw an exception.
226 protected Object
recoverFromMismatchedToken(IntStream input
, int ttype
, BitSet follow
) throws RecognitionException
{
227 throw new MismatchedTokenException(ttype
, input
);
231 * Checks if a given name has been defined has a type.
232 * From: http://www.antlr.org/grammar/1153358328744/C.g
234 * @param name The name to check.
235 * @return True if is is a type, false otherwise.
237 boolean isTypeName(String name
) {
238 for (int i
= Symbols_stack
.size() - 1; i
>= 0; i
--) {
239 Symbols_scope scope
= (Symbols_scope
) Symbols_stack
.get(i
);
240 if (scope
.types
.contains(name
)) {
247 void addTypeName(String name
) {
248 Symbols_stack
.peek().types
.add(name
);
250 debug_print("New type: " + name
+ " " + declaration_stack
);
255 debug_print("typedefOn" + declaration_stack
);
256 declaration_stack
.peek().isTypedef
=true;
260 debug_print("typedefOff" + declaration_stack
);
261 declaration_stack
.peek().isTypedef
=false;
264 boolean inTypedef() {
265 return declaration_stack
.peek().isTypedef
;
268 boolean _inTypealiasAlias
= false;
270 void typealiasAliasOn() {
271 debug_print("typealiasAliasOn");
272 _inTypealiasAlias
= true;
275 void typealiasAliasOff() {
276 debug_print("typealiasAliasOff");
277 _inTypealiasAlias
= false;
280 boolean inTypealiasAlias() {
281 return _inTypealiasAlias
;
284 void debug_print(String str
) {
286 System
.out
.println(str
);
290 /* Prints rule entry and exit while parsing */
291 boolean verbose
= false;
294 public static class parse_return
extends ParserRuleReturnScope
{
297 public CommonTree
getTree() { return tree
; }
301 // $ANTLR start "parse"
302 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:189:1: parse : ( declaration )+ EOF -> ^( ROOT ( declaration )+ ) ;
303 public final CTFParser
.parse_return
parse() throws RecognitionException
{
304 Symbols_stack
.push(new Symbols_scope());
306 CTFParser
.parse_return retval
= new CTFParser
.parse_return();
307 retval
.start
= input
.LT(1);
309 CommonTree root_0
= null;
312 ParserRuleReturnScope declaration1
=null;
314 CommonTree EOF2_tree
=null;
315 RewriteRuleTokenStream stream_EOF
=new RewriteRuleTokenStream(adaptor
,"token EOF");
316 RewriteRuleSubtreeStream stream_declaration
=new RewriteRuleSubtreeStream(adaptor
,"rule declaration");
319 Symbols_stack
.peek().types
= new HashSet
<String
>();
322 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:194:3: ( ( declaration )+ EOF -> ^( ROOT ( declaration )+ ) )
323 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:194:5: ( declaration )+ EOF
325 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:194:5: ( declaration )+
330 int LA1_0
= input
.LA(1);
331 if ( (LA1_0
==BOOLTOK
||LA1_0
==CHARTOK
||(LA1_0
>= COMPLEXTOK
&& LA1_0
<= CONSTTOK
)||LA1_0
==DOUBLETOK
||LA1_0
==ENUMTOK
||(LA1_0
>= FLOATINGPOINTTOK
&& LA1_0
<= FLOATTOK
)||LA1_0
==IMAGINARYTOK
||LA1_0
==INTEGERTOK
||LA1_0
==INTTOK
||LA1_0
==LONGTOK
||LA1_0
==SHORTTOK
||LA1_0
==SIGNEDTOK
||LA1_0
==STRINGTOK
||LA1_0
==STRUCTTOK
||LA1_0
==TYPEDEFTOK
||(LA1_0
>= UNSIGNEDTOK
&& LA1_0
<= VOIDTOK
)) ) {
334 else if ( (LA1_0
==IDENTIFIER
) && (( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) ))) {
337 else if ( (LA1_0
==CLOCKTOK
||LA1_0
==ENVTOK
||LA1_0
==EVENTTOK
||LA1_0
==STREAMTOK
||(LA1_0
>= TRACETOK
&& LA1_0
<= TYPEALIASTOK
)) ) {
343 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:194:5: declaration
345 pushFollow(FOLLOW_declaration_in_parse442
);
346 declaration1
=declaration();
348 if (state
.failed
) return retval
;
349 if ( state
.backtracking
==0 ) stream_declaration
.add(declaration1
.getTree());
354 if ( cnt1
>= 1 ) break loop1
;
355 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
356 EarlyExitException eee
= new EarlyExitException(1, input
);
362 EOF2
=(Token
)match(input
,EOF
,FOLLOW_EOF_in_parse445
); if (state
.failed
) return retval
;
363 if ( state
.backtracking
==0 ) stream_EOF
.add(EOF2
);
366 // elements: declaration
368 // rule labels: retval
369 // token list labels:
372 if ( state
.backtracking
==0 ) {
373 retval
.tree
= root_0
;
374 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
376 root_0
= (CommonTree
)adaptor
.nil();
377 // 194:22: -> ^( ROOT ( declaration )+ )
379 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:194:25: ^( ROOT ( declaration )+ )
381 CommonTree root_1
= (CommonTree
)adaptor
.nil();
382 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ROOT
, "ROOT"), root_1
);
383 if ( !(stream_declaration
.hasNext()) ) {
384 throw new RewriteEarlyExitException();
386 while ( stream_declaration
.hasNext() ) {
387 adaptor
.addChild(root_1
, stream_declaration
.nextTree());
389 stream_declaration
.reset();
391 adaptor
.addChild(root_0
, root_1
);
397 retval
.tree
= root_0
;
402 retval
.stop
= input
.LT(-1);
404 if ( state
.backtracking
==0 ) {
405 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
406 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
410 catch (RecognitionException e
) {
415 // do for sure before leaving
421 // $ANTLR end "parse"
424 public static class numberLiteral_return
extends ParserRuleReturnScope
{
427 public CommonTree
getTree() { return tree
; }
431 // $ANTLR start "numberLiteral"
432 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:197:1: numberLiteral : ( SIGN )* ( HEX_LITERAL -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) ) ;
433 public final CTFParser
.numberLiteral_return
numberLiteral() throws RecognitionException
{
434 CTFParser
.numberLiteral_return retval
= new CTFParser
.numberLiteral_return();
435 retval
.start
= input
.LT(1);
437 CommonTree root_0
= null;
440 Token HEX_LITERAL4
=null;
441 Token DECIMAL_LITERAL5
=null;
442 Token OCTAL_LITERAL6
=null;
444 CommonTree SIGN3_tree
=null;
445 CommonTree HEX_LITERAL4_tree
=null;
446 CommonTree DECIMAL_LITERAL5_tree
=null;
447 CommonTree OCTAL_LITERAL6_tree
=null;
448 RewriteRuleTokenStream stream_OCTAL_LITERAL
=new RewriteRuleTokenStream(adaptor
,"token OCTAL_LITERAL");
449 RewriteRuleTokenStream stream_HEX_LITERAL
=new RewriteRuleTokenStream(adaptor
,"token HEX_LITERAL");
450 RewriteRuleTokenStream stream_SIGN
=new RewriteRuleTokenStream(adaptor
,"token SIGN");
451 RewriteRuleTokenStream stream_DECIMAL_LITERAL
=new RewriteRuleTokenStream(adaptor
,"token DECIMAL_LITERAL");
454 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:198:3: ( ( SIGN )* ( HEX_LITERAL -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) ) )
455 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:198:5: ( SIGN )* ( HEX_LITERAL -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) )
457 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:198:5: ( SIGN )*
461 int LA2_0
= input
.LA(1);
462 if ( (LA2_0
==SIGN
) ) {
468 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:198:5: SIGN
470 SIGN3
=(Token
)match(input
,SIGN
,FOLLOW_SIGN_in_numberLiteral467
); if (state
.failed
) return retval
;
471 if ( state
.backtracking
==0 ) stream_SIGN
.add(SIGN3
);
481 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:199:7: ( HEX_LITERAL -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) )
483 switch ( input
.LA(1) ) {
489 case DECIMAL_LITERAL
:
500 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
501 NoViableAltException nvae
=
502 new NoViableAltException("", 3, 0, input
);
507 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:199:9: HEX_LITERAL
509 HEX_LITERAL4
=(Token
)match(input
,HEX_LITERAL
,FOLLOW_HEX_LITERAL_in_numberLiteral478
); if (state
.failed
) return retval
;
510 if ( state
.backtracking
==0 ) stream_HEX_LITERAL
.add(HEX_LITERAL4
);
513 // elements: SIGN, HEX_LITERAL
515 // rule labels: retval
516 // token list labels:
519 if ( state
.backtracking
==0 ) {
520 retval
.tree
= root_0
;
521 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
523 root_0
= (CommonTree
)adaptor
.nil();
524 // 199:21: -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
526 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:199:24: ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
528 CommonTree root_1
= (CommonTree
)adaptor
.nil();
529 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_HEX
, "UNARY_EXPRESSION_HEX"), root_1
);
530 adaptor
.addChild(root_1
, stream_HEX_LITERAL
.nextNode());
531 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:199:59: ( SIGN )*
532 while ( stream_SIGN
.hasNext() ) {
533 adaptor
.addChild(root_1
, stream_SIGN
.nextNode());
537 adaptor
.addChild(root_0
, root_1
);
543 retval
.tree
= root_0
;
549 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:200:9: DECIMAL_LITERAL
551 DECIMAL_LITERAL5
=(Token
)match(input
,DECIMAL_LITERAL
,FOLLOW_DECIMAL_LITERAL_in_numberLiteral499
); if (state
.failed
) return retval
;
552 if ( state
.backtracking
==0 ) stream_DECIMAL_LITERAL
.add(DECIMAL_LITERAL5
);
555 // elements: SIGN, DECIMAL_LITERAL
557 // rule labels: retval
558 // token list labels:
561 if ( state
.backtracking
==0 ) {
562 retval
.tree
= root_0
;
563 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
565 root_0
= (CommonTree
)adaptor
.nil();
566 // 200:25: -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
568 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:200:28: ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
570 CommonTree root_1
= (CommonTree
)adaptor
.nil();
571 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_DEC
, "UNARY_EXPRESSION_DEC"), root_1
);
572 adaptor
.addChild(root_1
, stream_DECIMAL_LITERAL
.nextNode());
573 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:200:67: ( SIGN )*
574 while ( stream_SIGN
.hasNext() ) {
575 adaptor
.addChild(root_1
, stream_SIGN
.nextNode());
579 adaptor
.addChild(root_0
, root_1
);
585 retval
.tree
= root_0
;
591 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:201:9: OCTAL_LITERAL
593 OCTAL_LITERAL6
=(Token
)match(input
,OCTAL_LITERAL
,FOLLOW_OCTAL_LITERAL_in_numberLiteral520
); if (state
.failed
) return retval
;
594 if ( state
.backtracking
==0 ) stream_OCTAL_LITERAL
.add(OCTAL_LITERAL6
);
597 // elements: OCTAL_LITERAL, SIGN
599 // rule labels: retval
600 // token list labels:
603 if ( state
.backtracking
==0 ) {
604 retval
.tree
= root_0
;
605 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
607 root_0
= (CommonTree
)adaptor
.nil();
608 // 201:23: -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
610 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:201:26: ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
612 CommonTree root_1
= (CommonTree
)adaptor
.nil();
613 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_OCT
, "UNARY_EXPRESSION_OCT"), root_1
);
614 adaptor
.addChild(root_1
, stream_OCTAL_LITERAL
.nextNode());
615 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:201:63: ( SIGN )*
616 while ( stream_SIGN
.hasNext() ) {
617 adaptor
.addChild(root_1
, stream_SIGN
.nextNode());
621 adaptor
.addChild(root_0
, root_1
);
627 retval
.tree
= root_0
;
637 retval
.stop
= input
.LT(-1);
639 if ( state
.backtracking
==0 ) {
640 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
641 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
645 catch (RecognitionException e
) {
650 // do for sure before leaving
654 // $ANTLR end "numberLiteral"
657 public static class primaryExpression_return
extends ParserRuleReturnScope
{
660 public CommonTree
getTree() { return tree
; }
664 // $ANTLR start "primaryExpression"
665 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:205:1: primaryExpression : ( ( IDENTIFIER )=> IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=> ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | ( STRING_LITERAL )=> STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | numberLiteral | enumConstant | CHARACTER_LITERAL );
666 public final CTFParser
.primaryExpression_return
primaryExpression() throws RecognitionException
{
667 CTFParser
.primaryExpression_return retval
= new CTFParser
.primaryExpression_return();
668 retval
.start
= input
.LT(1);
670 CommonTree root_0
= null;
672 Token IDENTIFIER7
=null;
673 Token STRING_LITERAL9
=null;
674 Token CHARACTER_LITERAL12
=null;
675 ParserRuleReturnScope ctfKeyword8
=null;
676 ParserRuleReturnScope numberLiteral10
=null;
677 ParserRuleReturnScope enumConstant11
=null;
679 CommonTree IDENTIFIER7_tree
=null;
680 CommonTree STRING_LITERAL9_tree
=null;
681 CommonTree CHARACTER_LITERAL12_tree
=null;
682 RewriteRuleTokenStream stream_STRING_LITERAL
=new RewriteRuleTokenStream(adaptor
,"token STRING_LITERAL");
683 RewriteRuleTokenStream stream_IDENTIFIER
=new RewriteRuleTokenStream(adaptor
,"token IDENTIFIER");
684 RewriteRuleSubtreeStream stream_ctfKeyword
=new RewriteRuleSubtreeStream(adaptor
,"rule ctfKeyword");
687 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:206:3: ( ( IDENTIFIER )=> IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=> ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | ( STRING_LITERAL )=> STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | numberLiteral | enumConstant | CHARACTER_LITERAL )
689 switch ( input
.LA(1) ) {
692 int LA4_1
= input
.LA(2);
693 if ( (synpred1_CTFParser()) ) {
707 int LA4_2
= input
.LA(2);
708 if ( (synpred2_CTFParser()) ) {
719 int LA4_3
= input
.LA(2);
720 if ( (synpred3_CTFParser()) ) {
729 case DECIMAL_LITERAL
:
737 case CHARACTER_LITERAL
:
743 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
744 NoViableAltException nvae
=
745 new NoViableAltException("", 4, 0, input
);
750 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:206:5: ( IDENTIFIER )=> IDENTIFIER
752 IDENTIFIER7
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_primaryExpression558
); if (state
.failed
) return retval
;
753 if ( state
.backtracking
==0 ) stream_IDENTIFIER
.add(IDENTIFIER7
);
756 // elements: IDENTIFIER
758 // rule labels: retval
759 // token list labels:
762 if ( state
.backtracking
==0 ) {
763 retval
.tree
= root_0
;
764 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
766 root_0
= (CommonTree
)adaptor
.nil();
767 // 207:7: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
769 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:207:10: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
771 CommonTree root_1
= (CommonTree
)adaptor
.nil();
772 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_STRING
, "UNARY_EXPRESSION_STRING"), root_1
);
773 adaptor
.addChild(root_1
, stream_IDENTIFIER
.nextNode());
774 adaptor
.addChild(root_0
, root_1
);
780 retval
.tree
= root_0
;
786 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:208:5: ( ctfKeyword )=> ctfKeyword
788 pushFollow(FOLLOW_ctfKeyword_in_primaryExpression584
);
789 ctfKeyword8
=ctfKeyword();
791 if (state
.failed
) return retval
;
792 if ( state
.backtracking
==0 ) stream_ctfKeyword
.add(ctfKeyword8
.getTree());
794 // elements: ctfKeyword
796 // rule labels: retval
797 // token list labels:
800 if ( state
.backtracking
==0 ) {
801 retval
.tree
= root_0
;
802 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
804 root_0
= (CommonTree
)adaptor
.nil();
805 // 208:32: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
807 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:208:35: ^( UNARY_EXPRESSION_STRING ctfKeyword )
809 CommonTree root_1
= (CommonTree
)adaptor
.nil();
810 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_STRING
, "UNARY_EXPRESSION_STRING"), root_1
);
811 adaptor
.addChild(root_1
, stream_ctfKeyword
.nextTree());
812 adaptor
.addChild(root_0
, root_1
);
818 retval
.tree
= root_0
;
824 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:209:5: ( STRING_LITERAL )=> STRING_LITERAL
826 STRING_LITERAL9
=(Token
)match(input
,STRING_LITERAL
,FOLLOW_STRING_LITERAL_in_primaryExpression604
); if (state
.failed
) return retval
;
827 if ( state
.backtracking
==0 ) stream_STRING_LITERAL
.add(STRING_LITERAL9
);
830 // elements: STRING_LITERAL
832 // rule labels: retval
833 // token list labels:
836 if ( state
.backtracking
==0 ) {
837 retval
.tree
= root_0
;
838 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
840 root_0
= (CommonTree
)adaptor
.nil();
841 // 210:7: -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
843 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:210:10: ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
845 CommonTree root_1
= (CommonTree
)adaptor
.nil();
846 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_STRING_QUOTES
, "UNARY_EXPRESSION_STRING_QUOTES"), root_1
);
847 adaptor
.addChild(root_1
, stream_STRING_LITERAL
.nextNode());
848 adaptor
.addChild(root_0
, root_1
);
854 retval
.tree
= root_0
;
860 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:212:5: numberLiteral
862 root_0
= (CommonTree
)adaptor
.nil();
865 pushFollow(FOLLOW_numberLiteral_in_primaryExpression629
);
866 numberLiteral10
=numberLiteral();
868 if (state
.failed
) return retval
;
869 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, numberLiteral10
.getTree());
874 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:213:5: enumConstant
876 root_0
= (CommonTree
)adaptor
.nil();
879 pushFollow(FOLLOW_enumConstant_in_primaryExpression635
);
880 enumConstant11
=enumConstant();
882 if (state
.failed
) return retval
;
883 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, enumConstant11
.getTree());
888 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:214:5: CHARACTER_LITERAL
890 root_0
= (CommonTree
)adaptor
.nil();
893 CHARACTER_LITERAL12
=(Token
)match(input
,CHARACTER_LITERAL
,FOLLOW_CHARACTER_LITERAL_in_primaryExpression641
); if (state
.failed
) return retval
;
894 if ( state
.backtracking
==0 ) {
895 CHARACTER_LITERAL12_tree
= (CommonTree
)adaptor
.create(CHARACTER_LITERAL12
);
896 adaptor
.addChild(root_0
, CHARACTER_LITERAL12_tree
);
903 retval
.stop
= input
.LT(-1);
905 if ( state
.backtracking
==0 ) {
906 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
907 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
911 catch (RecognitionException e
) {
916 // do for sure before leaving
920 // $ANTLR end "primaryExpression"
923 public static class postfixExpressionSuffix_return
extends ParserRuleReturnScope
{
926 public CommonTree
getTree() { return tree
; }
930 // $ANTLR start "postfixExpressionSuffix"
931 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:217:1: postfixExpressionSuffix : ( OPENBRAC unaryExpression CLOSEBRAC !| (ref= DOT |ref= ARROW ) IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) );
932 public final CTFParser
.postfixExpressionSuffix_return
postfixExpressionSuffix() throws RecognitionException
{
933 CTFParser
.postfixExpressionSuffix_return retval
= new CTFParser
.postfixExpressionSuffix_return();
934 retval
.start
= input
.LT(1);
936 CommonTree root_0
= null;
939 Token OPENBRAC13
=null;
940 Token CLOSEBRAC15
=null;
941 Token IDENTIFIER16
=null;
942 ParserRuleReturnScope unaryExpression14
=null;
944 CommonTree ref_tree
=null;
945 CommonTree OPENBRAC13_tree
=null;
946 CommonTree CLOSEBRAC15_tree
=null;
947 CommonTree IDENTIFIER16_tree
=null;
948 RewriteRuleTokenStream stream_ARROW
=new RewriteRuleTokenStream(adaptor
,"token ARROW");
949 RewriteRuleTokenStream stream_DOT
=new RewriteRuleTokenStream(adaptor
,"token DOT");
950 RewriteRuleTokenStream stream_IDENTIFIER
=new RewriteRuleTokenStream(adaptor
,"token IDENTIFIER");
953 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:218:3: ( OPENBRAC unaryExpression CLOSEBRAC !| (ref= DOT |ref= ARROW ) IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) )
955 int LA6_0
= input
.LA(1);
956 if ( (LA6_0
==OPENBRAC
) ) {
959 else if ( (LA6_0
==ARROW
||LA6_0
==DOT
) ) {
964 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
965 NoViableAltException nvae
=
966 new NoViableAltException("", 6, 0, input
);
972 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:218:5: OPENBRAC unaryExpression CLOSEBRAC !
974 root_0
= (CommonTree
)adaptor
.nil();
977 OPENBRAC13
=(Token
)match(input
,OPENBRAC
,FOLLOW_OPENBRAC_in_postfixExpressionSuffix654
); if (state
.failed
) return retval
;
978 if ( state
.backtracking
==0 ) {
979 OPENBRAC13_tree
= (CommonTree
)adaptor
.create(OPENBRAC13
);
980 adaptor
.addChild(root_0
, OPENBRAC13_tree
);
983 pushFollow(FOLLOW_unaryExpression_in_postfixExpressionSuffix656
);
984 unaryExpression14
=unaryExpression();
986 if (state
.failed
) return retval
;
987 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, unaryExpression14
.getTree());
989 CLOSEBRAC15
=(Token
)match(input
,CLOSEBRAC
,FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix658
); if (state
.failed
) return retval
;
993 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:219:5: (ref= DOT |ref= ARROW ) IDENTIFIER
995 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:219:5: (ref= DOT |ref= ARROW )
997 int LA5_0
= input
.LA(1);
998 if ( (LA5_0
==DOT
) ) {
1001 else if ( (LA5_0
==ARROW
) ) {
1006 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
1007 NoViableAltException nvae
=
1008 new NoViableAltException("", 5, 0, input
);
1014 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:219:6: ref= DOT
1016 ref
=(Token
)match(input
,DOT
,FOLLOW_DOT_in_postfixExpressionSuffix668
); if (state
.failed
) return retval
;
1017 if ( state
.backtracking
==0 ) stream_DOT
.add(ref
);
1022 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:219:16: ref= ARROW
1024 ref
=(Token
)match(input
,ARROW
,FOLLOW_ARROW_in_postfixExpressionSuffix674
); if (state
.failed
) return retval
;
1025 if ( state
.backtracking
==0 ) stream_ARROW
.add(ref
);
1032 IDENTIFIER16
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_postfixExpressionSuffix677
); if (state
.failed
) return retval
;
1033 if ( state
.backtracking
==0 ) stream_IDENTIFIER
.add(IDENTIFIER16
);
1036 // elements: IDENTIFIER, ref
1037 // token labels: ref
1038 // rule labels: retval
1039 // token list labels:
1040 // rule list labels:
1042 if ( state
.backtracking
==0 ) {
1043 retval
.tree
= root_0
;
1044 RewriteRuleTokenStream stream_ref
=new RewriteRuleTokenStream(adaptor
,"token ref",ref
);
1045 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
1047 root_0
= (CommonTree
)adaptor
.nil();
1048 // 220:7: -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) )
1050 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:220:10: ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) )
1052 CommonTree root_1
= (CommonTree
)adaptor
.nil();
1053 root_1
= (CommonTree
)adaptor
.becomeRoot(stream_ref
.nextNode(), root_1
);
1054 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:220:17: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
1056 CommonTree root_2
= (CommonTree
)adaptor
.nil();
1057 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_STRING
, "UNARY_EXPRESSION_STRING"), root_2
);
1058 adaptor
.addChild(root_2
, stream_IDENTIFIER
.nextNode());
1059 adaptor
.addChild(root_1
, root_2
);
1062 adaptor
.addChild(root_0
, root_1
);
1068 retval
.tree
= root_0
;
1075 retval
.stop
= input
.LT(-1);
1077 if ( state
.backtracking
==0 ) {
1078 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
1079 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
1083 catch (RecognitionException e
) {
1088 // do for sure before leaving
1092 // $ANTLR end "postfixExpressionSuffix"
1095 public static class postfixCtfExpression_return
extends ParserRuleReturnScope
{
1098 public CommonTree
getTree() { return tree
; }
1102 // $ANTLR start "postfixCtfExpression"
1103 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:223:1: postfixCtfExpression : (ref= DOT ) ctfSpecifierHead -> ^( $ref ^( UNARY_EXPRESSION_STRING ctfSpecifierHead ) ) ;
1104 public final CTFParser
.postfixCtfExpression_return
postfixCtfExpression() throws RecognitionException
{
1105 CTFParser
.postfixCtfExpression_return retval
= new CTFParser
.postfixCtfExpression_return();
1106 retval
.start
= input
.LT(1);
1108 CommonTree root_0
= null;
1111 ParserRuleReturnScope ctfSpecifierHead17
=null;
1113 CommonTree ref_tree
=null;
1114 RewriteRuleTokenStream stream_DOT
=new RewriteRuleTokenStream(adaptor
,"token DOT");
1115 RewriteRuleSubtreeStream stream_ctfSpecifierHead
=new RewriteRuleSubtreeStream(adaptor
,"rule ctfSpecifierHead");
1118 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:224:3: ( (ref= DOT ) ctfSpecifierHead -> ^( $ref ^( UNARY_EXPRESSION_STRING ctfSpecifierHead ) ) )
1119 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:224:5: (ref= DOT ) ctfSpecifierHead
1121 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:224:5: (ref= DOT )
1122 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:224:6: ref= DOT
1124 ref
=(Token
)match(input
,DOT
,FOLLOW_DOT_in_postfixCtfExpression712
); if (state
.failed
) return retval
;
1125 if ( state
.backtracking
==0 ) stream_DOT
.add(ref
);
1129 pushFollow(FOLLOW_ctfSpecifierHead_in_postfixCtfExpression715
);
1130 ctfSpecifierHead17
=ctfSpecifierHead();
1132 if (state
.failed
) return retval
;
1133 if ( state
.backtracking
==0 ) stream_ctfSpecifierHead
.add(ctfSpecifierHead17
.getTree());
1135 // elements: ref, ctfSpecifierHead
1136 // token labels: ref
1137 // rule labels: retval
1138 // token list labels:
1139 // rule list labels:
1141 if ( state
.backtracking
==0 ) {
1142 retval
.tree
= root_0
;
1143 RewriteRuleTokenStream stream_ref
=new RewriteRuleTokenStream(adaptor
,"token ref",ref
);
1144 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
1146 root_0
= (CommonTree
)adaptor
.nil();
1147 // 225:7: -> ^( $ref ^( UNARY_EXPRESSION_STRING ctfSpecifierHead ) )
1149 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:225:10: ^( $ref ^( UNARY_EXPRESSION_STRING ctfSpecifierHead ) )
1151 CommonTree root_1
= (CommonTree
)adaptor
.nil();
1152 root_1
= (CommonTree
)adaptor
.becomeRoot(stream_ref
.nextNode(), root_1
);
1153 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:225:17: ^( UNARY_EXPRESSION_STRING ctfSpecifierHead )
1155 CommonTree root_2
= (CommonTree
)adaptor
.nil();
1156 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_STRING
, "UNARY_EXPRESSION_STRING"), root_2
);
1157 adaptor
.addChild(root_2
, stream_ctfSpecifierHead
.nextTree());
1158 adaptor
.addChild(root_1
, root_2
);
1161 adaptor
.addChild(root_0
, root_1
);
1167 retval
.tree
= root_0
;
1172 retval
.stop
= input
.LT(-1);
1174 if ( state
.backtracking
==0 ) {
1175 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
1176 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
1180 catch (RecognitionException e
) {
1185 // do for sure before leaving
1189 // $ANTLR end "postfixCtfExpression"
1192 public static class postfixExpression_return
extends ParserRuleReturnScope
{
1195 public CommonTree
getTree() { return tree
; }
1199 // $ANTLR start "postfixExpression"
1200 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:228:1: postfixExpression : ( ( primaryExpression ( postfixExpressionSuffix )* ) | ( ctfSpecifierHead ( postfixCtfExpression )* ( postfixExpressionSuffix )+ ) );
1201 public final CTFParser
.postfixExpression_return
postfixExpression() throws RecognitionException
{
1202 CTFParser
.postfixExpression_return retval
= new CTFParser
.postfixExpression_return();
1203 retval
.start
= input
.LT(1);
1205 CommonTree root_0
= null;
1207 ParserRuleReturnScope primaryExpression18
=null;
1208 ParserRuleReturnScope postfixExpressionSuffix19
=null;
1209 ParserRuleReturnScope ctfSpecifierHead20
=null;
1210 ParserRuleReturnScope postfixCtfExpression21
=null;
1211 ParserRuleReturnScope postfixExpressionSuffix22
=null;
1215 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:3: ( ( primaryExpression ( postfixExpressionSuffix )* ) | ( ctfSpecifierHead ( postfixCtfExpression )* ( postfixExpressionSuffix )+ ) )
1217 switch ( input
.LA(1) ) {
1219 case CHARACTER_LITERAL
:
1220 case DECIMAL_LITERAL
:
1227 case STRING_LITERAL
:
1246 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
1247 NoViableAltException nvae
=
1248 new NoViableAltException("", 10, 0, input
);
1253 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:5: ( primaryExpression ( postfixExpressionSuffix )* )
1255 root_0
= (CommonTree
)adaptor
.nil();
1258 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:5: ( primaryExpression ( postfixExpressionSuffix )* )
1259 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:6: primaryExpression ( postfixExpressionSuffix )*
1261 pushFollow(FOLLOW_primaryExpression_in_postfixExpression748
);
1262 primaryExpression18
=primaryExpression();
1264 if (state
.failed
) return retval
;
1265 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, primaryExpression18
.getTree());
1267 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:24: ( postfixExpressionSuffix )*
1271 int LA7_0
= input
.LA(1);
1272 if ( (LA7_0
==ARROW
||LA7_0
==DOT
||LA7_0
==OPENBRAC
) ) {
1278 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:24: postfixExpressionSuffix
1280 pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression750
);
1281 postfixExpressionSuffix19
=postfixExpressionSuffix();
1283 if (state
.failed
) return retval
;
1284 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, postfixExpressionSuffix19
.getTree());
1299 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:5: ( ctfSpecifierHead ( postfixCtfExpression )* ( postfixExpressionSuffix )+ )
1301 root_0
= (CommonTree
)adaptor
.nil();
1304 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:5: ( ctfSpecifierHead ( postfixCtfExpression )* ( postfixExpressionSuffix )+ )
1305 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:6: ctfSpecifierHead ( postfixCtfExpression )* ( postfixExpressionSuffix )+
1307 pushFollow(FOLLOW_ctfSpecifierHead_in_postfixExpression759
);
1308 ctfSpecifierHead20
=ctfSpecifierHead();
1310 if (state
.failed
) return retval
;
1311 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, ctfSpecifierHead20
.getTree());
1313 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:23: ( postfixCtfExpression )*
1317 int LA8_0
= input
.LA(1);
1318 if ( (LA8_0
==DOT
) ) {
1319 int LA8_2
= input
.LA(2);
1320 if ( (LA8_2
==CLOCKTOK
||LA8_2
==ENVTOK
||LA8_2
==EVENTTOK
||LA8_2
==STREAMTOK
||LA8_2
==TRACETOK
) ) {
1328 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:23: postfixCtfExpression
1330 pushFollow(FOLLOW_postfixCtfExpression_in_postfixExpression761
);
1331 postfixCtfExpression21
=postfixCtfExpression();
1333 if (state
.failed
) return retval
;
1334 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, postfixCtfExpression21
.getTree());
1344 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:45: ( postfixExpressionSuffix )+
1349 int LA9_0
= input
.LA(1);
1350 if ( (LA9_0
==ARROW
||LA9_0
==DOT
||LA9_0
==OPENBRAC
) ) {
1356 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:45: postfixExpressionSuffix
1358 pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression764
);
1359 postfixExpressionSuffix22
=postfixExpressionSuffix();
1361 if (state
.failed
) return retval
;
1362 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, postfixExpressionSuffix22
.getTree());
1368 if ( cnt9
>= 1 ) break loop9
;
1369 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
1370 EarlyExitException eee
= new EarlyExitException(9, input
);
1382 retval
.stop
= input
.LT(-1);
1384 if ( state
.backtracking
==0 ) {
1385 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
1386 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
1390 catch (RecognitionException e
) {
1395 // do for sure before leaving
1399 // $ANTLR end "postfixExpression"
1402 public static class unaryExpression_return
extends ParserRuleReturnScope
{
1405 public CommonTree
getTree() { return tree
; }
1409 // $ANTLR start "unaryExpression"
1410 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:233:1: unaryExpression : postfixExpression ;
1411 public final CTFParser
.unaryExpression_return
unaryExpression() throws RecognitionException
{
1412 CTFParser
.unaryExpression_return retval
= new CTFParser
.unaryExpression_return();
1413 retval
.start
= input
.LT(1);
1415 CommonTree root_0
= null;
1417 ParserRuleReturnScope postfixExpression23
=null;
1421 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:234:3: ( postfixExpression )
1422 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:234:5: postfixExpression
1424 root_0
= (CommonTree
)adaptor
.nil();
1427 pushFollow(FOLLOW_postfixExpression_in_unaryExpression780
);
1428 postfixExpression23
=postfixExpression();
1430 if (state
.failed
) return retval
;
1431 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, postfixExpression23
.getTree());
1435 retval
.stop
= input
.LT(-1);
1437 if ( state
.backtracking
==0 ) {
1438 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
1439 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
1443 catch (RecognitionException e
) {
1448 // do for sure before leaving
1452 // $ANTLR end "unaryExpression"
1455 public static class enumConstant_return
extends ParserRuleReturnScope
{
1458 public CommonTree
getTree() { return tree
; }
1462 // $ANTLR start "enumConstant"
1463 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:238:1: enumConstant : ( STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) );
1464 public final CTFParser
.enumConstant_return
enumConstant() throws RecognitionException
{
1465 CTFParser
.enumConstant_return retval
= new CTFParser
.enumConstant_return();
1466 retval
.start
= input
.LT(1);
1468 CommonTree root_0
= null;
1470 Token STRING_LITERAL24
=null;
1471 Token IDENTIFIER25
=null;
1472 ParserRuleReturnScope ctfKeyword26
=null;
1474 CommonTree STRING_LITERAL24_tree
=null;
1475 CommonTree IDENTIFIER25_tree
=null;
1476 RewriteRuleTokenStream stream_STRING_LITERAL
=new RewriteRuleTokenStream(adaptor
,"token STRING_LITERAL");
1477 RewriteRuleTokenStream stream_IDENTIFIER
=new RewriteRuleTokenStream(adaptor
,"token IDENTIFIER");
1478 RewriteRuleSubtreeStream stream_ctfKeyword
=new RewriteRuleSubtreeStream(adaptor
,"rule ctfKeyword");
1481 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:239:3: ( STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) )
1483 switch ( input
.LA(1) ) {
1484 case STRING_LITERAL
:
1503 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
1504 NoViableAltException nvae
=
1505 new NoViableAltException("", 11, 0, input
);
1510 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:239:5: STRING_LITERAL
1512 STRING_LITERAL24
=(Token
)match(input
,STRING_LITERAL
,FOLLOW_STRING_LITERAL_in_enumConstant797
); if (state
.failed
) return retval
;
1513 if ( state
.backtracking
==0 ) stream_STRING_LITERAL
.add(STRING_LITERAL24
);
1516 // elements: STRING_LITERAL
1518 // rule labels: retval
1519 // token list labels:
1520 // rule list labels:
1522 if ( state
.backtracking
==0 ) {
1523 retval
.tree
= root_0
;
1524 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
1526 root_0
= (CommonTree
)adaptor
.nil();
1527 // 239:20: -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
1529 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:239:23: ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
1531 CommonTree root_1
= (CommonTree
)adaptor
.nil();
1532 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_STRING_QUOTES
, "UNARY_EXPRESSION_STRING_QUOTES"), root_1
);
1533 adaptor
.addChild(root_1
, stream_STRING_LITERAL
.nextNode());
1534 adaptor
.addChild(root_0
, root_1
);
1540 retval
.tree
= root_0
;
1546 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:240:5: IDENTIFIER
1548 IDENTIFIER25
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_enumConstant811
); if (state
.failed
) return retval
;
1549 if ( state
.backtracking
==0 ) stream_IDENTIFIER
.add(IDENTIFIER25
);
1552 // elements: IDENTIFIER
1554 // rule labels: retval
1555 // token list labels:
1556 // rule list labels:
1558 if ( state
.backtracking
==0 ) {
1559 retval
.tree
= root_0
;
1560 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
1562 root_0
= (CommonTree
)adaptor
.nil();
1563 // 240:16: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
1565 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:240:19: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
1567 CommonTree root_1
= (CommonTree
)adaptor
.nil();
1568 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_STRING
, "UNARY_EXPRESSION_STRING"), root_1
);
1569 adaptor
.addChild(root_1
, stream_IDENTIFIER
.nextNode());
1570 adaptor
.addChild(root_0
, root_1
);
1576 retval
.tree
= root_0
;
1582 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:241:5: ctfKeyword
1584 pushFollow(FOLLOW_ctfKeyword_in_enumConstant825
);
1585 ctfKeyword26
=ctfKeyword();
1587 if (state
.failed
) return retval
;
1588 if ( state
.backtracking
==0 ) stream_ctfKeyword
.add(ctfKeyword26
.getTree());
1590 // elements: ctfKeyword
1592 // rule labels: retval
1593 // token list labels:
1594 // rule list labels:
1596 if ( state
.backtracking
==0 ) {
1597 retval
.tree
= root_0
;
1598 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
1600 root_0
= (CommonTree
)adaptor
.nil();
1601 // 241:16: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
1603 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:241:19: ^( UNARY_EXPRESSION_STRING ctfKeyword )
1605 CommonTree root_1
= (CommonTree
)adaptor
.nil();
1606 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(UNARY_EXPRESSION_STRING
, "UNARY_EXPRESSION_STRING"), root_1
);
1607 adaptor
.addChild(root_1
, stream_ctfKeyword
.nextTree());
1608 adaptor
.addChild(root_0
, root_1
);
1614 retval
.tree
= root_0
;
1621 retval
.stop
= input
.LT(-1);
1623 if ( state
.backtracking
==0 ) {
1624 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
1625 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
1629 catch (RecognitionException e
) {
1634 // do for sure before leaving
1638 // $ANTLR end "enumConstant"
1641 protected static class declaration_scope
{
1644 protected Stack
<declaration_scope
> declaration_stack
= new Stack
<declaration_scope
>();
1646 public static class declaration_return
extends ParserRuleReturnScope
{
1649 public CommonTree
getTree() { return tree
; }
1653 // $ANTLR start "declaration"
1654 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:246:1: declaration : ( declarationSpecifiers ( declaratorList )? TERM -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) ) -> ^( DECLARATION declarationSpecifiers ( declaratorList )? ) | ctfSpecifier TERM !);
1655 public final CTFParser
.declaration_return
declaration() throws RecognitionException
{
1656 declaration_stack
.push(new declaration_scope());
1657 CTFParser
.declaration_return retval
= new CTFParser
.declaration_return();
1658 retval
.start
= input
.LT(1);
1660 CommonTree root_0
= null;
1664 ParserRuleReturnScope declarationSpecifiers27
=null;
1665 ParserRuleReturnScope declaratorList28
=null;
1666 ParserRuleReturnScope ctfSpecifier30
=null;
1668 CommonTree TERM29_tree
=null;
1669 CommonTree TERM31_tree
=null;
1670 RewriteRuleTokenStream stream_TERM
=new RewriteRuleTokenStream(adaptor
,"token TERM");
1671 RewriteRuleSubtreeStream stream_declaratorList
=new RewriteRuleSubtreeStream(adaptor
,"rule declaratorList");
1672 RewriteRuleSubtreeStream stream_declarationSpecifiers
=new RewriteRuleSubtreeStream(adaptor
,"rule declarationSpecifiers");
1678 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:253:3: ( declarationSpecifiers ( declaratorList )? TERM -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) ) -> ^( DECLARATION declarationSpecifiers ( declaratorList )? ) | ctfSpecifier TERM !)
1680 int LA13_0
= input
.LA(1);
1681 if ( (LA13_0
==BOOLTOK
||LA13_0
==CHARTOK
||(LA13_0
>= COMPLEXTOK
&& LA13_0
<= CONSTTOK
)||LA13_0
==DOUBLETOK
||LA13_0
==ENUMTOK
||(LA13_0
>= FLOATINGPOINTTOK
&& LA13_0
<= FLOATTOK
)||LA13_0
==IMAGINARYTOK
||LA13_0
==INTEGERTOK
||LA13_0
==INTTOK
||LA13_0
==LONGTOK
||LA13_0
==SHORTTOK
||LA13_0
==SIGNEDTOK
||LA13_0
==STRINGTOK
||LA13_0
==STRUCTTOK
||LA13_0
==TYPEDEFTOK
||(LA13_0
>= UNSIGNEDTOK
&& LA13_0
<= VOIDTOK
)) ) {
1684 else if ( (LA13_0
==IDENTIFIER
) && (( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) ))) {
1687 else if ( (LA13_0
==CLOCKTOK
||LA13_0
==ENVTOK
||LA13_0
==EVENTTOK
||LA13_0
==STREAMTOK
||(LA13_0
>= TRACETOK
&& LA13_0
<= TYPEALIASTOK
)) ) {
1692 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
1693 NoViableAltException nvae
=
1694 new NoViableAltException("", 13, 0, input
);
1700 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:253:5: declarationSpecifiers ( declaratorList )? TERM
1702 pushFollow(FOLLOW_declarationSpecifiers_in_declaration856
);
1703 declarationSpecifiers27
=declarationSpecifiers();
1705 if (state
.failed
) return retval
;
1706 if ( state
.backtracking
==0 ) stream_declarationSpecifiers
.add(declarationSpecifiers27
.getTree());
1707 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:253:27: ( declaratorList )?
1709 int LA12_0
= input
.LA(1);
1710 if ( (LA12_0
==IDENTIFIER
||LA12_0
==POINTER
) ) {
1715 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:253:27: declaratorList
1717 pushFollow(FOLLOW_declaratorList_in_declaration858
);
1718 declaratorList28
=declaratorList();
1720 if (state
.failed
) return retval
;
1721 if ( state
.backtracking
==0 ) stream_declaratorList
.add(declaratorList28
.getTree());
1727 TERM29
=(Token
)match(input
,TERM
,FOLLOW_TERM_in_declaration861
); if (state
.failed
) return retval
;
1728 if ( state
.backtracking
==0 ) stream_TERM
.add(TERM29
);
1731 // elements: declarationSpecifiers, declaratorList, declarationSpecifiers, declaratorList
1733 // rule labels: retval
1734 // token list labels:
1735 // rule list labels:
1737 if ( state
.backtracking
==0 ) {
1738 retval
.tree
= root_0
;
1739 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
1741 root_0
= (CommonTree
)adaptor
.nil();
1742 // 256:7: -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) )
1744 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:257:10: ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) )
1746 CommonTree root_1
= (CommonTree
)adaptor
.nil();
1747 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(DECLARATION
, "DECLARATION"), root_1
);
1748 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:257:24: ^( TYPEDEF declaratorList declarationSpecifiers )
1750 CommonTree root_2
= (CommonTree
)adaptor
.nil();
1751 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPEDEF
, "TYPEDEF"), root_2
);
1752 adaptor
.addChild(root_2
, stream_declaratorList
.nextTree());
1753 adaptor
.addChild(root_2
, stream_declarationSpecifiers
.nextTree());
1754 adaptor
.addChild(root_1
, root_2
);
1757 adaptor
.addChild(root_0
, root_1
);
1762 else // 258:7: -> ^( DECLARATION declarationSpecifiers ( declaratorList )? )
1764 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:258:10: ^( DECLARATION declarationSpecifiers ( declaratorList )? )
1766 CommonTree root_1
= (CommonTree
)adaptor
.nil();
1767 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(DECLARATION
, "DECLARATION"), root_1
);
1768 adaptor
.addChild(root_1
, stream_declarationSpecifiers
.nextTree());
1769 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:258:46: ( declaratorList )?
1770 if ( stream_declaratorList
.hasNext() ) {
1771 adaptor
.addChild(root_1
, stream_declaratorList
.nextTree());
1773 stream_declaratorList
.reset();
1775 adaptor
.addChild(root_0
, root_1
);
1781 retval
.tree
= root_0
;
1787 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:259:5: ctfSpecifier TERM !
1789 root_0
= (CommonTree
)adaptor
.nil();
1792 pushFollow(FOLLOW_ctfSpecifier_in_declaration929
);
1793 ctfSpecifier30
=ctfSpecifier();
1795 if (state
.failed
) return retval
;
1796 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, ctfSpecifier30
.getTree());
1798 TERM31
=(Token
)match(input
,TERM
,FOLLOW_TERM_in_declaration931
); if (state
.failed
) return retval
;
1803 retval
.stop
= input
.LT(-1);
1805 if ( state
.backtracking
==0 ) {
1806 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
1807 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
1811 catch (RecognitionException e
) {
1816 // do for sure before leaving
1817 declaration_stack
.pop();
1821 // $ANTLR end "declaration"
1824 public static class declarationSpecifiers_return
extends ParserRuleReturnScope
{
1827 public CommonTree
getTree() { return tree
; }
1831 // $ANTLR start "declarationSpecifiers"
1832 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:262:1: declarationSpecifiers : ( storageClassSpecifier | typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
1833 public final CTFParser
.declarationSpecifiers_return
declarationSpecifiers() throws RecognitionException
{
1834 CTFParser
.declarationSpecifiers_return retval
= new CTFParser
.declarationSpecifiers_return();
1835 retval
.start
= input
.LT(1);
1837 CommonTree root_0
= null;
1839 ParserRuleReturnScope storageClassSpecifier32
=null;
1840 ParserRuleReturnScope typeQualifier33
=null;
1841 ParserRuleReturnScope typeSpecifier34
=null;
1843 RewriteRuleSubtreeStream stream_typeSpecifier
=new RewriteRuleSubtreeStream(adaptor
,"rule typeSpecifier");
1844 RewriteRuleSubtreeStream stream_storageClassSpecifier
=new RewriteRuleSubtreeStream(adaptor
,"rule storageClassSpecifier");
1845 RewriteRuleSubtreeStream stream_typeQualifier
=new RewriteRuleSubtreeStream(adaptor
,"rule typeQualifier");
1848 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:263:3: ( ( storageClassSpecifier | typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) )
1849 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:263:5: ( storageClassSpecifier | typeQualifier | typeSpecifier )+
1851 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:263:5: ( storageClassSpecifier | typeQualifier | typeSpecifier )+
1856 switch ( input
.LA(1) ) {
1859 int LA14_2
= input
.LA(2);
1860 if ( ((( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) )&&(inTypealiasAlias() || isTypeName(input
.LT(1).getText())))) ) {
1881 case FLOATINGPOINTTOK
:
1901 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:266:9: storageClassSpecifier
1903 pushFollow(FOLLOW_storageClassSpecifier_in_declarationSpecifiers969
);
1904 storageClassSpecifier32
=storageClassSpecifier();
1906 if (state
.failed
) return retval
;
1907 if ( state
.backtracking
==0 ) stream_storageClassSpecifier
.add(storageClassSpecifier32
.getTree());
1911 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:267:9: typeQualifier
1913 pushFollow(FOLLOW_typeQualifier_in_declarationSpecifiers979
);
1914 typeQualifier33
=typeQualifier();
1916 if (state
.failed
) return retval
;
1917 if ( state
.backtracking
==0 ) stream_typeQualifier
.add(typeQualifier33
.getTree());
1921 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:268:9: typeSpecifier
1923 pushFollow(FOLLOW_typeSpecifier_in_declarationSpecifiers989
);
1924 typeSpecifier34
=typeSpecifier();
1926 if (state
.failed
) return retval
;
1927 if ( state
.backtracking
==0 ) stream_typeSpecifier
.add(typeSpecifier34
.getTree());
1932 if ( cnt14
>= 1 ) break loop14
;
1933 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
1934 EarlyExitException eee
= new EarlyExitException(14, input
);
1941 // elements: typeQualifier, typeSpecifier
1943 // rule labels: retval
1944 // token list labels:
1945 // rule list labels:
1947 if ( state
.backtracking
==0 ) {
1948 retval
.tree
= root_0
;
1949 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
1951 root_0
= (CommonTree
)adaptor
.nil();
1952 // 269:6: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
1954 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:269:9: ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
1956 CommonTree root_1
= (CommonTree
)adaptor
.nil();
1957 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_SPECIFIER_LIST
, "TYPE_SPECIFIER_LIST"), root_1
);
1958 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:269:31: ( typeQualifier )*
1959 while ( stream_typeQualifier
.hasNext() ) {
1960 adaptor
.addChild(root_1
, stream_typeQualifier
.nextTree());
1962 stream_typeQualifier
.reset();
1964 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:269:46: ( typeSpecifier )*
1965 while ( stream_typeSpecifier
.hasNext() ) {
1966 adaptor
.addChild(root_1
, stream_typeSpecifier
.nextTree());
1968 stream_typeSpecifier
.reset();
1970 adaptor
.addChild(root_0
, root_1
);
1976 retval
.tree
= root_0
;
1981 retval
.stop
= input
.LT(-1);
1983 if ( state
.backtracking
==0 ) {
1984 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
1985 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
1989 catch (RecognitionException e
) {
1994 // do for sure before leaving
1998 // $ANTLR end "declarationSpecifiers"
2001 public static class declaratorList_return
extends ParserRuleReturnScope
{
2004 public CommonTree
getTree() { return tree
; }
2008 // $ANTLR start "declaratorList"
2009 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:272:1: declaratorList : declarator ( SEPARATOR declarator )* -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) ;
2010 public final CTFParser
.declaratorList_return
declaratorList() throws RecognitionException
{
2011 CTFParser
.declaratorList_return retval
= new CTFParser
.declaratorList_return();
2012 retval
.start
= input
.LT(1);
2014 CommonTree root_0
= null;
2016 Token SEPARATOR36
=null;
2017 ParserRuleReturnScope declarator35
=null;
2018 ParserRuleReturnScope declarator37
=null;
2020 CommonTree SEPARATOR36_tree
=null;
2021 RewriteRuleTokenStream stream_SEPARATOR
=new RewriteRuleTokenStream(adaptor
,"token SEPARATOR");
2022 RewriteRuleSubtreeStream stream_declarator
=new RewriteRuleSubtreeStream(adaptor
,"rule declarator");
2025 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:273:3: ( declarator ( SEPARATOR declarator )* -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) )
2026 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:273:5: declarator ( SEPARATOR declarator )*
2028 pushFollow(FOLLOW_declarator_in_declaratorList1019
);
2029 declarator35
=declarator();
2031 if (state
.failed
) return retval
;
2032 if ( state
.backtracking
==0 ) stream_declarator
.add(declarator35
.getTree());
2033 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:273:16: ( SEPARATOR declarator )*
2037 int LA15_0
= input
.LA(1);
2038 if ( (LA15_0
==SEPARATOR
) ) {
2044 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:273:17: SEPARATOR declarator
2046 SEPARATOR36
=(Token
)match(input
,SEPARATOR
,FOLLOW_SEPARATOR_in_declaratorList1022
); if (state
.failed
) return retval
;
2047 if ( state
.backtracking
==0 ) stream_SEPARATOR
.add(SEPARATOR36
);
2049 pushFollow(FOLLOW_declarator_in_declaratorList1024
);
2050 declarator37
=declarator();
2052 if (state
.failed
) return retval
;
2053 if ( state
.backtracking
==0 ) stream_declarator
.add(declarator37
.getTree());
2063 // elements: declarator
2065 // rule labels: retval
2066 // token list labels:
2067 // rule list labels:
2069 if ( state
.backtracking
==0 ) {
2070 retval
.tree
= root_0
;
2071 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
2073 root_0
= (CommonTree
)adaptor
.nil();
2074 // 274:7: -> ^( TYPE_DECLARATOR_LIST ( declarator )+ )
2076 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:274:10: ^( TYPE_DECLARATOR_LIST ( declarator )+ )
2078 CommonTree root_1
= (CommonTree
)adaptor
.nil();
2079 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_DECLARATOR_LIST
, "TYPE_DECLARATOR_LIST"), root_1
);
2080 if ( !(stream_declarator
.hasNext()) ) {
2081 throw new RewriteEarlyExitException();
2083 while ( stream_declarator
.hasNext() ) {
2084 adaptor
.addChild(root_1
, stream_declarator
.nextTree());
2086 stream_declarator
.reset();
2088 adaptor
.addChild(root_0
, root_1
);
2094 retval
.tree
= root_0
;
2099 retval
.stop
= input
.LT(-1);
2101 if ( state
.backtracking
==0 ) {
2102 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
2103 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
2107 catch (RecognitionException e
) {
2112 // do for sure before leaving
2116 // $ANTLR end "declaratorList"
2119 public static class abstractDeclaratorList_return
extends ParserRuleReturnScope
{
2122 public CommonTree
getTree() { return tree
; }
2126 // $ANTLR start "abstractDeclaratorList"
2127 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:277:1: abstractDeclaratorList : abstractDeclarator ( SEPARATOR abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ ) ;
2128 public final CTFParser
.abstractDeclaratorList_return
abstractDeclaratorList() throws RecognitionException
{
2129 CTFParser
.abstractDeclaratorList_return retval
= new CTFParser
.abstractDeclaratorList_return();
2130 retval
.start
= input
.LT(1);
2132 CommonTree root_0
= null;
2134 Token SEPARATOR39
=null;
2135 ParserRuleReturnScope abstractDeclarator38
=null;
2136 ParserRuleReturnScope abstractDeclarator40
=null;
2138 CommonTree SEPARATOR39_tree
=null;
2139 RewriteRuleTokenStream stream_SEPARATOR
=new RewriteRuleTokenStream(adaptor
,"token SEPARATOR");
2140 RewriteRuleSubtreeStream stream_abstractDeclarator
=new RewriteRuleSubtreeStream(adaptor
,"rule abstractDeclarator");
2143 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:278:3: ( abstractDeclarator ( SEPARATOR abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ ) )
2144 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:278:5: abstractDeclarator ( SEPARATOR abstractDeclarator )*
2146 pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList1054
);
2147 abstractDeclarator38
=abstractDeclarator();
2149 if (state
.failed
) return retval
;
2150 if ( state
.backtracking
==0 ) stream_abstractDeclarator
.add(abstractDeclarator38
.getTree());
2151 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:278:24: ( SEPARATOR abstractDeclarator )*
2155 int LA16_0
= input
.LA(1);
2156 if ( (LA16_0
==SEPARATOR
) ) {
2162 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:278:25: SEPARATOR abstractDeclarator
2164 SEPARATOR39
=(Token
)match(input
,SEPARATOR
,FOLLOW_SEPARATOR_in_abstractDeclaratorList1057
); if (state
.failed
) return retval
;
2165 if ( state
.backtracking
==0 ) stream_SEPARATOR
.add(SEPARATOR39
);
2167 pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList1059
);
2168 abstractDeclarator40
=abstractDeclarator();
2170 if (state
.failed
) return retval
;
2171 if ( state
.backtracking
==0 ) stream_abstractDeclarator
.add(abstractDeclarator40
.getTree());
2181 // elements: abstractDeclarator
2183 // rule labels: retval
2184 // token list labels:
2185 // rule list labels:
2187 if ( state
.backtracking
==0 ) {
2188 retval
.tree
= root_0
;
2189 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
2191 root_0
= (CommonTree
)adaptor
.nil();
2192 // 279:7: -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ )
2194 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:279:10: ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ )
2196 CommonTree root_1
= (CommonTree
)adaptor
.nil();
2197 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_DECLARATOR_LIST
, "TYPE_DECLARATOR_LIST"), root_1
);
2198 if ( !(stream_abstractDeclarator
.hasNext()) ) {
2199 throw new RewriteEarlyExitException();
2201 while ( stream_abstractDeclarator
.hasNext() ) {
2202 adaptor
.addChild(root_1
, stream_abstractDeclarator
.nextTree());
2204 stream_abstractDeclarator
.reset();
2206 adaptor
.addChild(root_0
, root_1
);
2212 retval
.tree
= root_0
;
2217 retval
.stop
= input
.LT(-1);
2219 if ( state
.backtracking
==0 ) {
2220 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
2221 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
2225 catch (RecognitionException e
) {
2230 // do for sure before leaving
2234 // $ANTLR end "abstractDeclaratorList"
2237 public static class storageClassSpecifier_return
extends ParserRuleReturnScope
{
2240 public CommonTree
getTree() { return tree
; }
2244 // $ANTLR start "storageClassSpecifier"
2245 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:282:1: storageClassSpecifier : TYPEDEFTOK ;
2246 public final CTFParser
.storageClassSpecifier_return
storageClassSpecifier() throws RecognitionException
{
2247 CTFParser
.storageClassSpecifier_return retval
= new CTFParser
.storageClassSpecifier_return();
2248 retval
.start
= input
.LT(1);
2250 CommonTree root_0
= null;
2252 Token TYPEDEFTOK41
=null;
2254 CommonTree TYPEDEFTOK41_tree
=null;
2257 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:283:3: ( TYPEDEFTOK )
2258 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:283:5: TYPEDEFTOK
2260 root_0
= (CommonTree
)adaptor
.nil();
2263 TYPEDEFTOK41
=(Token
)match(input
,TYPEDEFTOK
,FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1089
); if (state
.failed
) return retval
;
2264 if ( state
.backtracking
==0 ) {
2265 TYPEDEFTOK41_tree
= (CommonTree
)adaptor
.create(TYPEDEFTOK41
);
2266 adaptor
.addChild(root_0
, TYPEDEFTOK41_tree
);
2269 if ( state
.backtracking
==0 ) { typedefOn(); }
2272 retval
.stop
= input
.LT(-1);
2274 if ( state
.backtracking
==0 ) {
2275 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
2276 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
2280 catch (RecognitionException e
) {
2285 // do for sure before leaving
2289 // $ANTLR end "storageClassSpecifier"
2292 public static class typeSpecifier_return
extends ParserRuleReturnScope
{
2295 public CommonTree
getTree() { return tree
; }
2299 // $ANTLR start "typeSpecifier"
2300 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:286:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier | enumSpecifier | ctfTypeSpecifier |{...}? => typedefName );
2301 public final CTFParser
.typeSpecifier_return
typeSpecifier() throws RecognitionException
{
2302 CTFParser
.typeSpecifier_return retval
= new CTFParser
.typeSpecifier_return();
2303 retval
.start
= input
.LT(1);
2305 CommonTree root_0
= null;
2307 Token FLOATTOK42
=null;
2308 Token INTTOK43
=null;
2309 Token LONGTOK44
=null;
2310 Token SHORTTOK45
=null;
2311 Token SIGNEDTOK46
=null;
2312 Token UNSIGNEDTOK47
=null;
2313 Token CHARTOK48
=null;
2314 Token DOUBLETOK49
=null;
2315 Token VOIDTOK50
=null;
2316 Token BOOLTOK51
=null;
2317 Token COMPLEXTOK52
=null;
2318 Token IMAGINARYTOK53
=null;
2319 ParserRuleReturnScope structSpecifier54
=null;
2320 ParserRuleReturnScope variantSpecifier55
=null;
2321 ParserRuleReturnScope enumSpecifier56
=null;
2322 ParserRuleReturnScope ctfTypeSpecifier57
=null;
2323 ParserRuleReturnScope typedefName58
=null;
2325 CommonTree FLOATTOK42_tree
=null;
2326 CommonTree INTTOK43_tree
=null;
2327 CommonTree LONGTOK44_tree
=null;
2328 CommonTree SHORTTOK45_tree
=null;
2329 CommonTree SIGNEDTOK46_tree
=null;
2330 CommonTree UNSIGNEDTOK47_tree
=null;
2331 CommonTree CHARTOK48_tree
=null;
2332 CommonTree DOUBLETOK49_tree
=null;
2333 CommonTree VOIDTOK50_tree
=null;
2334 CommonTree BOOLTOK51_tree
=null;
2335 CommonTree COMPLEXTOK52_tree
=null;
2336 CommonTree IMAGINARYTOK53_tree
=null;
2339 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:287:3: ( FLOATTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier | enumSpecifier | ctfTypeSpecifier |{...}? => typedefName )
2341 int LA17_0
= input
.LA(1);
2342 if ( (LA17_0
==FLOATTOK
) ) {
2345 else if ( (LA17_0
==INTTOK
) ) {
2348 else if ( (LA17_0
==LONGTOK
) ) {
2351 else if ( (LA17_0
==SHORTTOK
) ) {
2354 else if ( (LA17_0
==SIGNEDTOK
) ) {
2357 else if ( (LA17_0
==UNSIGNEDTOK
) ) {
2360 else if ( (LA17_0
==CHARTOK
) ) {
2363 else if ( (LA17_0
==DOUBLETOK
) ) {
2366 else if ( (LA17_0
==VOIDTOK
) ) {
2369 else if ( (LA17_0
==BOOLTOK
) ) {
2372 else if ( (LA17_0
==COMPLEXTOK
) ) {
2375 else if ( (LA17_0
==IMAGINARYTOK
) ) {
2378 else if ( (LA17_0
==STRUCTTOK
) ) {
2381 else if ( (LA17_0
==VARIANTTOK
) ) {
2384 else if ( (LA17_0
==ENUMTOK
) ) {
2387 else if ( (LA17_0
==FLOATINGPOINTTOK
||LA17_0
==INTEGERTOK
||LA17_0
==STRINGTOK
) ) {
2390 else if ( (LA17_0
==IDENTIFIER
) && (( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) ))) {
2396 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:287:5: FLOATTOK
2398 root_0
= (CommonTree
)adaptor
.nil();
2401 FLOATTOK42
=(Token
)match(input
,FLOATTOK
,FOLLOW_FLOATTOK_in_typeSpecifier1105
); if (state
.failed
) return retval
;
2402 if ( state
.backtracking
==0 ) {
2403 FLOATTOK42_tree
= (CommonTree
)adaptor
.create(FLOATTOK42
);
2404 adaptor
.addChild(root_0
, FLOATTOK42_tree
);
2410 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:288:5: INTTOK
2412 root_0
= (CommonTree
)adaptor
.nil();
2415 INTTOK43
=(Token
)match(input
,INTTOK
,FOLLOW_INTTOK_in_typeSpecifier1111
); if (state
.failed
) return retval
;
2416 if ( state
.backtracking
==0 ) {
2417 INTTOK43_tree
= (CommonTree
)adaptor
.create(INTTOK43
);
2418 adaptor
.addChild(root_0
, INTTOK43_tree
);
2424 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:289:5: LONGTOK
2426 root_0
= (CommonTree
)adaptor
.nil();
2429 LONGTOK44
=(Token
)match(input
,LONGTOK
,FOLLOW_LONGTOK_in_typeSpecifier1117
); if (state
.failed
) return retval
;
2430 if ( state
.backtracking
==0 ) {
2431 LONGTOK44_tree
= (CommonTree
)adaptor
.create(LONGTOK44
);
2432 adaptor
.addChild(root_0
, LONGTOK44_tree
);
2438 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:290:5: SHORTTOK
2440 root_0
= (CommonTree
)adaptor
.nil();
2443 SHORTTOK45
=(Token
)match(input
,SHORTTOK
,FOLLOW_SHORTTOK_in_typeSpecifier1123
); if (state
.failed
) return retval
;
2444 if ( state
.backtracking
==0 ) {
2445 SHORTTOK45_tree
= (CommonTree
)adaptor
.create(SHORTTOK45
);
2446 adaptor
.addChild(root_0
, SHORTTOK45_tree
);
2452 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:291:5: SIGNEDTOK
2454 root_0
= (CommonTree
)adaptor
.nil();
2457 SIGNEDTOK46
=(Token
)match(input
,SIGNEDTOK
,FOLLOW_SIGNEDTOK_in_typeSpecifier1129
); if (state
.failed
) return retval
;
2458 if ( state
.backtracking
==0 ) {
2459 SIGNEDTOK46_tree
= (CommonTree
)adaptor
.create(SIGNEDTOK46
);
2460 adaptor
.addChild(root_0
, SIGNEDTOK46_tree
);
2466 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:292:5: UNSIGNEDTOK
2468 root_0
= (CommonTree
)adaptor
.nil();
2471 UNSIGNEDTOK47
=(Token
)match(input
,UNSIGNEDTOK
,FOLLOW_UNSIGNEDTOK_in_typeSpecifier1135
); if (state
.failed
) return retval
;
2472 if ( state
.backtracking
==0 ) {
2473 UNSIGNEDTOK47_tree
= (CommonTree
)adaptor
.create(UNSIGNEDTOK47
);
2474 adaptor
.addChild(root_0
, UNSIGNEDTOK47_tree
);
2480 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:293:5: CHARTOK
2482 root_0
= (CommonTree
)adaptor
.nil();
2485 CHARTOK48
=(Token
)match(input
,CHARTOK
,FOLLOW_CHARTOK_in_typeSpecifier1141
); if (state
.failed
) return retval
;
2486 if ( state
.backtracking
==0 ) {
2487 CHARTOK48_tree
= (CommonTree
)adaptor
.create(CHARTOK48
);
2488 adaptor
.addChild(root_0
, CHARTOK48_tree
);
2494 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:294:5: DOUBLETOK
2496 root_0
= (CommonTree
)adaptor
.nil();
2499 DOUBLETOK49
=(Token
)match(input
,DOUBLETOK
,FOLLOW_DOUBLETOK_in_typeSpecifier1147
); if (state
.failed
) return retval
;
2500 if ( state
.backtracking
==0 ) {
2501 DOUBLETOK49_tree
= (CommonTree
)adaptor
.create(DOUBLETOK49
);
2502 adaptor
.addChild(root_0
, DOUBLETOK49_tree
);
2508 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:295:5: VOIDTOK
2510 root_0
= (CommonTree
)adaptor
.nil();
2513 VOIDTOK50
=(Token
)match(input
,VOIDTOK
,FOLLOW_VOIDTOK_in_typeSpecifier1153
); if (state
.failed
) return retval
;
2514 if ( state
.backtracking
==0 ) {
2515 VOIDTOK50_tree
= (CommonTree
)adaptor
.create(VOIDTOK50
);
2516 adaptor
.addChild(root_0
, VOIDTOK50_tree
);
2522 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:296:5: BOOLTOK
2524 root_0
= (CommonTree
)adaptor
.nil();
2527 BOOLTOK51
=(Token
)match(input
,BOOLTOK
,FOLLOW_BOOLTOK_in_typeSpecifier1159
); if (state
.failed
) return retval
;
2528 if ( state
.backtracking
==0 ) {
2529 BOOLTOK51_tree
= (CommonTree
)adaptor
.create(BOOLTOK51
);
2530 adaptor
.addChild(root_0
, BOOLTOK51_tree
);
2536 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:297:5: COMPLEXTOK
2538 root_0
= (CommonTree
)adaptor
.nil();
2541 COMPLEXTOK52
=(Token
)match(input
,COMPLEXTOK
,FOLLOW_COMPLEXTOK_in_typeSpecifier1165
); if (state
.failed
) return retval
;
2542 if ( state
.backtracking
==0 ) {
2543 COMPLEXTOK52_tree
= (CommonTree
)adaptor
.create(COMPLEXTOK52
);
2544 adaptor
.addChild(root_0
, COMPLEXTOK52_tree
);
2550 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:298:5: IMAGINARYTOK
2552 root_0
= (CommonTree
)adaptor
.nil();
2555 IMAGINARYTOK53
=(Token
)match(input
,IMAGINARYTOK
,FOLLOW_IMAGINARYTOK_in_typeSpecifier1171
); if (state
.failed
) return retval
;
2556 if ( state
.backtracking
==0 ) {
2557 IMAGINARYTOK53_tree
= (CommonTree
)adaptor
.create(IMAGINARYTOK53
);
2558 adaptor
.addChild(root_0
, IMAGINARYTOK53_tree
);
2564 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:299:5: structSpecifier
2566 root_0
= (CommonTree
)adaptor
.nil();
2569 pushFollow(FOLLOW_structSpecifier_in_typeSpecifier1177
);
2570 structSpecifier54
=structSpecifier();
2572 if (state
.failed
) return retval
;
2573 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, structSpecifier54
.getTree());
2578 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:300:5: variantSpecifier
2580 root_0
= (CommonTree
)adaptor
.nil();
2583 pushFollow(FOLLOW_variantSpecifier_in_typeSpecifier1183
);
2584 variantSpecifier55
=variantSpecifier();
2586 if (state
.failed
) return retval
;
2587 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, variantSpecifier55
.getTree());
2592 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:301:5: enumSpecifier
2594 root_0
= (CommonTree
)adaptor
.nil();
2597 pushFollow(FOLLOW_enumSpecifier_in_typeSpecifier1189
);
2598 enumSpecifier56
=enumSpecifier();
2600 if (state
.failed
) return retval
;
2601 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, enumSpecifier56
.getTree());
2606 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:302:5: ctfTypeSpecifier
2608 root_0
= (CommonTree
)adaptor
.nil();
2611 pushFollow(FOLLOW_ctfTypeSpecifier_in_typeSpecifier1195
);
2612 ctfTypeSpecifier57
=ctfTypeSpecifier();
2614 if (state
.failed
) return retval
;
2615 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, ctfTypeSpecifier57
.getTree());
2620 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:303:5: {...}? => typedefName
2622 root_0
= (CommonTree
)adaptor
.nil();
2625 if ( !(( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) )) ) {
2626 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
2627 throw new FailedPredicateException(input
, "typeSpecifier", " inTypealiasAlias() || isTypeName(input.LT(1).getText()) ");
2629 pushFollow(FOLLOW_typedefName_in_typeSpecifier1205
);
2630 typedefName58
=typedefName();
2632 if (state
.failed
) return retval
;
2633 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, typedefName58
.getTree());
2639 retval
.stop
= input
.LT(-1);
2641 if ( state
.backtracking
==0 ) {
2642 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
2643 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
2647 catch (RecognitionException e
) {
2652 // do for sure before leaving
2656 // $ANTLR end "typeSpecifier"
2659 public static class typeQualifier_return
extends ParserRuleReturnScope
{
2662 public CommonTree
getTree() { return tree
; }
2666 // $ANTLR start "typeQualifier"
2667 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:306:1: typeQualifier : CONSTTOK ;
2668 public final CTFParser
.typeQualifier_return
typeQualifier() throws RecognitionException
{
2669 CTFParser
.typeQualifier_return retval
= new CTFParser
.typeQualifier_return();
2670 retval
.start
= input
.LT(1);
2672 CommonTree root_0
= null;
2674 Token CONSTTOK59
=null;
2676 CommonTree CONSTTOK59_tree
=null;
2679 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:307:3: ( CONSTTOK )
2680 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:307:5: CONSTTOK
2682 root_0
= (CommonTree
)adaptor
.nil();
2685 CONSTTOK59
=(Token
)match(input
,CONSTTOK
,FOLLOW_CONSTTOK_in_typeQualifier1218
); if (state
.failed
) return retval
;
2686 if ( state
.backtracking
==0 ) {
2687 CONSTTOK59_tree
= (CommonTree
)adaptor
.create(CONSTTOK59
);
2688 adaptor
.addChild(root_0
, CONSTTOK59_tree
);
2693 retval
.stop
= input
.LT(-1);
2695 if ( state
.backtracking
==0 ) {
2696 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
2697 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
2701 catch (RecognitionException e
) {
2706 // do for sure before leaving
2710 // $ANTLR end "typeQualifier"
2713 public static class alignAttribute_return
extends ParserRuleReturnScope
{
2716 public CommonTree
getTree() { return tree
; }
2720 // $ANTLR start "alignAttribute"
2721 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:310:1: alignAttribute : ALIGNTOK LPAREN unaryExpression RPAREN -> ^( ALIGN unaryExpression ) ;
2722 public final CTFParser
.alignAttribute_return
alignAttribute() throws RecognitionException
{
2723 CTFParser
.alignAttribute_return retval
= new CTFParser
.alignAttribute_return();
2724 retval
.start
= input
.LT(1);
2726 CommonTree root_0
= null;
2728 Token ALIGNTOK60
=null;
2729 Token LPAREN61
=null;
2730 Token RPAREN63
=null;
2731 ParserRuleReturnScope unaryExpression62
=null;
2733 CommonTree ALIGNTOK60_tree
=null;
2734 CommonTree LPAREN61_tree
=null;
2735 CommonTree RPAREN63_tree
=null;
2736 RewriteRuleTokenStream stream_LPAREN
=new RewriteRuleTokenStream(adaptor
,"token LPAREN");
2737 RewriteRuleTokenStream stream_RPAREN
=new RewriteRuleTokenStream(adaptor
,"token RPAREN");
2738 RewriteRuleTokenStream stream_ALIGNTOK
=new RewriteRuleTokenStream(adaptor
,"token ALIGNTOK");
2739 RewriteRuleSubtreeStream stream_unaryExpression
=new RewriteRuleSubtreeStream(adaptor
,"rule unaryExpression");
2742 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:311:3: ( ALIGNTOK LPAREN unaryExpression RPAREN -> ^( ALIGN unaryExpression ) )
2743 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:311:5: ALIGNTOK LPAREN unaryExpression RPAREN
2745 ALIGNTOK60
=(Token
)match(input
,ALIGNTOK
,FOLLOW_ALIGNTOK_in_alignAttribute1231
); if (state
.failed
) return retval
;
2746 if ( state
.backtracking
==0 ) stream_ALIGNTOK
.add(ALIGNTOK60
);
2748 LPAREN61
=(Token
)match(input
,LPAREN
,FOLLOW_LPAREN_in_alignAttribute1233
); if (state
.failed
) return retval
;
2749 if ( state
.backtracking
==0 ) stream_LPAREN
.add(LPAREN61
);
2751 pushFollow(FOLLOW_unaryExpression_in_alignAttribute1235
);
2752 unaryExpression62
=unaryExpression();
2754 if (state
.failed
) return retval
;
2755 if ( state
.backtracking
==0 ) stream_unaryExpression
.add(unaryExpression62
.getTree());
2756 RPAREN63
=(Token
)match(input
,RPAREN
,FOLLOW_RPAREN_in_alignAttribute1237
); if (state
.failed
) return retval
;
2757 if ( state
.backtracking
==0 ) stream_RPAREN
.add(RPAREN63
);
2760 // elements: unaryExpression
2762 // rule labels: retval
2763 // token list labels:
2764 // rule list labels:
2766 if ( state
.backtracking
==0 ) {
2767 retval
.tree
= root_0
;
2768 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
2770 root_0
= (CommonTree
)adaptor
.nil();
2771 // 311:44: -> ^( ALIGN unaryExpression )
2773 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:311:47: ^( ALIGN unaryExpression )
2775 CommonTree root_1
= (CommonTree
)adaptor
.nil();
2776 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ALIGN
, "ALIGN"), root_1
);
2777 adaptor
.addChild(root_1
, stream_unaryExpression
.nextTree());
2778 adaptor
.addChild(root_0
, root_1
);
2784 retval
.tree
= root_0
;
2789 retval
.stop
= input
.LT(-1);
2791 if ( state
.backtracking
==0 ) {
2792 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
2793 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
2797 catch (RecognitionException e
) {
2802 // do for sure before leaving
2806 // $ANTLR end "alignAttribute"
2809 public static class structBody_return
extends ParserRuleReturnScope
{
2812 public CommonTree
getTree() { return tree
; }
2816 // $ANTLR start "structBody"
2817 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:315:1: structBody : LCURL ( structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY ( structOrVariantDeclarationList )? ) ;
2818 public final CTFParser
.structBody_return
structBody() throws RecognitionException
{
2819 Symbols_stack
.push(new Symbols_scope());
2821 CTFParser
.structBody_return retval
= new CTFParser
.structBody_return();
2822 retval
.start
= input
.LT(1);
2824 CommonTree root_0
= null;
2828 ParserRuleReturnScope structOrVariantDeclarationList65
=null;
2830 CommonTree LCURL64_tree
=null;
2831 CommonTree RCURL66_tree
=null;
2832 RewriteRuleTokenStream stream_LCURL
=new RewriteRuleTokenStream(adaptor
,"token LCURL");
2833 RewriteRuleTokenStream stream_RCURL
=new RewriteRuleTokenStream(adaptor
,"token RCURL");
2834 RewriteRuleSubtreeStream stream_structOrVariantDeclarationList
=new RewriteRuleSubtreeStream(adaptor
,"rule structOrVariantDeclarationList");
2837 Symbols_stack
.peek().types
= new HashSet
<String
>();
2840 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:320:3: ( LCURL ( structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY ( structOrVariantDeclarationList )? ) )
2841 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:320:5: LCURL ( structOrVariantDeclarationList )? RCURL
2843 LCURL64
=(Token
)match(input
,LCURL
,FOLLOW_LCURL_in_structBody1271
); if (state
.failed
) return retval
;
2844 if ( state
.backtracking
==0 ) stream_LCURL
.add(LCURL64
);
2846 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:320:11: ( structOrVariantDeclarationList )?
2848 int LA18_0
= input
.LA(1);
2849 if ( (LA18_0
==BOOLTOK
||LA18_0
==CHARTOK
||(LA18_0
>= COMPLEXTOK
&& LA18_0
<= CONSTTOK
)||LA18_0
==DOUBLETOK
||LA18_0
==ENUMTOK
||(LA18_0
>= FLOATINGPOINTTOK
&& LA18_0
<= FLOATTOK
)||LA18_0
==IMAGINARYTOK
||LA18_0
==INTEGERTOK
||LA18_0
==INTTOK
||LA18_0
==LONGTOK
||LA18_0
==SHORTTOK
||LA18_0
==SIGNEDTOK
||LA18_0
==STRINGTOK
||LA18_0
==STRUCTTOK
||LA18_0
==TYPEDEFTOK
||(LA18_0
>= UNSIGNEDTOK
&& LA18_0
<= VOIDTOK
)) ) {
2852 else if ( (LA18_0
==IDENTIFIER
) && (( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) ))) {
2855 else if ( (LA18_0
==TYPEALIASTOK
) ) {
2860 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:320:11: structOrVariantDeclarationList
2862 pushFollow(FOLLOW_structOrVariantDeclarationList_in_structBody1273
);
2863 structOrVariantDeclarationList65
=structOrVariantDeclarationList();
2865 if (state
.failed
) return retval
;
2866 if ( state
.backtracking
==0 ) stream_structOrVariantDeclarationList
.add(structOrVariantDeclarationList65
.getTree());
2872 RCURL66
=(Token
)match(input
,RCURL
,FOLLOW_RCURL_in_structBody1276
); if (state
.failed
) return retval
;
2873 if ( state
.backtracking
==0 ) stream_RCURL
.add(RCURL66
);
2876 // elements: structOrVariantDeclarationList
2878 // rule labels: retval
2879 // token list labels:
2880 // rule list labels:
2882 if ( state
.backtracking
==0 ) {
2883 retval
.tree
= root_0
;
2884 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
2886 root_0
= (CommonTree
)adaptor
.nil();
2887 // 321:7: -> ^( STRUCT_BODY ( structOrVariantDeclarationList )? )
2889 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:321:10: ^( STRUCT_BODY ( structOrVariantDeclarationList )? )
2891 CommonTree root_1
= (CommonTree
)adaptor
.nil();
2892 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(STRUCT_BODY
, "STRUCT_BODY"), root_1
);
2893 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:321:24: ( structOrVariantDeclarationList )?
2894 if ( stream_structOrVariantDeclarationList
.hasNext() ) {
2895 adaptor
.addChild(root_1
, stream_structOrVariantDeclarationList
.nextTree());
2897 stream_structOrVariantDeclarationList
.reset();
2899 adaptor
.addChild(root_0
, root_1
);
2905 retval
.tree
= root_0
;
2910 retval
.stop
= input
.LT(-1);
2912 if ( state
.backtracking
==0 ) {
2913 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
2914 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
2918 catch (RecognitionException e
) {
2923 // do for sure before leaving
2924 Symbols_stack
.pop();
2929 // $ANTLR end "structBody"
2932 public static class structSpecifier_return
extends ParserRuleReturnScope
{
2935 public CommonTree
getTree() { return tree
; }
2939 // $ANTLR start "structSpecifier"
2940 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:324:1: structSpecifier : STRUCTTOK ( ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) ) | ( structBody ( alignAttribute |) ) ) -> ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? ) ;
2941 public final CTFParser
.structSpecifier_return
structSpecifier() throws RecognitionException
{
2942 CTFParser
.structSpecifier_return retval
= new CTFParser
.structSpecifier_return();
2943 retval
.start
= input
.LT(1);
2945 CommonTree root_0
= null;
2947 Token STRUCTTOK67
=null;
2948 ParserRuleReturnScope structName68
=null;
2949 ParserRuleReturnScope alignAttribute69
=null;
2950 ParserRuleReturnScope structBody70
=null;
2951 ParserRuleReturnScope alignAttribute71
=null;
2952 ParserRuleReturnScope structBody72
=null;
2953 ParserRuleReturnScope alignAttribute73
=null;
2955 CommonTree STRUCTTOK67_tree
=null;
2956 RewriteRuleTokenStream stream_STRUCTTOK
=new RewriteRuleTokenStream(adaptor
,"token STRUCTTOK");
2957 RewriteRuleSubtreeStream stream_structName
=new RewriteRuleSubtreeStream(adaptor
,"rule structName");
2958 RewriteRuleSubtreeStream stream_structBody
=new RewriteRuleSubtreeStream(adaptor
,"rule structBody");
2959 RewriteRuleSubtreeStream stream_alignAttribute
=new RewriteRuleSubtreeStream(adaptor
,"rule alignAttribute");
2962 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:325:3: ( STRUCTTOK ( ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) ) | ( structBody ( alignAttribute |) ) ) -> ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? ) )
2963 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:325:5: STRUCTTOK ( ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) ) | ( structBody ( alignAttribute |) ) )
2965 STRUCTTOK67
=(Token
)match(input
,STRUCTTOK
,FOLLOW_STRUCTTOK_in_structSpecifier1304
); if (state
.failed
) return retval
;
2966 if ( state
.backtracking
==0 ) stream_STRUCTTOK
.add(STRUCTTOK67
);
2968 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:326:3: ( ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) ) | ( structBody ( alignAttribute |) ) )
2970 int LA22_0
= input
.LA(1);
2971 if ( (LA22_0
==IDENTIFIER
) ) {
2974 else if ( (LA22_0
==LCURL
) ) {
2979 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
2980 NoViableAltException nvae
=
2981 new NoViableAltException("", 22, 0, input
);
2987 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:328:5: ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) )
2989 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:328:5: ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) )
2990 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:329:9: structName ( alignAttribute | ( structBody ( alignAttribute |) ) |)
2992 pushFollow(FOLLOW_structName_in_structSpecifier1329
);
2993 structName68
=structName();
2995 if (state
.failed
) return retval
;
2996 if ( state
.backtracking
==0 ) stream_structName
.add(structName68
.getTree());
2997 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:330:9: ( alignAttribute | ( structBody ( alignAttribute |) ) |)
2999 switch ( input
.LA(1) ) {
3007 switch ( input
.LA(2) ) {
3014 case FLOATINGPOINTTOK
:
3034 int LA20_5
= input
.LA(3);
3035 if ( (LA20_5
==BOOLTOK
||LA20_5
==CHARTOK
||(LA20_5
>= COMPLEXTOK
&& LA20_5
<= CONSTTOK
)||LA20_5
==DOUBLETOK
||LA20_5
==ENUMTOK
||(LA20_5
>= FLOATINGPOINTTOK
&& LA20_5
<= FLOATTOK
)||(LA20_5
>= IDENTIFIER
&& LA20_5
<= IMAGINARYTOK
)||LA20_5
==INTEGERTOK
||LA20_5
==INTTOK
||LA20_5
==LONGTOK
||LA20_5
==POINTER
||LA20_5
==SHORTTOK
||LA20_5
==SIGNEDTOK
||LA20_5
==STRINGTOK
||LA20_5
==STRUCTTOK
||LA20_5
==TYPEDEFTOK
||(LA20_5
>= UNSIGNEDTOK
&& LA20_5
<= VOIDTOK
)) ) {
3038 else if ( (LA20_5
==ASSIGNMENT
||LA20_5
==RCURL
||LA20_5
==SEPARATOR
) ) {
3043 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3044 int nvaeMark
= input
.mark();
3046 for (int nvaeConsume
= 0; nvaeConsume
< 3 - 1; nvaeConsume
++) {
3049 NoViableAltException nvae
=
3050 new NoViableAltException("", 20, 5, input
);
3053 input
.rewind(nvaeMark
);
3061 int LA20_6
= input
.LA(3);
3062 if ( (LA20_6
==BOOLTOK
||LA20_6
==CHARTOK
||(LA20_6
>= COMPLEXTOK
&& LA20_6
<= CONSTTOK
)||LA20_6
==DOUBLETOK
||LA20_6
==ENUMTOK
||(LA20_6
>= FLOATINGPOINTTOK
&& LA20_6
<= FLOATTOK
)||(LA20_6
>= IDENTIFIER
&& LA20_6
<= IMAGINARYTOK
)||LA20_6
==INTEGERTOK
||(LA20_6
>= INTTOK
&& LA20_6
<= LCURL
)||LA20_6
==LONGTOK
||LA20_6
==POINTER
||LA20_6
==SHORTTOK
||LA20_6
==SIGNEDTOK
||LA20_6
==STRINGTOK
||LA20_6
==STRUCTTOK
||LA20_6
==TYPEDEFTOK
||(LA20_6
>= UNSIGNEDTOK
&& LA20_6
<= VOIDTOK
)) ) {
3065 else if ( (LA20_6
==ASSIGNMENT
||LA20_6
==RCURL
||LA20_6
==SEPARATOR
) ) {
3070 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3071 int nvaeMark
= input
.mark();
3073 for (int nvaeConsume
= 0; nvaeConsume
< 3 - 1; nvaeConsume
++) {
3076 NoViableAltException nvae
=
3077 new NoViableAltException("", 20, 6, input
);
3080 input
.rewind(nvaeMark
);
3088 int LA20_7
= input
.LA(3);
3089 if ( (LA20_7
==BOOLTOK
||LA20_7
==CHARTOK
||(LA20_7
>= COMPLEXTOK
&& LA20_7
<= CONSTTOK
)||LA20_7
==DOUBLETOK
||LA20_7
==ENUMTOK
||(LA20_7
>= FLOATINGPOINTTOK
&& LA20_7
<= FLOATTOK
)||(LA20_7
>= IDENTIFIER
&& LA20_7
<= IMAGINARYTOK
)||LA20_7
==INTEGERTOK
||LA20_7
==INTTOK
||LA20_7
==LONGTOK
||LA20_7
==POINTER
||LA20_7
==SHORTTOK
||LA20_7
==SIGNEDTOK
||LA20_7
==STRINGTOK
||LA20_7
==STRUCTTOK
||LA20_7
==TYPEDEFTOK
||(LA20_7
>= UNSIGNEDTOK
&& LA20_7
<= VOIDTOK
)) ) {
3092 else if ( (LA20_7
==ASSIGNMENT
||LA20_7
==RCURL
||LA20_7
==SEPARATOR
) ) {
3097 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3098 int nvaeMark
= input
.mark();
3100 for (int nvaeConsume
= 0; nvaeConsume
< 3 - 1; nvaeConsume
++) {
3103 NoViableAltException nvae
=
3104 new NoViableAltException("", 20, 7, input
);
3107 input
.rewind(nvaeMark
);
3115 case STRING_LITERAL
:
3121 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3122 int nvaeMark
= input
.mark();
3125 NoViableAltException nvae
=
3126 new NoViableAltException("", 20, 2, input
);
3129 input
.rewind(nvaeMark
);
3141 case FLOATINGPOINTTOK
:
3156 case TYPE_ASSIGNMENT
:
3165 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3166 NoViableAltException nvae
=
3167 new NoViableAltException("", 20, 0, input
);
3172 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:331:11: alignAttribute
3174 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1351
);
3175 alignAttribute69
=alignAttribute();
3177 if (state
.failed
) return retval
;
3178 if ( state
.backtracking
==0 ) stream_alignAttribute
.add(alignAttribute69
.getTree());
3182 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:333:11: ( structBody ( alignAttribute |) )
3184 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:333:11: ( structBody ( alignAttribute |) )
3185 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:334:13: structBody ( alignAttribute |)
3187 pushFollow(FOLLOW_structBody_in_structSpecifier1387
);
3188 structBody70
=structBody();
3190 if (state
.failed
) return retval
;
3191 if ( state
.backtracking
==0 ) stream_structBody
.add(structBody70
.getTree());
3192 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:335:13: ( alignAttribute |)
3194 int LA19_0
= input
.LA(1);
3195 if ( (LA19_0
==ALIGNTOK
) ) {
3198 else if ( (LA19_0
==EOF
||LA19_0
==BOOLTOK
||LA19_0
==CHARTOK
||(LA19_0
>= COMPLEXTOK
&& LA19_0
<= CONSTTOK
)||LA19_0
==DOUBLETOK
||LA19_0
==ENUMTOK
||(LA19_0
>= FLOATINGPOINTTOK
&& LA19_0
<= FLOATTOK
)||(LA19_0
>= IDENTIFIER
&& LA19_0
<= IMAGINARYTOK
)||LA19_0
==INTEGERTOK
||(LA19_0
>= INTTOK
&& LA19_0
<= LCURL
)||(LA19_0
>= LONGTOK
&& LA19_0
<= LPAREN
)||LA19_0
==POINTER
||LA19_0
==SHORTTOK
||LA19_0
==SIGNEDTOK
||LA19_0
==STRINGTOK
||(LA19_0
>= STRUCTTOK
&& LA19_0
<= TERM
)||(LA19_0
>= TYPEDEFTOK
&& LA19_0
<= TYPE_ASSIGNMENT
)||(LA19_0
>= UNSIGNEDTOK
&& LA19_0
<= VOIDTOK
)) ) {
3203 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3204 NoViableAltException nvae
=
3205 new NoViableAltException("", 19, 0, input
);
3211 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:336:14: alignAttribute
3213 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1418
);
3214 alignAttribute71
=alignAttribute();
3216 if (state
.failed
) return retval
;
3217 if ( state
.backtracking
==0 ) stream_alignAttribute
.add(alignAttribute71
.getTree());
3221 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:339:13:
3233 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:343:9:
3245 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:347:5: ( structBody ( alignAttribute |) )
3247 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:347:5: ( structBody ( alignAttribute |) )
3248 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:348:7: structBody ( alignAttribute |)
3250 pushFollow(FOLLOW_structBody_in_structSpecifier1534
);
3251 structBody72
=structBody();
3253 if (state
.failed
) return retval
;
3254 if ( state
.backtracking
==0 ) stream_structBody
.add(structBody72
.getTree());
3255 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:349:7: ( alignAttribute |)
3257 int LA21_0
= input
.LA(1);
3258 if ( (LA21_0
==ALIGNTOK
) ) {
3261 else if ( (LA21_0
==EOF
||LA21_0
==BOOLTOK
||LA21_0
==CHARTOK
||(LA21_0
>= COMPLEXTOK
&& LA21_0
<= CONSTTOK
)||LA21_0
==DOUBLETOK
||LA21_0
==ENUMTOK
||(LA21_0
>= FLOATINGPOINTTOK
&& LA21_0
<= FLOATTOK
)||(LA21_0
>= IDENTIFIER
&& LA21_0
<= IMAGINARYTOK
)||LA21_0
==INTEGERTOK
||(LA21_0
>= INTTOK
&& LA21_0
<= LCURL
)||(LA21_0
>= LONGTOK
&& LA21_0
<= LPAREN
)||LA21_0
==POINTER
||LA21_0
==SHORTTOK
||LA21_0
==SIGNEDTOK
||LA21_0
==STRINGTOK
||(LA21_0
>= STRUCTTOK
&& LA21_0
<= TERM
)||(LA21_0
>= TYPEDEFTOK
&& LA21_0
<= TYPE_ASSIGNMENT
)||(LA21_0
>= UNSIGNEDTOK
&& LA21_0
<= VOIDTOK
)) ) {
3266 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3267 NoViableAltException nvae
=
3268 new NoViableAltException("", 21, 0, input
);
3274 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:350:9: alignAttribute
3276 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1552
);
3277 alignAttribute73
=alignAttribute();
3279 if (state
.failed
) return retval
;
3280 if ( state
.backtracking
==0 ) stream_alignAttribute
.add(alignAttribute73
.getTree());
3284 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:353:7:
3299 // elements: structName, structBody, alignAttribute
3301 // rule labels: retval
3302 // token list labels:
3303 // rule list labels:
3305 if ( state
.backtracking
==0 ) {
3306 retval
.tree
= root_0
;
3307 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
3309 root_0
= (CommonTree
)adaptor
.nil();
3310 // 355:5: -> ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? )
3312 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:355:8: ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? )
3314 CommonTree root_1
= (CommonTree
)adaptor
.nil();
3315 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(STRUCT
, "STRUCT"), root_1
);
3316 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:355:17: ( structName )?
3317 if ( stream_structName
.hasNext() ) {
3318 adaptor
.addChild(root_1
, stream_structName
.nextTree());
3320 stream_structName
.reset();
3322 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:355:29: ( structBody )?
3323 if ( stream_structBody
.hasNext() ) {
3324 adaptor
.addChild(root_1
, stream_structBody
.nextTree());
3326 stream_structBody
.reset();
3328 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:355:41: ( alignAttribute )?
3329 if ( stream_alignAttribute
.hasNext() ) {
3330 adaptor
.addChild(root_1
, stream_alignAttribute
.nextTree());
3332 stream_alignAttribute
.reset();
3334 adaptor
.addChild(root_0
, root_1
);
3340 retval
.tree
= root_0
;
3345 retval
.stop
= input
.LT(-1);
3347 if ( state
.backtracking
==0 ) {
3348 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
3349 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
3353 catch (RecognitionException e
) {
3358 // do for sure before leaving
3362 // $ANTLR end "structSpecifier"
3365 public static class structName_return
extends ParserRuleReturnScope
{
3368 public CommonTree
getTree() { return tree
; }
3372 // $ANTLR start "structName"
3373 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:358:1: structName : IDENTIFIER -> ^( STRUCT_NAME IDENTIFIER ) ;
3374 public final CTFParser
.structName_return
structName() throws RecognitionException
{
3375 CTFParser
.structName_return retval
= new CTFParser
.structName_return();
3376 retval
.start
= input
.LT(1);
3378 CommonTree root_0
= null;
3380 Token IDENTIFIER74
=null;
3382 CommonTree IDENTIFIER74_tree
=null;
3383 RewriteRuleTokenStream stream_IDENTIFIER
=new RewriteRuleTokenStream(adaptor
,"token IDENTIFIER");
3386 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:359:3: ( IDENTIFIER -> ^( STRUCT_NAME IDENTIFIER ) )
3387 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:359:5: IDENTIFIER
3389 IDENTIFIER74
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_structName1618
); if (state
.failed
) return retval
;
3390 if ( state
.backtracking
==0 ) stream_IDENTIFIER
.add(IDENTIFIER74
);
3393 // elements: IDENTIFIER
3395 // rule labels: retval
3396 // token list labels:
3397 // rule list labels:
3399 if ( state
.backtracking
==0 ) {
3400 retval
.tree
= root_0
;
3401 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
3403 root_0
= (CommonTree
)adaptor
.nil();
3404 // 359:16: -> ^( STRUCT_NAME IDENTIFIER )
3406 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:359:19: ^( STRUCT_NAME IDENTIFIER )
3408 CommonTree root_1
= (CommonTree
)adaptor
.nil();
3409 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(STRUCT_NAME
, "STRUCT_NAME"), root_1
);
3410 adaptor
.addChild(root_1
, stream_IDENTIFIER
.nextNode());
3411 adaptor
.addChild(root_0
, root_1
);
3417 retval
.tree
= root_0
;
3422 retval
.stop
= input
.LT(-1);
3424 if ( state
.backtracking
==0 ) {
3425 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
3426 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
3430 catch (RecognitionException e
) {
3435 // do for sure before leaving
3439 // $ANTLR end "structName"
3442 public static class structOrVariantDeclarationList_return
extends ParserRuleReturnScope
{
3445 public CommonTree
getTree() { return tree
; }
3449 // $ANTLR start "structOrVariantDeclarationList"
3450 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:362:1: structOrVariantDeclarationList : ( structOrVariantDeclaration )+ ;
3451 public final CTFParser
.structOrVariantDeclarationList_return
structOrVariantDeclarationList() throws RecognitionException
{
3452 CTFParser
.structOrVariantDeclarationList_return retval
= new CTFParser
.structOrVariantDeclarationList_return();
3453 retval
.start
= input
.LT(1);
3455 CommonTree root_0
= null;
3457 ParserRuleReturnScope structOrVariantDeclaration75
=null;
3461 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:363:3: ( ( structOrVariantDeclaration )+ )
3462 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:363:5: ( structOrVariantDeclaration )+
3464 root_0
= (CommonTree
)adaptor
.nil();
3467 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:363:5: ( structOrVariantDeclaration )+
3472 int LA23_0
= input
.LA(1);
3473 if ( (LA23_0
==BOOLTOK
||LA23_0
==CHARTOK
||(LA23_0
>= COMPLEXTOK
&& LA23_0
<= CONSTTOK
)||LA23_0
==DOUBLETOK
||LA23_0
==ENUMTOK
||(LA23_0
>= FLOATINGPOINTTOK
&& LA23_0
<= FLOATTOK
)||LA23_0
==IMAGINARYTOK
||LA23_0
==INTEGERTOK
||LA23_0
==INTTOK
||LA23_0
==LONGTOK
||LA23_0
==SHORTTOK
||LA23_0
==SIGNEDTOK
||LA23_0
==STRINGTOK
||LA23_0
==STRUCTTOK
||LA23_0
==TYPEDEFTOK
||(LA23_0
>= UNSIGNEDTOK
&& LA23_0
<= VOIDTOK
)) ) {
3476 else if ( (LA23_0
==IDENTIFIER
) && (( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) ))) {
3479 else if ( (LA23_0
==TYPEALIASTOK
) ) {
3485 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:363:5: structOrVariantDeclaration
3487 pushFollow(FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1639
);
3488 structOrVariantDeclaration75
=structOrVariantDeclaration();
3490 if (state
.failed
) return retval
;
3491 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, structOrVariantDeclaration75
.getTree());
3497 if ( cnt23
>= 1 ) break loop23
;
3498 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3499 EarlyExitException eee
= new EarlyExitException(23, input
);
3507 retval
.stop
= input
.LT(-1);
3509 if ( state
.backtracking
==0 ) {
3510 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
3511 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
3515 catch (RecognitionException e
) {
3520 // do for sure before leaving
3524 // $ANTLR end "structOrVariantDeclarationList"
3527 public static class structOrVariantDeclaration_return
extends ParserRuleReturnScope
{
3530 public CommonTree
getTree() { return tree
; }
3534 // $ANTLR start "structOrVariantDeclaration"
3535 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:366:1: structOrVariantDeclaration : ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl ) TERM ;
3536 public final CTFParser
.structOrVariantDeclaration_return
structOrVariantDeclaration() throws RecognitionException
{
3537 CTFParser
.structOrVariantDeclaration_return retval
= new CTFParser
.structOrVariantDeclaration_return();
3538 retval
.start
= input
.LT(1);
3540 CommonTree root_0
= null;
3543 ParserRuleReturnScope declarationSpecifiers76
=null;
3544 ParserRuleReturnScope declaratorList77
=null;
3545 ParserRuleReturnScope structOrVariantDeclaratorList78
=null;
3546 ParserRuleReturnScope typealiasDecl79
=null;
3548 CommonTree TERM80_tree
=null;
3549 RewriteRuleTokenStream stream_TERM
=new RewriteRuleTokenStream(adaptor
,"token TERM");
3550 RewriteRuleSubtreeStream stream_typealiasDecl
=new RewriteRuleSubtreeStream(adaptor
,"rule typealiasDecl");
3551 RewriteRuleSubtreeStream stream_declaratorList
=new RewriteRuleSubtreeStream(adaptor
,"rule declaratorList");
3552 RewriteRuleSubtreeStream stream_structOrVariantDeclaratorList
=new RewriteRuleSubtreeStream(adaptor
,"rule structOrVariantDeclaratorList");
3553 RewriteRuleSubtreeStream stream_declarationSpecifiers
=new RewriteRuleSubtreeStream(adaptor
,"rule declarationSpecifiers");
3556 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:367:3: ( ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl ) TERM )
3557 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:368:3: ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl ) TERM
3559 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:368:3: ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl )
3561 int LA25_0
= input
.LA(1);
3562 if ( (LA25_0
==BOOLTOK
||LA25_0
==CHARTOK
||(LA25_0
>= COMPLEXTOK
&& LA25_0
<= CONSTTOK
)||LA25_0
==DOUBLETOK
||LA25_0
==ENUMTOK
||(LA25_0
>= FLOATINGPOINTTOK
&& LA25_0
<= FLOATTOK
)||LA25_0
==IMAGINARYTOK
||LA25_0
==INTEGERTOK
||LA25_0
==INTTOK
||LA25_0
==LONGTOK
||LA25_0
==SHORTTOK
||LA25_0
==SIGNEDTOK
||LA25_0
==STRINGTOK
||LA25_0
==STRUCTTOK
||LA25_0
==TYPEDEFTOK
||(LA25_0
>= UNSIGNEDTOK
&& LA25_0
<= VOIDTOK
)) ) {
3565 else if ( (LA25_0
==IDENTIFIER
) && (( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) ))) {
3568 else if ( (LA25_0
==TYPEALIASTOK
) ) {
3573 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3574 NoViableAltException nvae
=
3575 new NoViableAltException("", 25, 0, input
);
3581 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:369:7: ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) )
3583 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:369:7: ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) )
3584 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:370:8: declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )
3586 pushFollow(FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1672
);
3587 declarationSpecifiers76
=declarationSpecifiers();
3589 if (state
.failed
) return retval
;
3590 if ( state
.backtracking
==0 ) stream_declarationSpecifiers
.add(declarationSpecifiers76
.getTree());
3591 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:371:10: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )
3593 alt24
= dfa24
.predict(input
);
3596 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:373:12: {...}? => declaratorList
3598 if ( !((inTypedef())) ) {
3599 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3600 throw new FailedPredicateException(input
, "structOrVariantDeclaration", "inTypedef()");
3602 pushFollow(FOLLOW_declaratorList_in_structOrVariantDeclaration1713
);
3603 declaratorList77
=declaratorList();
3605 if (state
.failed
) return retval
;
3606 if ( state
.backtracking
==0 ) stream_declaratorList
.add(declaratorList77
.getTree());
3608 // elements: declaratorList, declarationSpecifiers
3610 // rule labels: retval
3611 // token list labels:
3612 // rule list labels:
3614 if ( state
.backtracking
==0 ) {
3615 retval
.tree
= root_0
;
3616 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
3618 root_0
= (CommonTree
)adaptor
.nil();
3619 // 374:14: -> ^( TYPEDEF declaratorList declarationSpecifiers )
3621 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:374:17: ^( TYPEDEF declaratorList declarationSpecifiers )
3623 CommonTree root_1
= (CommonTree
)adaptor
.nil();
3624 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPEDEF
, "TYPEDEF"), root_1
);
3625 adaptor
.addChild(root_1
, stream_declaratorList
.nextTree());
3626 adaptor
.addChild(root_1
, stream_declarationSpecifiers
.nextTree());
3627 adaptor
.addChild(root_0
, root_1
);
3633 retval
.tree
= root_0
;
3639 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:375:14: structOrVariantDeclaratorList
3641 pushFollow(FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1751
);
3642 structOrVariantDeclaratorList78
=structOrVariantDeclaratorList();
3644 if (state
.failed
) return retval
;
3645 if ( state
.backtracking
==0 ) stream_structOrVariantDeclaratorList
.add(structOrVariantDeclaratorList78
.getTree());
3647 // elements: declarationSpecifiers, structOrVariantDeclaratorList
3649 // rule labels: retval
3650 // token list labels:
3651 // rule list labels:
3653 if ( state
.backtracking
==0 ) {
3654 retval
.tree
= root_0
;
3655 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
3657 root_0
= (CommonTree
)adaptor
.nil();
3658 // 376:14: -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList )
3660 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:376:17: ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList )
3662 CommonTree root_1
= (CommonTree
)adaptor
.nil();
3663 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(SV_DECLARATION
, "SV_DECLARATION"), root_1
);
3664 adaptor
.addChild(root_1
, stream_declarationSpecifiers
.nextTree());
3665 adaptor
.addChild(root_1
, stream_structOrVariantDeclaratorList
.nextTree());
3666 adaptor
.addChild(root_0
, root_1
);
3672 retval
.tree
= root_0
;
3685 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:381:5: typealiasDecl
3687 pushFollow(FOLLOW_typealiasDecl_in_structOrVariantDeclaration1810
);
3688 typealiasDecl79
=typealiasDecl();
3690 if (state
.failed
) return retval
;
3691 if ( state
.backtracking
==0 ) stream_typealiasDecl
.add(typealiasDecl79
.getTree());
3693 // elements: typealiasDecl
3695 // rule labels: retval
3696 // token list labels:
3697 // rule list labels:
3699 if ( state
.backtracking
==0 ) {
3700 retval
.tree
= root_0
;
3701 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
3703 root_0
= (CommonTree
)adaptor
.nil();
3704 // 381:19: -> typealiasDecl
3706 adaptor
.addChild(root_0
, stream_typealiasDecl
.nextTree());
3710 retval
.tree
= root_0
;
3718 TERM80
=(Token
)match(input
,TERM
,FOLLOW_TERM_in_structOrVariantDeclaration1822
); if (state
.failed
) return retval
;
3719 if ( state
.backtracking
==0 ) stream_TERM
.add(TERM80
);
3723 retval
.stop
= input
.LT(-1);
3725 if ( state
.backtracking
==0 ) {
3726 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
3727 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
3731 catch (RecognitionException e
) {
3736 // do for sure before leaving
3740 // $ANTLR end "structOrVariantDeclaration"
3743 public static class specifierQualifierList_return
extends ParserRuleReturnScope
{
3746 public CommonTree
getTree() { return tree
; }
3750 // $ANTLR start "specifierQualifierList"
3751 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:386:1: specifierQualifierList : ( typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
3752 public final CTFParser
.specifierQualifierList_return
specifierQualifierList() throws RecognitionException
{
3753 CTFParser
.specifierQualifierList_return retval
= new CTFParser
.specifierQualifierList_return();
3754 retval
.start
= input
.LT(1);
3756 CommonTree root_0
= null;
3758 ParserRuleReturnScope typeQualifier81
=null;
3759 ParserRuleReturnScope typeSpecifier82
=null;
3761 RewriteRuleSubtreeStream stream_typeSpecifier
=new RewriteRuleSubtreeStream(adaptor
,"rule typeSpecifier");
3762 RewriteRuleSubtreeStream stream_typeQualifier
=new RewriteRuleSubtreeStream(adaptor
,"rule typeQualifier");
3765 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:387:3: ( ( typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) )
3766 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:387:5: ( typeQualifier | typeSpecifier )+
3768 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:387:5: ( typeQualifier | typeSpecifier )+
3773 int LA26_0
= input
.LA(1);
3774 if ( (LA26_0
==CONSTTOK
) ) {
3777 else if ( (LA26_0
==BOOLTOK
||LA26_0
==CHARTOK
||LA26_0
==COMPLEXTOK
||LA26_0
==DOUBLETOK
||LA26_0
==ENUMTOK
||(LA26_0
>= FLOATINGPOINTTOK
&& LA26_0
<= FLOATTOK
)||LA26_0
==IMAGINARYTOK
||LA26_0
==INTEGERTOK
||LA26_0
==INTTOK
||LA26_0
==LONGTOK
||LA26_0
==SHORTTOK
||LA26_0
==SIGNEDTOK
||LA26_0
==STRINGTOK
||LA26_0
==STRUCTTOK
||(LA26_0
>= UNSIGNEDTOK
&& LA26_0
<= VOIDTOK
)) ) {
3780 else if ( (LA26_0
==IDENTIFIER
) && (( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) ))) {
3786 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:387:6: typeQualifier
3788 pushFollow(FOLLOW_typeQualifier_in_specifierQualifierList1836
);
3789 typeQualifier81
=typeQualifier();
3791 if (state
.failed
) return retval
;
3792 if ( state
.backtracking
==0 ) stream_typeQualifier
.add(typeQualifier81
.getTree());
3796 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:387:22: typeSpecifier
3798 pushFollow(FOLLOW_typeSpecifier_in_specifierQualifierList1840
);
3799 typeSpecifier82
=typeSpecifier();
3801 if (state
.failed
) return retval
;
3802 if ( state
.backtracking
==0 ) stream_typeSpecifier
.add(typeSpecifier82
.getTree());
3807 if ( cnt26
>= 1 ) break loop26
;
3808 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
3809 EarlyExitException eee
= new EarlyExitException(26, input
);
3816 // elements: typeQualifier, typeSpecifier
3818 // rule labels: retval
3819 // token list labels:
3820 // rule list labels:
3822 if ( state
.backtracking
==0 ) {
3823 retval
.tree
= root_0
;
3824 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
3826 root_0
= (CommonTree
)adaptor
.nil();
3827 // 388:7: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
3829 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:388:10: ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
3831 CommonTree root_1
= (CommonTree
)adaptor
.nil();
3832 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_SPECIFIER_LIST
, "TYPE_SPECIFIER_LIST"), root_1
);
3833 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:388:32: ( typeQualifier )*
3834 while ( stream_typeQualifier
.hasNext() ) {
3835 adaptor
.addChild(root_1
, stream_typeQualifier
.nextTree());
3837 stream_typeQualifier
.reset();
3839 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:388:47: ( typeSpecifier )*
3840 while ( stream_typeSpecifier
.hasNext() ) {
3841 adaptor
.addChild(root_1
, stream_typeSpecifier
.nextTree());
3843 stream_typeSpecifier
.reset();
3845 adaptor
.addChild(root_0
, root_1
);
3851 retval
.tree
= root_0
;
3856 retval
.stop
= input
.LT(-1);
3858 if ( state
.backtracking
==0 ) {
3859 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
3860 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
3864 catch (RecognitionException e
) {
3869 // do for sure before leaving
3873 // $ANTLR end "specifierQualifierList"
3876 public static class structOrVariantDeclaratorList_return
extends ParserRuleReturnScope
{
3879 public CommonTree
getTree() { return tree
; }
3883 // $ANTLR start "structOrVariantDeclaratorList"
3884 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:391:1: structOrVariantDeclaratorList : structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ ) ;
3885 public final CTFParser
.structOrVariantDeclaratorList_return
structOrVariantDeclaratorList() throws RecognitionException
{
3886 CTFParser
.structOrVariantDeclaratorList_return retval
= new CTFParser
.structOrVariantDeclaratorList_return();
3887 retval
.start
= input
.LT(1);
3889 CommonTree root_0
= null;
3891 Token SEPARATOR84
=null;
3892 ParserRuleReturnScope structOrVariantDeclarator83
=null;
3893 ParserRuleReturnScope structOrVariantDeclarator85
=null;
3895 CommonTree SEPARATOR84_tree
=null;
3896 RewriteRuleTokenStream stream_SEPARATOR
=new RewriteRuleTokenStream(adaptor
,"token SEPARATOR");
3897 RewriteRuleSubtreeStream stream_structOrVariantDeclarator
=new RewriteRuleSubtreeStream(adaptor
,"rule structOrVariantDeclarator");
3900 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:392:3: ( structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ ) )
3901 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:392:5: structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )*
3903 pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1873
);
3904 structOrVariantDeclarator83
=structOrVariantDeclarator();
3906 if (state
.failed
) return retval
;
3907 if ( state
.backtracking
==0 ) stream_structOrVariantDeclarator
.add(structOrVariantDeclarator83
.getTree());
3908 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:392:31: ( SEPARATOR structOrVariantDeclarator )*
3912 int LA27_0
= input
.LA(1);
3913 if ( (LA27_0
==SEPARATOR
) ) {
3919 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:392:32: SEPARATOR structOrVariantDeclarator
3921 SEPARATOR84
=(Token
)match(input
,SEPARATOR
,FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1876
); if (state
.failed
) return retval
;
3922 if ( state
.backtracking
==0 ) stream_SEPARATOR
.add(SEPARATOR84
);
3924 pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1878
);
3925 structOrVariantDeclarator85
=structOrVariantDeclarator();
3927 if (state
.failed
) return retval
;
3928 if ( state
.backtracking
==0 ) stream_structOrVariantDeclarator
.add(structOrVariantDeclarator85
.getTree());
3938 // elements: structOrVariantDeclarator
3940 // rule labels: retval
3941 // token list labels:
3942 // rule list labels:
3944 if ( state
.backtracking
==0 ) {
3945 retval
.tree
= root_0
;
3946 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
3948 root_0
= (CommonTree
)adaptor
.nil();
3949 // 393:7: -> ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ )
3951 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:393:10: ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ )
3953 CommonTree root_1
= (CommonTree
)adaptor
.nil();
3954 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_DECLARATOR_LIST
, "TYPE_DECLARATOR_LIST"), root_1
);
3955 if ( !(stream_structOrVariantDeclarator
.hasNext()) ) {
3956 throw new RewriteEarlyExitException();
3958 while ( stream_structOrVariantDeclarator
.hasNext() ) {
3959 adaptor
.addChild(root_1
, stream_structOrVariantDeclarator
.nextTree());
3961 stream_structOrVariantDeclarator
.reset();
3963 adaptor
.addChild(root_0
, root_1
);
3969 retval
.tree
= root_0
;
3974 retval
.stop
= input
.LT(-1);
3976 if ( state
.backtracking
==0 ) {
3977 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
3978 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
3982 catch (RecognitionException e
) {
3987 // do for sure before leaving
3991 // $ANTLR end "structOrVariantDeclaratorList"
3994 public static class structOrVariantDeclarator_return
extends ParserRuleReturnScope
{
3997 public CommonTree
getTree() { return tree
; }
4001 // $ANTLR start "structOrVariantDeclarator"
4002 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:396:1: structOrVariantDeclarator : ( declarator ( COLON numberLiteral )? ) -> declarator ;
4003 public final CTFParser
.structOrVariantDeclarator_return
structOrVariantDeclarator() throws RecognitionException
{
4004 CTFParser
.structOrVariantDeclarator_return retval
= new CTFParser
.structOrVariantDeclarator_return();
4005 retval
.start
= input
.LT(1);
4007 CommonTree root_0
= null;
4010 ParserRuleReturnScope declarator86
=null;
4011 ParserRuleReturnScope numberLiteral88
=null;
4013 CommonTree COLON87_tree
=null;
4014 RewriteRuleTokenStream stream_COLON
=new RewriteRuleTokenStream(adaptor
,"token COLON");
4015 RewriteRuleSubtreeStream stream_declarator
=new RewriteRuleSubtreeStream(adaptor
,"rule declarator");
4016 RewriteRuleSubtreeStream stream_numberLiteral
=new RewriteRuleSubtreeStream(adaptor
,"rule numberLiteral");
4019 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:397:3: ( ( declarator ( COLON numberLiteral )? ) -> declarator )
4020 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:399:5: ( declarator ( COLON numberLiteral )? )
4022 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:399:5: ( declarator ( COLON numberLiteral )? )
4023 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:399:6: declarator ( COLON numberLiteral )?
4025 pushFollow(FOLLOW_declarator_in_structOrVariantDeclarator1917
);
4026 declarator86
=declarator();
4028 if (state
.failed
) return retval
;
4029 if ( state
.backtracking
==0 ) stream_declarator
.add(declarator86
.getTree());
4030 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:399:17: ( COLON numberLiteral )?
4032 int LA28_0
= input
.LA(1);
4033 if ( (LA28_0
==COLON
) ) {
4038 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:399:18: COLON numberLiteral
4040 COLON87
=(Token
)match(input
,COLON
,FOLLOW_COLON_in_structOrVariantDeclarator1920
); if (state
.failed
) return retval
;
4041 if ( state
.backtracking
==0 ) stream_COLON
.add(COLON87
);
4043 pushFollow(FOLLOW_numberLiteral_in_structOrVariantDeclarator1922
);
4044 numberLiteral88
=numberLiteral();
4046 if (state
.failed
) return retval
;
4047 if ( state
.backtracking
==0 ) stream_numberLiteral
.add(numberLiteral88
.getTree());
4056 // elements: declarator
4058 // rule labels: retval
4059 // token list labels:
4060 // rule list labels:
4062 if ( state
.backtracking
==0 ) {
4063 retval
.tree
= root_0
;
4064 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
4066 root_0
= (CommonTree
)adaptor
.nil();
4067 // 399:41: -> declarator
4069 adaptor
.addChild(root_0
, stream_declarator
.nextTree());
4073 retval
.tree
= root_0
;
4078 retval
.stop
= input
.LT(-1);
4080 if ( state
.backtracking
==0 ) {
4081 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
4082 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
4086 catch (RecognitionException e
) {
4091 // do for sure before leaving
4095 // $ANTLR end "structOrVariantDeclarator"
4098 public static class variantSpecifier_return
extends ParserRuleReturnScope
{
4101 public CommonTree
getTree() { return tree
; }
4105 // $ANTLR start "variantSpecifier"
4106 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:403:1: variantSpecifier : VARIANTTOK ( ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? ) ;
4107 public final CTFParser
.variantSpecifier_return
variantSpecifier() throws RecognitionException
{
4108 CTFParser
.variantSpecifier_return retval
= new CTFParser
.variantSpecifier_return();
4109 retval
.start
= input
.LT(1);
4111 CommonTree root_0
= null;
4113 Token VARIANTTOK89
=null;
4114 ParserRuleReturnScope variantName90
=null;
4115 ParserRuleReturnScope variantTag91
=null;
4116 ParserRuleReturnScope variantBody92
=null;
4117 ParserRuleReturnScope variantBody93
=null;
4118 ParserRuleReturnScope variantTag94
=null;
4119 ParserRuleReturnScope variantBody95
=null;
4120 ParserRuleReturnScope variantBody96
=null;
4122 CommonTree VARIANTTOK89_tree
=null;
4123 RewriteRuleTokenStream stream_VARIANTTOK
=new RewriteRuleTokenStream(adaptor
,"token VARIANTTOK");
4124 RewriteRuleSubtreeStream stream_variantBody
=new RewriteRuleSubtreeStream(adaptor
,"rule variantBody");
4125 RewriteRuleSubtreeStream stream_variantTag
=new RewriteRuleSubtreeStream(adaptor
,"rule variantTag");
4126 RewriteRuleSubtreeStream stream_variantName
=new RewriteRuleSubtreeStream(adaptor
,"rule variantName");
4129 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:404:3: ( VARIANTTOK ( ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? ) )
4130 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:404:5: VARIANTTOK ( ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody )
4132 VARIANTTOK89
=(Token
)match(input
,VARIANTTOK
,FOLLOW_VARIANTTOK_in_variantSpecifier1946
); if (state
.failed
) return retval
;
4133 if ( state
.backtracking
==0 ) stream_VARIANTTOK
.add(VARIANTTOK89
);
4135 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:405:3: ( ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody )
4137 switch ( input
.LA(1) ) {
4154 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4155 NoViableAltException nvae
=
4156 new NoViableAltException("", 31, 0, input
);
4161 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:406:5: ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) )
4163 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:406:5: ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) )
4164 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:407:7: variantName ( ( variantTag ( variantBody |) ) | variantBody )
4166 pushFollow(FOLLOW_variantName_in_variantSpecifier1964
);
4167 variantName90
=variantName();
4169 if (state
.failed
) return retval
;
4170 if ( state
.backtracking
==0 ) stream_variantName
.add(variantName90
.getTree());
4171 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:408:7: ( ( variantTag ( variantBody |) ) | variantBody )
4173 int LA30_0
= input
.LA(1);
4174 if ( (LA30_0
==LT
) ) {
4177 else if ( (LA30_0
==LCURL
) ) {
4182 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4183 NoViableAltException nvae
=
4184 new NoViableAltException("", 30, 0, input
);
4190 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:409:9: ( variantTag ( variantBody |) )
4192 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:409:9: ( variantTag ( variantBody |) )
4193 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:410:11: variantTag ( variantBody |)
4195 pushFollow(FOLLOW_variantTag_in_variantSpecifier1994
);
4196 variantTag91
=variantTag();
4198 if (state
.failed
) return retval
;
4199 if ( state
.backtracking
==0 ) stream_variantTag
.add(variantTag91
.getTree());
4200 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:411:11: ( variantBody |)
4202 int LA29_0
= input
.LA(1);
4203 if ( (LA29_0
==LCURL
) ) {
4204 switch ( input
.LA(2) ) {
4211 case FLOATINGPOINTTOK
:
4230 int LA29_4
= input
.LA(3);
4231 if ( (LA29_4
==BOOLTOK
||LA29_4
==CHARTOK
||(LA29_4
>= COMPLEXTOK
&& LA29_4
<= CONSTTOK
)||LA29_4
==DOUBLETOK
||LA29_4
==ENUMTOK
||(LA29_4
>= FLOATINGPOINTTOK
&& LA29_4
<= FLOATTOK
)||(LA29_4
>= IDENTIFIER
&& LA29_4
<= IMAGINARYTOK
)||LA29_4
==INTEGERTOK
||LA29_4
==INTTOK
||LA29_4
==LONGTOK
||LA29_4
==POINTER
||LA29_4
==SHORTTOK
||LA29_4
==SIGNEDTOK
||LA29_4
==STRINGTOK
||LA29_4
==STRUCTTOK
||LA29_4
==TYPEDEFTOK
||(LA29_4
>= UNSIGNEDTOK
&& LA29_4
<= VOIDTOK
)) ) {
4234 else if ( (LA29_4
==ASSIGNMENT
||LA29_4
==RCURL
||LA29_4
==SEPARATOR
) ) {
4239 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4240 int nvaeMark
= input
.mark();
4242 for (int nvaeConsume
= 0; nvaeConsume
< 3 - 1; nvaeConsume
++) {
4245 NoViableAltException nvae
=
4246 new NoViableAltException("", 29, 4, input
);
4249 input
.rewind(nvaeMark
);
4257 int LA29_5
= input
.LA(3);
4258 if ( (LA29_5
==BOOLTOK
||LA29_5
==CHARTOK
||(LA29_5
>= COMPLEXTOK
&& LA29_5
<= CONSTTOK
)||LA29_5
==DOUBLETOK
||LA29_5
==ENUMTOK
||(LA29_5
>= FLOATINGPOINTTOK
&& LA29_5
<= FLOATTOK
)||(LA29_5
>= IDENTIFIER
&& LA29_5
<= IMAGINARYTOK
)||LA29_5
==INTEGERTOK
||(LA29_5
>= INTTOK
&& LA29_5
<= LCURL
)||LA29_5
==LONGTOK
||LA29_5
==POINTER
||LA29_5
==SHORTTOK
||LA29_5
==SIGNEDTOK
||LA29_5
==STRINGTOK
||LA29_5
==STRUCTTOK
||LA29_5
==TYPEDEFTOK
||(LA29_5
>= UNSIGNEDTOK
&& LA29_5
<= VOIDTOK
)) ) {
4261 else if ( (LA29_5
==ASSIGNMENT
||LA29_5
==RCURL
||LA29_5
==SEPARATOR
) ) {
4266 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4267 int nvaeMark
= input
.mark();
4269 for (int nvaeConsume
= 0; nvaeConsume
< 3 - 1; nvaeConsume
++) {
4272 NoViableAltException nvae
=
4273 new NoViableAltException("", 29, 5, input
);
4276 input
.rewind(nvaeMark
);
4284 int LA29_6
= input
.LA(3);
4285 if ( (LA29_6
==BOOLTOK
||LA29_6
==CHARTOK
||(LA29_6
>= COMPLEXTOK
&& LA29_6
<= CONSTTOK
)||LA29_6
==DOUBLETOK
||LA29_6
==ENUMTOK
||(LA29_6
>= FLOATINGPOINTTOK
&& LA29_6
<= FLOATTOK
)||(LA29_6
>= IDENTIFIER
&& LA29_6
<= IMAGINARYTOK
)||LA29_6
==INTEGERTOK
||LA29_6
==INTTOK
||LA29_6
==LONGTOK
||LA29_6
==POINTER
||LA29_6
==SHORTTOK
||LA29_6
==SIGNEDTOK
||LA29_6
==STRINGTOK
||LA29_6
==STRUCTTOK
||LA29_6
==TYPEDEFTOK
||(LA29_6
>= UNSIGNEDTOK
&& LA29_6
<= VOIDTOK
)) ) {
4288 else if ( (LA29_6
==ASSIGNMENT
||LA29_6
==RCURL
||LA29_6
==SEPARATOR
) ) {
4293 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4294 int nvaeMark
= input
.mark();
4296 for (int nvaeConsume
= 0; nvaeConsume
< 3 - 1; nvaeConsume
++) {
4299 NoViableAltException nvae
=
4300 new NoViableAltException("", 29, 6, input
);
4303 input
.rewind(nvaeMark
);
4311 case STRING_LITERAL
:
4317 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4318 int nvaeMark
= input
.mark();
4321 NoViableAltException nvae
=
4322 new NoViableAltException("", 29, 1, input
);
4325 input
.rewind(nvaeMark
);
4329 else if ( (LA29_0
==EOF
||LA29_0
==BOOLTOK
||LA29_0
==CHARTOK
||(LA29_0
>= COMPLEXTOK
&& LA29_0
<= CONSTTOK
)||LA29_0
==DOUBLETOK
||LA29_0
==ENUMTOK
||(LA29_0
>= FLOATINGPOINTTOK
&& LA29_0
<= FLOATTOK
)||(LA29_0
>= IDENTIFIER
&& LA29_0
<= IMAGINARYTOK
)||LA29_0
==INTEGERTOK
||LA29_0
==INTTOK
||(LA29_0
>= LONGTOK
&& LA29_0
<= LPAREN
)||LA29_0
==POINTER
||LA29_0
==SHORTTOK
||LA29_0
==SIGNEDTOK
||LA29_0
==STRINGTOK
||(LA29_0
>= STRUCTTOK
&& LA29_0
<= TERM
)||(LA29_0
>= TYPEDEFTOK
&& LA29_0
<= TYPE_ASSIGNMENT
)||(LA29_0
>= UNSIGNEDTOK
&& LA29_0
<= VOIDTOK
)) ) {
4334 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4335 NoViableAltException nvae
=
4336 new NoViableAltException("", 29, 0, input
);
4342 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:412:13: variantBody
4344 pushFollow(FOLLOW_variantBody_in_variantSpecifier2020
);
4345 variantBody92
=variantBody();
4347 if (state
.failed
) return retval
;
4348 if ( state
.backtracking
==0 ) stream_variantBody
.add(variantBody92
.getTree());
4352 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:415:11:
4364 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:418:9: variantBody
4366 pushFollow(FOLLOW_variantBody_in_variantSpecifier2088
);
4367 variantBody93
=variantBody();
4369 if (state
.failed
) return retval
;
4370 if ( state
.backtracking
==0 ) stream_variantBody
.add(variantBody93
.getTree());
4381 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:421:5: ( variantTag variantBody )
4383 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:421:5: ( variantTag variantBody )
4384 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:421:6: variantTag variantBody
4386 pushFollow(FOLLOW_variantTag_in_variantSpecifier2109
);
4387 variantTag94
=variantTag();
4389 if (state
.failed
) return retval
;
4390 if ( state
.backtracking
==0 ) stream_variantTag
.add(variantTag94
.getTree());
4391 pushFollow(FOLLOW_variantBody_in_variantSpecifier2111
);
4392 variantBody95
=variantBody();
4394 if (state
.failed
) return retval
;
4395 if ( state
.backtracking
==0 ) stream_variantBody
.add(variantBody95
.getTree());
4401 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:422:5: variantBody
4403 pushFollow(FOLLOW_variantBody_in_variantSpecifier2118
);
4404 variantBody96
=variantBody();
4406 if (state
.failed
) return retval
;
4407 if ( state
.backtracking
==0 ) stream_variantBody
.add(variantBody96
.getTree());
4414 // elements: variantTag, variantBody, variantName
4416 // rule labels: retval
4417 // token list labels:
4418 // rule list labels:
4420 if ( state
.backtracking
==0 ) {
4421 retval
.tree
= root_0
;
4422 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
4424 root_0
= (CommonTree
)adaptor
.nil();
4425 // 423:5: -> ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? )
4427 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:423:8: ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? )
4429 CommonTree root_1
= (CommonTree
)adaptor
.nil();
4430 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(VARIANT
, "VARIANT"), root_1
);
4431 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:423:18: ( variantName )?
4432 if ( stream_variantName
.hasNext() ) {
4433 adaptor
.addChild(root_1
, stream_variantName
.nextTree());
4435 stream_variantName
.reset();
4437 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:423:31: ( variantTag )?
4438 if ( stream_variantTag
.hasNext() ) {
4439 adaptor
.addChild(root_1
, stream_variantTag
.nextTree());
4441 stream_variantTag
.reset();
4443 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:423:43: ( variantBody )?
4444 if ( stream_variantBody
.hasNext() ) {
4445 adaptor
.addChild(root_1
, stream_variantBody
.nextTree());
4447 stream_variantBody
.reset();
4449 adaptor
.addChild(root_0
, root_1
);
4455 retval
.tree
= root_0
;
4460 retval
.stop
= input
.LT(-1);
4462 if ( state
.backtracking
==0 ) {
4463 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
4464 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
4468 catch (RecognitionException e
) {
4473 // do for sure before leaving
4477 // $ANTLR end "variantSpecifier"
4480 public static class variantName_return
extends ParserRuleReturnScope
{
4483 public CommonTree
getTree() { return tree
; }
4487 // $ANTLR start "variantName"
4488 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:426:1: variantName : IDENTIFIER -> ^( VARIANT_NAME IDENTIFIER ) ;
4489 public final CTFParser
.variantName_return
variantName() throws RecognitionException
{
4490 CTFParser
.variantName_return retval
= new CTFParser
.variantName_return();
4491 retval
.start
= input
.LT(1);
4493 CommonTree root_0
= null;
4495 Token IDENTIFIER97
=null;
4497 CommonTree IDENTIFIER97_tree
=null;
4498 RewriteRuleTokenStream stream_IDENTIFIER
=new RewriteRuleTokenStream(adaptor
,"token IDENTIFIER");
4501 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:427:3: ( IDENTIFIER -> ^( VARIANT_NAME IDENTIFIER ) )
4502 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:427:5: IDENTIFIER
4504 IDENTIFIER97
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_variantName2150
); if (state
.failed
) return retval
;
4505 if ( state
.backtracking
==0 ) stream_IDENTIFIER
.add(IDENTIFIER97
);
4508 // elements: IDENTIFIER
4510 // rule labels: retval
4511 // token list labels:
4512 // rule list labels:
4514 if ( state
.backtracking
==0 ) {
4515 retval
.tree
= root_0
;
4516 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
4518 root_0
= (CommonTree
)adaptor
.nil();
4519 // 427:16: -> ^( VARIANT_NAME IDENTIFIER )
4521 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:427:19: ^( VARIANT_NAME IDENTIFIER )
4523 CommonTree root_1
= (CommonTree
)adaptor
.nil();
4524 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(VARIANT_NAME
, "VARIANT_NAME"), root_1
);
4525 adaptor
.addChild(root_1
, stream_IDENTIFIER
.nextNode());
4526 adaptor
.addChild(root_0
, root_1
);
4532 retval
.tree
= root_0
;
4537 retval
.stop
= input
.LT(-1);
4539 if ( state
.backtracking
==0 ) {
4540 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
4541 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
4545 catch (RecognitionException e
) {
4550 // do for sure before leaving
4554 // $ANTLR end "variantName"
4557 public static class variantBody_return
extends ParserRuleReturnScope
{
4560 public CommonTree
getTree() { return tree
; }
4564 // $ANTLR start "variantBody"
4565 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:430:1: variantBody : LCURL structOrVariantDeclarationList RCURL -> ^( VARIANT_BODY structOrVariantDeclarationList ) ;
4566 public final CTFParser
.variantBody_return
variantBody() throws RecognitionException
{
4567 Symbols_stack
.push(new Symbols_scope());
4569 CTFParser
.variantBody_return retval
= new CTFParser
.variantBody_return();
4570 retval
.start
= input
.LT(1);
4572 CommonTree root_0
= null;
4575 Token RCURL100
=null;
4576 ParserRuleReturnScope structOrVariantDeclarationList99
=null;
4578 CommonTree LCURL98_tree
=null;
4579 CommonTree RCURL100_tree
=null;
4580 RewriteRuleTokenStream stream_LCURL
=new RewriteRuleTokenStream(adaptor
,"token LCURL");
4581 RewriteRuleTokenStream stream_RCURL
=new RewriteRuleTokenStream(adaptor
,"token RCURL");
4582 RewriteRuleSubtreeStream stream_structOrVariantDeclarationList
=new RewriteRuleSubtreeStream(adaptor
,"rule structOrVariantDeclarationList");
4585 Symbols_stack
.peek().types
= new HashSet
<String
>();
4588 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:435:3: ( LCURL structOrVariantDeclarationList RCURL -> ^( VARIANT_BODY structOrVariantDeclarationList ) )
4589 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:435:5: LCURL structOrVariantDeclarationList RCURL
4591 LCURL98
=(Token
)match(input
,LCURL
,FOLLOW_LCURL_in_variantBody2181
); if (state
.failed
) return retval
;
4592 if ( state
.backtracking
==0 ) stream_LCURL
.add(LCURL98
);
4594 pushFollow(FOLLOW_structOrVariantDeclarationList_in_variantBody2183
);
4595 structOrVariantDeclarationList99
=structOrVariantDeclarationList();
4597 if (state
.failed
) return retval
;
4598 if ( state
.backtracking
==0 ) stream_structOrVariantDeclarationList
.add(structOrVariantDeclarationList99
.getTree());
4599 RCURL100
=(Token
)match(input
,RCURL
,FOLLOW_RCURL_in_variantBody2185
); if (state
.failed
) return retval
;
4600 if ( state
.backtracking
==0 ) stream_RCURL
.add(RCURL100
);
4603 // elements: structOrVariantDeclarationList
4605 // rule labels: retval
4606 // token list labels:
4607 // rule list labels:
4609 if ( state
.backtracking
==0 ) {
4610 retval
.tree
= root_0
;
4611 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
4613 root_0
= (CommonTree
)adaptor
.nil();
4614 // 436:7: -> ^( VARIANT_BODY structOrVariantDeclarationList )
4616 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:436:10: ^( VARIANT_BODY structOrVariantDeclarationList )
4618 CommonTree root_1
= (CommonTree
)adaptor
.nil();
4619 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(VARIANT_BODY
, "VARIANT_BODY"), root_1
);
4620 adaptor
.addChild(root_1
, stream_structOrVariantDeclarationList
.nextTree());
4621 adaptor
.addChild(root_0
, root_1
);
4627 retval
.tree
= root_0
;
4632 retval
.stop
= input
.LT(-1);
4634 if ( state
.backtracking
==0 ) {
4635 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
4636 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
4640 catch (RecognitionException e
) {
4645 // do for sure before leaving
4646 Symbols_stack
.pop();
4651 // $ANTLR end "variantBody"
4654 public static class variantTag_return
extends ParserRuleReturnScope
{
4657 public CommonTree
getTree() { return tree
; }
4661 // $ANTLR start "variantTag"
4662 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:439:1: variantTag : LT IDENTIFIER GT -> ^( VARIANT_TAG IDENTIFIER ) ;
4663 public final CTFParser
.variantTag_return
variantTag() throws RecognitionException
{
4664 CTFParser
.variantTag_return retval
= new CTFParser
.variantTag_return();
4665 retval
.start
= input
.LT(1);
4667 CommonTree root_0
= null;
4670 Token IDENTIFIER102
=null;
4673 CommonTree LT101_tree
=null;
4674 CommonTree IDENTIFIER102_tree
=null;
4675 CommonTree GT103_tree
=null;
4676 RewriteRuleTokenStream stream_LT
=new RewriteRuleTokenStream(adaptor
,"token LT");
4677 RewriteRuleTokenStream stream_IDENTIFIER
=new RewriteRuleTokenStream(adaptor
,"token IDENTIFIER");
4678 RewriteRuleTokenStream stream_GT
=new RewriteRuleTokenStream(adaptor
,"token GT");
4681 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:440:3: ( LT IDENTIFIER GT -> ^( VARIANT_TAG IDENTIFIER ) )
4682 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:440:5: LT IDENTIFIER GT
4684 LT101
=(Token
)match(input
,LT
,FOLLOW_LT_in_variantTag2212
); if (state
.failed
) return retval
;
4685 if ( state
.backtracking
==0 ) stream_LT
.add(LT101
);
4687 IDENTIFIER102
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_variantTag2214
); if (state
.failed
) return retval
;
4688 if ( state
.backtracking
==0 ) stream_IDENTIFIER
.add(IDENTIFIER102
);
4690 GT103
=(Token
)match(input
,GT
,FOLLOW_GT_in_variantTag2216
); if (state
.failed
) return retval
;
4691 if ( state
.backtracking
==0 ) stream_GT
.add(GT103
);
4694 // elements: IDENTIFIER
4696 // rule labels: retval
4697 // token list labels:
4698 // rule list labels:
4700 if ( state
.backtracking
==0 ) {
4701 retval
.tree
= root_0
;
4702 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
4704 root_0
= (CommonTree
)adaptor
.nil();
4705 // 440:22: -> ^( VARIANT_TAG IDENTIFIER )
4707 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:440:25: ^( VARIANT_TAG IDENTIFIER )
4709 CommonTree root_1
= (CommonTree
)adaptor
.nil();
4710 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(VARIANT_TAG
, "VARIANT_TAG"), root_1
);
4711 adaptor
.addChild(root_1
, stream_IDENTIFIER
.nextNode());
4712 adaptor
.addChild(root_0
, root_1
);
4718 retval
.tree
= root_0
;
4723 retval
.stop
= input
.LT(-1);
4725 if ( state
.backtracking
==0 ) {
4726 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
4727 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
4731 catch (RecognitionException e
) {
4736 // do for sure before leaving
4740 // $ANTLR end "variantTag"
4743 public static class enumSpecifier_return
extends ParserRuleReturnScope
{
4746 public CommonTree
getTree() { return tree
; }
4750 // $ANTLR start "enumSpecifier"
4751 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:443:1: enumSpecifier : ENUMTOK ( ( enumName ( enumContainerType enumBody | enumBody |) ) | ( enumContainerType enumBody | enumBody ) ) -> ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? ) ;
4752 public final CTFParser
.enumSpecifier_return
enumSpecifier() throws RecognitionException
{
4753 CTFParser
.enumSpecifier_return retval
= new CTFParser
.enumSpecifier_return();
4754 retval
.start
= input
.LT(1);
4756 CommonTree root_0
= null;
4758 Token ENUMTOK104
=null;
4759 ParserRuleReturnScope enumName105
=null;
4760 ParserRuleReturnScope enumContainerType106
=null;
4761 ParserRuleReturnScope enumBody107
=null;
4762 ParserRuleReturnScope enumBody108
=null;
4763 ParserRuleReturnScope enumContainerType109
=null;
4764 ParserRuleReturnScope enumBody110
=null;
4765 ParserRuleReturnScope enumBody111
=null;
4767 CommonTree ENUMTOK104_tree
=null;
4768 RewriteRuleTokenStream stream_ENUMTOK
=new RewriteRuleTokenStream(adaptor
,"token ENUMTOK");
4769 RewriteRuleSubtreeStream stream_enumBody
=new RewriteRuleSubtreeStream(adaptor
,"rule enumBody");
4770 RewriteRuleSubtreeStream stream_enumName
=new RewriteRuleSubtreeStream(adaptor
,"rule enumName");
4771 RewriteRuleSubtreeStream stream_enumContainerType
=new RewriteRuleSubtreeStream(adaptor
,"rule enumContainerType");
4774 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:444:3: ( ENUMTOK ( ( enumName ( enumContainerType enumBody | enumBody |) ) | ( enumContainerType enumBody | enumBody ) ) -> ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? ) )
4775 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:444:5: ENUMTOK ( ( enumName ( enumContainerType enumBody | enumBody |) ) | ( enumContainerType enumBody | enumBody ) )
4777 ENUMTOK104
=(Token
)match(input
,ENUMTOK
,FOLLOW_ENUMTOK_in_enumSpecifier2237
); if (state
.failed
) return retval
;
4778 if ( state
.backtracking
==0 ) stream_ENUMTOK
.add(ENUMTOK104
);
4780 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:445:5: ( ( enumName ( enumContainerType enumBody | enumBody |) ) | ( enumContainerType enumBody | enumBody ) )
4782 int LA34_0
= input
.LA(1);
4783 if ( (LA34_0
==IDENTIFIER
) ) {
4786 else if ( (LA34_0
==COLON
||LA34_0
==LCURL
) ) {
4791 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4792 NoViableAltException nvae
=
4793 new NoViableAltException("", 34, 0, input
);
4799 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:447:9: ( enumName ( enumContainerType enumBody | enumBody |) )
4801 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:447:9: ( enumName ( enumContainerType enumBody | enumBody |) )
4802 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:448:13: enumName ( enumContainerType enumBody | enumBody |)
4804 pushFollow(FOLLOW_enumName_in_enumSpecifier2276
);
4805 enumName105
=enumName();
4807 if (state
.failed
) return retval
;
4808 if ( state
.backtracking
==0 ) stream_enumName
.add(enumName105
.getTree());
4809 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:449:13: ( enumContainerType enumBody | enumBody |)
4811 switch ( input
.LA(1) ) {
4829 case FLOATINGPOINTTOK
:
4844 case TYPE_ASSIGNMENT
:
4853 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4854 NoViableAltException nvae
=
4855 new NoViableAltException("", 32, 0, input
);
4860 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:450:17: enumContainerType enumBody
4862 pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2308
);
4863 enumContainerType106
=enumContainerType();
4865 if (state
.failed
) return retval
;
4866 if ( state
.backtracking
==0 ) stream_enumContainerType
.add(enumContainerType106
.getTree());
4867 pushFollow(FOLLOW_enumBody_in_enumSpecifier2310
);
4868 enumBody107
=enumBody();
4870 if (state
.failed
) return retval
;
4871 if ( state
.backtracking
==0 ) stream_enumBody
.add(enumBody107
.getTree());
4875 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:452:17: enumBody
4877 pushFollow(FOLLOW_enumBody_in_enumSpecifier2340
);
4878 enumBody108
=enumBody();
4880 if (state
.failed
) return retval
;
4881 if ( state
.backtracking
==0 ) stream_enumBody
.add(enumBody108
.getTree());
4885 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:455:13:
4897 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:459:9: ( enumContainerType enumBody | enumBody )
4899 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:459:9: ( enumContainerType enumBody | enumBody )
4901 int LA33_0
= input
.LA(1);
4902 if ( (LA33_0
==COLON
) ) {
4905 else if ( (LA33_0
==LCURL
) ) {
4910 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
4911 NoViableAltException nvae
=
4912 new NoViableAltException("", 33, 0, input
);
4918 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:460:13: enumContainerType enumBody
4920 pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2432
);
4921 enumContainerType109
=enumContainerType();
4923 if (state
.failed
) return retval
;
4924 if ( state
.backtracking
==0 ) stream_enumContainerType
.add(enumContainerType109
.getTree());
4925 pushFollow(FOLLOW_enumBody_in_enumSpecifier2434
);
4926 enumBody110
=enumBody();
4928 if (state
.failed
) return retval
;
4929 if ( state
.backtracking
==0 ) stream_enumBody
.add(enumBody110
.getTree());
4933 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:462:13: enumBody
4935 pushFollow(FOLLOW_enumBody_in_enumSpecifier2458
);
4936 enumBody111
=enumBody();
4938 if (state
.failed
) return retval
;
4939 if ( state
.backtracking
==0 ) stream_enumBody
.add(enumBody111
.getTree());
4951 // elements: enumName, enumBody, enumContainerType
4953 // rule labels: retval
4954 // token list labels:
4955 // rule list labels:
4957 if ( state
.backtracking
==0 ) {
4958 retval
.tree
= root_0
;
4959 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
4961 root_0
= (CommonTree
)adaptor
.nil();
4962 // 464:7: -> ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? )
4964 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:464:10: ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? )
4966 CommonTree root_1
= (CommonTree
)adaptor
.nil();
4967 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ENUM
, "ENUM"), root_1
);
4968 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:464:17: ( enumName )?
4969 if ( stream_enumName
.hasNext() ) {
4970 adaptor
.addChild(root_1
, stream_enumName
.nextTree());
4972 stream_enumName
.reset();
4974 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:464:27: ( enumContainerType )?
4975 if ( stream_enumContainerType
.hasNext() ) {
4976 adaptor
.addChild(root_1
, stream_enumContainerType
.nextTree());
4978 stream_enumContainerType
.reset();
4980 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:464:46: ( enumBody )?
4981 if ( stream_enumBody
.hasNext() ) {
4982 adaptor
.addChild(root_1
, stream_enumBody
.nextTree());
4984 stream_enumBody
.reset();
4986 adaptor
.addChild(root_0
, root_1
);
4992 retval
.tree
= root_0
;
4997 retval
.stop
= input
.LT(-1);
4999 if ( state
.backtracking
==0 ) {
5000 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5001 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5005 catch (RecognitionException e
) {
5010 // do for sure before leaving
5014 // $ANTLR end "enumSpecifier"
5017 public static class enumName_return
extends ParserRuleReturnScope
{
5020 public CommonTree
getTree() { return tree
; }
5024 // $ANTLR start "enumName"
5025 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:467:1: enumName : IDENTIFIER -> ^( ENUM_NAME IDENTIFIER ) ;
5026 public final CTFParser
.enumName_return
enumName() throws RecognitionException
{
5027 CTFParser
.enumName_return retval
= new CTFParser
.enumName_return();
5028 retval
.start
= input
.LT(1);
5030 CommonTree root_0
= null;
5032 Token IDENTIFIER112
=null;
5034 CommonTree IDENTIFIER112_tree
=null;
5035 RewriteRuleTokenStream stream_IDENTIFIER
=new RewriteRuleTokenStream(adaptor
,"token IDENTIFIER");
5038 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:468:3: ( IDENTIFIER -> ^( ENUM_NAME IDENTIFIER ) )
5039 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:468:5: IDENTIFIER
5041 IDENTIFIER112
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_enumName2502
); if (state
.failed
) return retval
;
5042 if ( state
.backtracking
==0 ) stream_IDENTIFIER
.add(IDENTIFIER112
);
5045 // elements: IDENTIFIER
5047 // rule labels: retval
5048 // token list labels:
5049 // rule list labels:
5051 if ( state
.backtracking
==0 ) {
5052 retval
.tree
= root_0
;
5053 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
5055 root_0
= (CommonTree
)adaptor
.nil();
5056 // 468:16: -> ^( ENUM_NAME IDENTIFIER )
5058 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:468:19: ^( ENUM_NAME IDENTIFIER )
5060 CommonTree root_1
= (CommonTree
)adaptor
.nil();
5061 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ENUM_NAME
, "ENUM_NAME"), root_1
);
5062 adaptor
.addChild(root_1
, stream_IDENTIFIER
.nextNode());
5063 adaptor
.addChild(root_0
, root_1
);
5069 retval
.tree
= root_0
;
5074 retval
.stop
= input
.LT(-1);
5076 if ( state
.backtracking
==0 ) {
5077 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5078 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5082 catch (RecognitionException e
) {
5087 // do for sure before leaving
5091 // $ANTLR end "enumName"
5094 public static class enumBody_return
extends ParserRuleReturnScope
{
5097 public CommonTree
getTree() { return tree
; }
5101 // $ANTLR start "enumBody"
5102 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:471:1: enumBody : LCURL enumeratorList ( SEPARATOR )? RCURL -> ^( ENUM_BODY enumeratorList ) ;
5103 public final CTFParser
.enumBody_return
enumBody() throws RecognitionException
{
5104 CTFParser
.enumBody_return retval
= new CTFParser
.enumBody_return();
5105 retval
.start
= input
.LT(1);
5107 CommonTree root_0
= null;
5109 Token LCURL113
=null;
5110 Token SEPARATOR115
=null;
5111 Token RCURL116
=null;
5112 ParserRuleReturnScope enumeratorList114
=null;
5114 CommonTree LCURL113_tree
=null;
5115 CommonTree SEPARATOR115_tree
=null;
5116 CommonTree RCURL116_tree
=null;
5117 RewriteRuleTokenStream stream_SEPARATOR
=new RewriteRuleTokenStream(adaptor
,"token SEPARATOR");
5118 RewriteRuleTokenStream stream_LCURL
=new RewriteRuleTokenStream(adaptor
,"token LCURL");
5119 RewriteRuleTokenStream stream_RCURL
=new RewriteRuleTokenStream(adaptor
,"token RCURL");
5120 RewriteRuleSubtreeStream stream_enumeratorList
=new RewriteRuleSubtreeStream(adaptor
,"rule enumeratorList");
5123 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:472:3: ( LCURL enumeratorList ( SEPARATOR )? RCURL -> ^( ENUM_BODY enumeratorList ) )
5124 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:472:5: LCURL enumeratorList ( SEPARATOR )? RCURL
5126 LCURL113
=(Token
)match(input
,LCURL
,FOLLOW_LCURL_in_enumBody2523
); if (state
.failed
) return retval
;
5127 if ( state
.backtracking
==0 ) stream_LCURL
.add(LCURL113
);
5129 pushFollow(FOLLOW_enumeratorList_in_enumBody2525
);
5130 enumeratorList114
=enumeratorList();
5132 if (state
.failed
) return retval
;
5133 if ( state
.backtracking
==0 ) stream_enumeratorList
.add(enumeratorList114
.getTree());
5134 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:472:26: ( SEPARATOR )?
5136 int LA35_0
= input
.LA(1);
5137 if ( (LA35_0
==SEPARATOR
) ) {
5142 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:472:26: SEPARATOR
5144 SEPARATOR115
=(Token
)match(input
,SEPARATOR
,FOLLOW_SEPARATOR_in_enumBody2527
); if (state
.failed
) return retval
;
5145 if ( state
.backtracking
==0 ) stream_SEPARATOR
.add(SEPARATOR115
);
5152 RCURL116
=(Token
)match(input
,RCURL
,FOLLOW_RCURL_in_enumBody2530
); if (state
.failed
) return retval
;
5153 if ( state
.backtracking
==0 ) stream_RCURL
.add(RCURL116
);
5156 // elements: enumeratorList
5158 // rule labels: retval
5159 // token list labels:
5160 // rule list labels:
5162 if ( state
.backtracking
==0 ) {
5163 retval
.tree
= root_0
;
5164 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
5166 root_0
= (CommonTree
)adaptor
.nil();
5167 // 472:43: -> ^( ENUM_BODY enumeratorList )
5169 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:472:46: ^( ENUM_BODY enumeratorList )
5171 CommonTree root_1
= (CommonTree
)adaptor
.nil();
5172 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ENUM_BODY
, "ENUM_BODY"), root_1
);
5173 adaptor
.addChild(root_1
, stream_enumeratorList
.nextTree());
5174 adaptor
.addChild(root_0
, root_1
);
5180 retval
.tree
= root_0
;
5185 retval
.stop
= input
.LT(-1);
5187 if ( state
.backtracking
==0 ) {
5188 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5189 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5193 catch (RecognitionException e
) {
5198 // do for sure before leaving
5202 // $ANTLR end "enumBody"
5205 public static class enumContainerType_return
extends ParserRuleReturnScope
{
5208 public CommonTree
getTree() { return tree
; }
5212 // $ANTLR start "enumContainerType"
5213 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:475:1: enumContainerType : COLON declarationSpecifiers -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers ) ;
5214 public final CTFParser
.enumContainerType_return
enumContainerType() throws RecognitionException
{
5215 CTFParser
.enumContainerType_return retval
= new CTFParser
.enumContainerType_return();
5216 retval
.start
= input
.LT(1);
5218 CommonTree root_0
= null;
5220 Token COLON117
=null;
5221 ParserRuleReturnScope declarationSpecifiers118
=null;
5223 CommonTree COLON117_tree
=null;
5224 RewriteRuleTokenStream stream_COLON
=new RewriteRuleTokenStream(adaptor
,"token COLON");
5225 RewriteRuleSubtreeStream stream_declarationSpecifiers
=new RewriteRuleSubtreeStream(adaptor
,"rule declarationSpecifiers");
5228 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:476:3: ( COLON declarationSpecifiers -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers ) )
5229 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:476:5: COLON declarationSpecifiers
5231 COLON117
=(Token
)match(input
,COLON
,FOLLOW_COLON_in_enumContainerType2551
); if (state
.failed
) return retval
;
5232 if ( state
.backtracking
==0 ) stream_COLON
.add(COLON117
);
5234 pushFollow(FOLLOW_declarationSpecifiers_in_enumContainerType2553
);
5235 declarationSpecifiers118
=declarationSpecifiers();
5237 if (state
.failed
) return retval
;
5238 if ( state
.backtracking
==0 ) stream_declarationSpecifiers
.add(declarationSpecifiers118
.getTree());
5240 // elements: declarationSpecifiers
5242 // rule labels: retval
5243 // token list labels:
5244 // rule list labels:
5246 if ( state
.backtracking
==0 ) {
5247 retval
.tree
= root_0
;
5248 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
5250 root_0
= (CommonTree
)adaptor
.nil();
5251 // 476:33: -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
5253 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:476:36: ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
5255 CommonTree root_1
= (CommonTree
)adaptor
.nil();
5256 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ENUM_CONTAINER_TYPE
, "ENUM_CONTAINER_TYPE"), root_1
);
5257 adaptor
.addChild(root_1
, stream_declarationSpecifiers
.nextTree());
5258 adaptor
.addChild(root_0
, root_1
);
5264 retval
.tree
= root_0
;
5269 retval
.stop
= input
.LT(-1);
5271 if ( state
.backtracking
==0 ) {
5272 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5273 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5277 catch (RecognitionException e
) {
5282 // do for sure before leaving
5286 // $ANTLR end "enumContainerType"
5289 public static class enumeratorList_return
extends ParserRuleReturnScope
{
5292 public CommonTree
getTree() { return tree
; }
5296 // $ANTLR start "enumeratorList"
5297 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:479:1: enumeratorList : enumerator ( SEPARATOR enumerator )* -> ( ^( ENUM_ENUMERATOR enumerator ) )+ ;
5298 public final CTFParser
.enumeratorList_return
enumeratorList() throws RecognitionException
{
5299 CTFParser
.enumeratorList_return retval
= new CTFParser
.enumeratorList_return();
5300 retval
.start
= input
.LT(1);
5302 CommonTree root_0
= null;
5304 Token SEPARATOR120
=null;
5305 ParserRuleReturnScope enumerator119
=null;
5306 ParserRuleReturnScope enumerator121
=null;
5308 CommonTree SEPARATOR120_tree
=null;
5309 RewriteRuleTokenStream stream_SEPARATOR
=new RewriteRuleTokenStream(adaptor
,"token SEPARATOR");
5310 RewriteRuleSubtreeStream stream_enumerator
=new RewriteRuleSubtreeStream(adaptor
,"rule enumerator");
5313 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:480:3: ( enumerator ( SEPARATOR enumerator )* -> ( ^( ENUM_ENUMERATOR enumerator ) )+ )
5314 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:480:5: enumerator ( SEPARATOR enumerator )*
5316 pushFollow(FOLLOW_enumerator_in_enumeratorList2574
);
5317 enumerator119
=enumerator();
5319 if (state
.failed
) return retval
;
5320 if ( state
.backtracking
==0 ) stream_enumerator
.add(enumerator119
.getTree());
5321 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:480:16: ( SEPARATOR enumerator )*
5325 int LA36_0
= input
.LA(1);
5326 if ( (LA36_0
==SEPARATOR
) ) {
5327 int LA36_1
= input
.LA(2);
5328 if ( (LA36_1
==ALIGNTOK
||LA36_1
==EVENTTOK
||LA36_1
==IDENTIFIER
||LA36_1
==SIGNEDTOK
||LA36_1
==STRINGTOK
||LA36_1
==STRING_LITERAL
) ) {
5336 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:480:17: SEPARATOR enumerator
5338 SEPARATOR120
=(Token
)match(input
,SEPARATOR
,FOLLOW_SEPARATOR_in_enumeratorList2577
); if (state
.failed
) return retval
;
5339 if ( state
.backtracking
==0 ) stream_SEPARATOR
.add(SEPARATOR120
);
5341 pushFollow(FOLLOW_enumerator_in_enumeratorList2579
);
5342 enumerator121
=enumerator();
5344 if (state
.failed
) return retval
;
5345 if ( state
.backtracking
==0 ) stream_enumerator
.add(enumerator121
.getTree());
5355 // elements: enumerator
5357 // rule labels: retval
5358 // token list labels:
5359 // rule list labels:
5361 if ( state
.backtracking
==0 ) {
5362 retval
.tree
= root_0
;
5363 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
5365 root_0
= (CommonTree
)adaptor
.nil();
5366 // 480:40: -> ( ^( ENUM_ENUMERATOR enumerator ) )+
5368 if ( !(stream_enumerator
.hasNext()) ) {
5369 throw new RewriteEarlyExitException();
5371 while ( stream_enumerator
.hasNext() ) {
5372 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:480:44: ^( ENUM_ENUMERATOR enumerator )
5374 CommonTree root_1
= (CommonTree
)adaptor
.nil();
5375 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ENUM_ENUMERATOR
, "ENUM_ENUMERATOR"), root_1
);
5376 adaptor
.addChild(root_1
, stream_enumerator
.nextTree());
5377 adaptor
.addChild(root_0
, root_1
);
5381 stream_enumerator
.reset();
5386 retval
.tree
= root_0
;
5391 retval
.stop
= input
.LT(-1);
5393 if ( state
.backtracking
==0 ) {
5394 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5395 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5399 catch (RecognitionException e
) {
5404 // do for sure before leaving
5408 // $ANTLR end "enumeratorList"
5411 public static class enumerator_return
extends ParserRuleReturnScope
{
5414 public CommonTree
getTree() { return tree
; }
5418 // $ANTLR start "enumerator"
5419 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:483:1: enumerator : enumConstant ( enumeratorValue )? ;
5420 public final CTFParser
.enumerator_return
enumerator() throws RecognitionException
{
5421 CTFParser
.enumerator_return retval
= new CTFParser
.enumerator_return();
5422 retval
.start
= input
.LT(1);
5424 CommonTree root_0
= null;
5426 ParserRuleReturnScope enumConstant122
=null;
5427 ParserRuleReturnScope enumeratorValue123
=null;
5431 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:484:3: ( enumConstant ( enumeratorValue )? )
5432 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:484:5: enumConstant ( enumeratorValue )?
5434 root_0
= (CommonTree
)adaptor
.nil();
5437 pushFollow(FOLLOW_enumConstant_in_enumerator2605
);
5438 enumConstant122
=enumConstant();
5440 if (state
.failed
) return retval
;
5441 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, enumConstant122
.getTree());
5443 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:484:18: ( enumeratorValue )?
5445 int LA37_0
= input
.LA(1);
5446 if ( (LA37_0
==ASSIGNMENT
) ) {
5451 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:484:18: enumeratorValue
5453 pushFollow(FOLLOW_enumeratorValue_in_enumerator2607
);
5454 enumeratorValue123
=enumeratorValue();
5456 if (state
.failed
) return retval
;
5457 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, enumeratorValue123
.getTree());
5466 retval
.stop
= input
.LT(-1);
5468 if ( state
.backtracking
==0 ) {
5469 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5470 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5474 catch (RecognitionException e
) {
5479 // do for sure before leaving
5483 // $ANTLR end "enumerator"
5486 public static class enumeratorValue_return
extends ParserRuleReturnScope
{
5489 public CommonTree
getTree() { return tree
; }
5493 // $ANTLR start "enumeratorValue"
5494 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:487:1: enumeratorValue : ASSIGNMENT e1= unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) ) ;
5495 public final CTFParser
.enumeratorValue_return
enumeratorValue() throws RecognitionException
{
5496 CTFParser
.enumeratorValue_return retval
= new CTFParser
.enumeratorValue_return();
5497 retval
.start
= input
.LT(1);
5499 CommonTree root_0
= null;
5501 Token ASSIGNMENT124
=null;
5502 Token ELIPSES125
=null;
5503 ParserRuleReturnScope e1
=null;
5504 ParserRuleReturnScope e2
=null;
5506 CommonTree ASSIGNMENT124_tree
=null;
5507 CommonTree ELIPSES125_tree
=null;
5508 RewriteRuleTokenStream stream_ASSIGNMENT
=new RewriteRuleTokenStream(adaptor
,"token ASSIGNMENT");
5509 RewriteRuleTokenStream stream_ELIPSES
=new RewriteRuleTokenStream(adaptor
,"token ELIPSES");
5510 RewriteRuleSubtreeStream stream_unaryExpression
=new RewriteRuleSubtreeStream(adaptor
,"rule unaryExpression");
5513 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:488:3: ( ASSIGNMENT e1= unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) ) )
5514 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:488:5: ASSIGNMENT e1= unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) )
5516 ASSIGNMENT124
=(Token
)match(input
,ASSIGNMENT
,FOLLOW_ASSIGNMENT_in_enumeratorValue2621
); if (state
.failed
) return retval
;
5517 if ( state
.backtracking
==0 ) stream_ASSIGNMENT
.add(ASSIGNMENT124
);
5519 pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2625
);
5520 e1
=unaryExpression();
5522 if (state
.failed
) return retval
;
5523 if ( state
.backtracking
==0 ) stream_unaryExpression
.add(e1
.getTree());
5524 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:489:7: ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) )
5526 int LA38_0
= input
.LA(1);
5527 if ( (LA38_0
==RCURL
||LA38_0
==SEPARATOR
) ) {
5530 else if ( (LA38_0
==ELIPSES
) ) {
5535 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
5536 NoViableAltException nvae
=
5537 new NoViableAltException("", 38, 0, input
);
5543 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:490:11:
5548 // rule labels: e1, retval
5549 // token list labels:
5550 // rule list labels:
5552 if ( state
.backtracking
==0 ) {
5553 retval
.tree
= root_0
;
5554 RewriteRuleSubtreeStream stream_e1
=new RewriteRuleSubtreeStream(adaptor
,"rule e1",e1
!=null?e1
.getTree():null);
5555 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
5557 root_0
= (CommonTree
)adaptor
.nil();
5558 // 490:11: -> ^( ENUM_VALUE $e1)
5560 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:490:14: ^( ENUM_VALUE $e1)
5562 CommonTree root_1
= (CommonTree
)adaptor
.nil();
5563 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ENUM_VALUE
, "ENUM_VALUE"), root_1
);
5564 adaptor
.addChild(root_1
, stream_e1
.nextTree());
5565 adaptor
.addChild(root_0
, root_1
);
5571 retval
.tree
= root_0
;
5577 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:491:9: ELIPSES e2= unaryExpression
5579 ELIPSES125
=(Token
)match(input
,ELIPSES
,FOLLOW_ELIPSES_in_enumeratorValue2664
); if (state
.failed
) return retval
;
5580 if ( state
.backtracking
==0 ) stream_ELIPSES
.add(ELIPSES125
);
5582 pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2668
);
5583 e2
=unaryExpression();
5585 if (state
.failed
) return retval
;
5586 if ( state
.backtracking
==0 ) stream_unaryExpression
.add(e2
.getTree());
5590 // rule labels: e1, e2, retval
5591 // token list labels:
5592 // rule list labels:
5594 if ( state
.backtracking
==0 ) {
5595 retval
.tree
= root_0
;
5596 RewriteRuleSubtreeStream stream_e1
=new RewriteRuleSubtreeStream(adaptor
,"rule e1",e1
!=null?e1
.getTree():null);
5597 RewriteRuleSubtreeStream stream_e2
=new RewriteRuleSubtreeStream(adaptor
,"rule e2",e2
!=null?e2
.getTree():null);
5598 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
5600 root_0
= (CommonTree
)adaptor
.nil();
5601 // 492:11: -> ^( ENUM_VALUE_RANGE $e1 $e2)
5603 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:492:14: ^( ENUM_VALUE_RANGE $e1 $e2)
5605 CommonTree root_1
= (CommonTree
)adaptor
.nil();
5606 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(ENUM_VALUE_RANGE
, "ENUM_VALUE_RANGE"), root_1
);
5607 adaptor
.addChild(root_1
, stream_e1
.nextTree());
5608 adaptor
.addChild(root_1
, stream_e2
.nextTree());
5609 adaptor
.addChild(root_0
, root_1
);
5615 retval
.tree
= root_0
;
5625 retval
.stop
= input
.LT(-1);
5627 if ( state
.backtracking
==0 ) {
5628 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5629 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5633 catch (RecognitionException e
) {
5638 // do for sure before leaving
5642 // $ANTLR end "enumeratorValue"
5645 public static class declarator_return
extends ParserRuleReturnScope
{
5648 public CommonTree
getTree() { return tree
; }
5652 // $ANTLR start "declarator"
5653 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:496:1: declarator : ( pointer )* directDeclarator -> ^( TYPE_DECLARATOR ( pointer )* directDeclarator ) ;
5654 public final CTFParser
.declarator_return
declarator() throws RecognitionException
{
5655 CTFParser
.declarator_return retval
= new CTFParser
.declarator_return();
5656 retval
.start
= input
.LT(1);
5658 CommonTree root_0
= null;
5660 ParserRuleReturnScope pointer126
=null;
5661 ParserRuleReturnScope directDeclarator127
=null;
5663 RewriteRuleSubtreeStream stream_pointer
=new RewriteRuleSubtreeStream(adaptor
,"rule pointer");
5664 RewriteRuleSubtreeStream stream_directDeclarator
=new RewriteRuleSubtreeStream(adaptor
,"rule directDeclarator");
5667 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:497:3: ( ( pointer )* directDeclarator -> ^( TYPE_DECLARATOR ( pointer )* directDeclarator ) )
5668 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:497:5: ( pointer )* directDeclarator
5670 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:497:5: ( pointer )*
5674 int LA39_0
= input
.LA(1);
5675 if ( (LA39_0
==POINTER
) ) {
5681 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:497:5: pointer
5683 pushFollow(FOLLOW_pointer_in_declarator2711
);
5684 pointer126
=pointer();
5686 if (state
.failed
) return retval
;
5687 if ( state
.backtracking
==0 ) stream_pointer
.add(pointer126
.getTree());
5696 pushFollow(FOLLOW_directDeclarator_in_declarator2714
);
5697 directDeclarator127
=directDeclarator();
5699 if (state
.failed
) return retval
;
5700 if ( state
.backtracking
==0 ) stream_directDeclarator
.add(directDeclarator127
.getTree());
5702 // elements: directDeclarator, pointer
5704 // rule labels: retval
5705 // token list labels:
5706 // rule list labels:
5708 if ( state
.backtracking
==0 ) {
5709 retval
.tree
= root_0
;
5710 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
5712 root_0
= (CommonTree
)adaptor
.nil();
5713 // 498:7: -> ^( TYPE_DECLARATOR ( pointer )* directDeclarator )
5715 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:498:10: ^( TYPE_DECLARATOR ( pointer )* directDeclarator )
5717 CommonTree root_1
= (CommonTree
)adaptor
.nil();
5718 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_DECLARATOR
, "TYPE_DECLARATOR"), root_1
);
5719 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:498:28: ( pointer )*
5720 while ( stream_pointer
.hasNext() ) {
5721 adaptor
.addChild(root_1
, stream_pointer
.nextTree());
5723 stream_pointer
.reset();
5725 adaptor
.addChild(root_1
, stream_directDeclarator
.nextTree());
5726 adaptor
.addChild(root_0
, root_1
);
5732 retval
.tree
= root_0
;
5737 retval
.stop
= input
.LT(-1);
5739 if ( state
.backtracking
==0 ) {
5740 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5741 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5745 catch (RecognitionException e
) {
5750 // do for sure before leaving
5754 // $ANTLR end "declarator"
5757 public static class directDeclarator_return
extends ParserRuleReturnScope
{
5760 public CommonTree
getTree() { return tree
; }
5764 // $ANTLR start "directDeclarator"
5765 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:501:1: directDeclarator : ( IDENTIFIER ) ( directDeclaratorSuffix )* ;
5766 public final CTFParser
.directDeclarator_return
directDeclarator() throws RecognitionException
{
5767 CTFParser
.directDeclarator_return retval
= new CTFParser
.directDeclarator_return();
5768 retval
.start
= input
.LT(1);
5770 CommonTree root_0
= null;
5772 Token IDENTIFIER128
=null;
5773 ParserRuleReturnScope directDeclaratorSuffix129
=null;
5775 CommonTree IDENTIFIER128_tree
=null;
5778 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:502:3: ( ( IDENTIFIER ) ( directDeclaratorSuffix )* )
5779 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:502:5: ( IDENTIFIER ) ( directDeclaratorSuffix )*
5781 root_0
= (CommonTree
)adaptor
.nil();
5784 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:502:5: ( IDENTIFIER )
5785 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:503:7: IDENTIFIER
5787 IDENTIFIER128
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_directDeclarator2752
); if (state
.failed
) return retval
;
5788 if ( state
.backtracking
==0 ) {
5789 IDENTIFIER128_tree
= (CommonTree
)adaptor
.create(IDENTIFIER128
);
5790 adaptor
.addChild(root_0
, IDENTIFIER128_tree
);
5793 if ( state
.backtracking
==0 ) { if (inTypedef()) addTypeName((IDENTIFIER128
!=null?IDENTIFIER128
.getText():null)); }
5794 if ( state
.backtracking
==0 ) { debug_print((IDENTIFIER128
!=null?IDENTIFIER128
.getText():null)); }
5797 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:508:5: ( directDeclaratorSuffix )*
5801 int LA40_0
= input
.LA(1);
5802 if ( (LA40_0
==OPENBRAC
) ) {
5808 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:508:5: directDeclaratorSuffix
5810 pushFollow(FOLLOW_directDeclaratorSuffix_in_directDeclarator2792
);
5811 directDeclaratorSuffix129
=directDeclaratorSuffix();
5813 if (state
.failed
) return retval
;
5814 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, directDeclaratorSuffix129
.getTree());
5826 retval
.stop
= input
.LT(-1);
5828 if ( state
.backtracking
==0 ) {
5829 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5830 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5834 catch (RecognitionException e
) {
5839 // do for sure before leaving
5843 // $ANTLR end "directDeclarator"
5846 public static class directDeclaratorSuffix_return
extends ParserRuleReturnScope
{
5849 public CommonTree
getTree() { return tree
; }
5853 // $ANTLR start "directDeclaratorSuffix"
5854 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:511:1: directDeclaratorSuffix : OPENBRAC directDeclaratorLength CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) ;
5855 public final CTFParser
.directDeclaratorSuffix_return
directDeclaratorSuffix() throws RecognitionException
{
5856 CTFParser
.directDeclaratorSuffix_return retval
= new CTFParser
.directDeclaratorSuffix_return();
5857 retval
.start
= input
.LT(1);
5859 CommonTree root_0
= null;
5861 Token OPENBRAC130
=null;
5862 Token CLOSEBRAC132
=null;
5863 ParserRuleReturnScope directDeclaratorLength131
=null;
5865 CommonTree OPENBRAC130_tree
=null;
5866 CommonTree CLOSEBRAC132_tree
=null;
5867 RewriteRuleTokenStream stream_OPENBRAC
=new RewriteRuleTokenStream(adaptor
,"token OPENBRAC");
5868 RewriteRuleTokenStream stream_CLOSEBRAC
=new RewriteRuleTokenStream(adaptor
,"token CLOSEBRAC");
5869 RewriteRuleSubtreeStream stream_directDeclaratorLength
=new RewriteRuleSubtreeStream(adaptor
,"rule directDeclaratorLength");
5872 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:512:3: ( OPENBRAC directDeclaratorLength CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) )
5873 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:512:5: OPENBRAC directDeclaratorLength CLOSEBRAC
5875 OPENBRAC130
=(Token
)match(input
,OPENBRAC
,FOLLOW_OPENBRAC_in_directDeclaratorSuffix2806
); if (state
.failed
) return retval
;
5876 if ( state
.backtracking
==0 ) stream_OPENBRAC
.add(OPENBRAC130
);
5878 pushFollow(FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2808
);
5879 directDeclaratorLength131
=directDeclaratorLength();
5881 if (state
.failed
) return retval
;
5882 if ( state
.backtracking
==0 ) stream_directDeclaratorLength
.add(directDeclaratorLength131
.getTree());
5883 CLOSEBRAC132
=(Token
)match(input
,CLOSEBRAC
,FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2810
); if (state
.failed
) return retval
;
5884 if ( state
.backtracking
==0 ) stream_CLOSEBRAC
.add(CLOSEBRAC132
);
5887 // elements: directDeclaratorLength
5889 // rule labels: retval
5890 // token list labels:
5891 // rule list labels:
5893 if ( state
.backtracking
==0 ) {
5894 retval
.tree
= root_0
;
5895 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
5897 root_0
= (CommonTree
)adaptor
.nil();
5898 // 513:7: -> ^( LENGTH directDeclaratorLength )
5900 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:513:10: ^( LENGTH directDeclaratorLength )
5902 CommonTree root_1
= (CommonTree
)adaptor
.nil();
5903 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(LENGTH
, "LENGTH"), root_1
);
5904 adaptor
.addChild(root_1
, stream_directDeclaratorLength
.nextTree());
5905 adaptor
.addChild(root_0
, root_1
);
5911 retval
.tree
= root_0
;
5916 retval
.stop
= input
.LT(-1);
5918 if ( state
.backtracking
==0 ) {
5919 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5920 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5924 catch (RecognitionException e
) {
5929 // do for sure before leaving
5933 // $ANTLR end "directDeclaratorSuffix"
5936 public static class directDeclaratorLength_return
extends ParserRuleReturnScope
{
5939 public CommonTree
getTree() { return tree
; }
5943 // $ANTLR start "directDeclaratorLength"
5944 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:516:1: directDeclaratorLength : unaryExpression ;
5945 public final CTFParser
.directDeclaratorLength_return
directDeclaratorLength() throws RecognitionException
{
5946 CTFParser
.directDeclaratorLength_return retval
= new CTFParser
.directDeclaratorLength_return();
5947 retval
.start
= input
.LT(1);
5949 CommonTree root_0
= null;
5951 ParserRuleReturnScope unaryExpression133
=null;
5955 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:517:3: ( unaryExpression )
5956 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:517:5: unaryExpression
5958 root_0
= (CommonTree
)adaptor
.nil();
5961 pushFollow(FOLLOW_unaryExpression_in_directDeclaratorLength2838
);
5962 unaryExpression133
=unaryExpression();
5964 if (state
.failed
) return retval
;
5965 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, unaryExpression133
.getTree());
5969 retval
.stop
= input
.LT(-1);
5971 if ( state
.backtracking
==0 ) {
5972 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
5973 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
5977 catch (RecognitionException e
) {
5982 // do for sure before leaving
5986 // $ANTLR end "directDeclaratorLength"
5989 public static class abstractDeclarator_return
extends ParserRuleReturnScope
{
5992 public CommonTree
getTree() { return tree
; }
5996 // $ANTLR start "abstractDeclarator"
5997 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:520:1: abstractDeclarator : ( ( pointer )+ ( directAbstractDeclarator )? -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^( TYPE_DECLARATOR directAbstractDeclarator ) );
5998 public final CTFParser
.abstractDeclarator_return
abstractDeclarator() throws RecognitionException
{
5999 CTFParser
.abstractDeclarator_return retval
= new CTFParser
.abstractDeclarator_return();
6000 retval
.start
= input
.LT(1);
6002 CommonTree root_0
= null;
6004 ParserRuleReturnScope pointer134
=null;
6005 ParserRuleReturnScope directAbstractDeclarator135
=null;
6006 ParserRuleReturnScope directAbstractDeclarator136
=null;
6008 RewriteRuleSubtreeStream stream_pointer
=new RewriteRuleSubtreeStream(adaptor
,"rule pointer");
6009 RewriteRuleSubtreeStream stream_directAbstractDeclarator
=new RewriteRuleSubtreeStream(adaptor
,"rule directAbstractDeclarator");
6012 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:3: ( ( pointer )+ ( directAbstractDeclarator )? -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^( TYPE_DECLARATOR directAbstractDeclarator ) )
6014 int LA43_0
= input
.LA(1);
6015 if ( (LA43_0
==POINTER
) ) {
6018 else if ( (LA43_0
==IDENTIFIER
||LA43_0
==LPAREN
) ) {
6023 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
6024 NoViableAltException nvae
=
6025 new NoViableAltException("", 43, 0, input
);
6031 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:5: ( pointer )+ ( directAbstractDeclarator )?
6033 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:5: ( pointer )+
6038 int LA41_0
= input
.LA(1);
6039 if ( (LA41_0
==POINTER
) ) {
6045 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:5: pointer
6047 pushFollow(FOLLOW_pointer_in_abstractDeclarator2851
);
6048 pointer134
=pointer();
6050 if (state
.failed
) return retval
;
6051 if ( state
.backtracking
==0 ) stream_pointer
.add(pointer134
.getTree());
6056 if ( cnt41
>= 1 ) break loop41
;
6057 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
6058 EarlyExitException eee
= new EarlyExitException(41, input
);
6064 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:14: ( directAbstractDeclarator )?
6066 int LA42_0
= input
.LA(1);
6067 if ( (LA42_0
==IDENTIFIER
||LA42_0
==LPAREN
) ) {
6072 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:14: directAbstractDeclarator
6074 pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2854
);
6075 directAbstractDeclarator135
=directAbstractDeclarator();
6077 if (state
.failed
) return retval
;
6078 if ( state
.backtracking
==0 ) stream_directAbstractDeclarator
.add(directAbstractDeclarator135
.getTree());
6085 // elements: pointer, directAbstractDeclarator
6087 // rule labels: retval
6088 // token list labels:
6089 // rule list labels:
6091 if ( state
.backtracking
==0 ) {
6092 retval
.tree
= root_0
;
6093 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
6095 root_0
= (CommonTree
)adaptor
.nil();
6096 // 522:7: -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? )
6098 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:522:10: ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? )
6100 CommonTree root_1
= (CommonTree
)adaptor
.nil();
6101 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_DECLARATOR
, "TYPE_DECLARATOR"), root_1
);
6102 if ( !(stream_pointer
.hasNext()) ) {
6103 throw new RewriteEarlyExitException();
6105 while ( stream_pointer
.hasNext() ) {
6106 adaptor
.addChild(root_1
, stream_pointer
.nextTree());
6108 stream_pointer
.reset();
6110 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:522:37: ( directAbstractDeclarator )?
6111 if ( stream_directAbstractDeclarator
.hasNext() ) {
6112 adaptor
.addChild(root_1
, stream_directAbstractDeclarator
.nextTree());
6114 stream_directAbstractDeclarator
.reset();
6116 adaptor
.addChild(root_0
, root_1
);
6122 retval
.tree
= root_0
;
6128 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:523:5: directAbstractDeclarator
6130 pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2879
);
6131 directAbstractDeclarator136
=directAbstractDeclarator();
6133 if (state
.failed
) return retval
;
6134 if ( state
.backtracking
==0 ) stream_directAbstractDeclarator
.add(directAbstractDeclarator136
.getTree());
6136 // elements: directAbstractDeclarator
6138 // rule labels: retval
6139 // token list labels:
6140 // rule list labels:
6142 if ( state
.backtracking
==0 ) {
6143 retval
.tree
= root_0
;
6144 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
6146 root_0
= (CommonTree
)adaptor
.nil();
6147 // 524:7: -> ^( TYPE_DECLARATOR directAbstractDeclarator )
6149 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:524:10: ^( TYPE_DECLARATOR directAbstractDeclarator )
6151 CommonTree root_1
= (CommonTree
)adaptor
.nil();
6152 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_DECLARATOR
, "TYPE_DECLARATOR"), root_1
);
6153 adaptor
.addChild(root_1
, stream_directAbstractDeclarator
.nextTree());
6154 adaptor
.addChild(root_0
, root_1
);
6160 retval
.tree
= root_0
;
6167 retval
.stop
= input
.LT(-1);
6169 if ( state
.backtracking
==0 ) {
6170 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6171 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6175 catch (RecognitionException e
) {
6180 // do for sure before leaving
6184 // $ANTLR end "abstractDeclarator"
6187 public static class directAbstractDeclarator_return
extends ParserRuleReturnScope
{
6190 public CommonTree
getTree() { return tree
; }
6194 // $ANTLR start "directAbstractDeclarator"
6195 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:532:1: directAbstractDeclarator : ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )? CLOSEBRAC )? ;
6196 public final CTFParser
.directAbstractDeclarator_return
directAbstractDeclarator() throws RecognitionException
{
6197 CTFParser
.directAbstractDeclarator_return retval
= new CTFParser
.directAbstractDeclarator_return();
6198 retval
.start
= input
.LT(1);
6200 CommonTree root_0
= null;
6202 Token IDENTIFIER137
=null;
6203 Token LPAREN138
=null;
6204 Token RPAREN140
=null;
6205 Token OPENBRAC141
=null;
6206 Token CLOSEBRAC143
=null;
6207 ParserRuleReturnScope abstractDeclarator139
=null;
6208 ParserRuleReturnScope unaryExpression142
=null;
6210 CommonTree IDENTIFIER137_tree
=null;
6211 CommonTree LPAREN138_tree
=null;
6212 CommonTree RPAREN140_tree
=null;
6213 CommonTree OPENBRAC141_tree
=null;
6214 CommonTree CLOSEBRAC143_tree
=null;
6217 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:533:3: ( ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )? CLOSEBRAC )? )
6218 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:533:5: ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )? CLOSEBRAC )?
6220 root_0
= (CommonTree
)adaptor
.nil();
6223 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:533:5: ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) )
6225 int LA44_0
= input
.LA(1);
6226 if ( (LA44_0
==IDENTIFIER
) ) {
6229 else if ( (LA44_0
==LPAREN
) ) {
6234 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
6235 NoViableAltException nvae
=
6236 new NoViableAltException("", 44, 0, input
);
6242 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:534:7: IDENTIFIER
6244 IDENTIFIER137
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_directAbstractDeclarator2916
); if (state
.failed
) return retval
;
6245 if ( state
.backtracking
==0 ) {
6246 IDENTIFIER137_tree
= (CommonTree
)adaptor
.create(IDENTIFIER137
);
6247 adaptor
.addChild(root_0
, IDENTIFIER137_tree
);
6253 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:535:9: ( LPAREN abstractDeclarator RPAREN )
6255 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:535:9: ( LPAREN abstractDeclarator RPAREN )
6256 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:535:10: LPAREN abstractDeclarator RPAREN
6258 LPAREN138
=(Token
)match(input
,LPAREN
,FOLLOW_LPAREN_in_directAbstractDeclarator2927
); if (state
.failed
) return retval
;
6259 if ( state
.backtracking
==0 ) {
6260 LPAREN138_tree
= (CommonTree
)adaptor
.create(LPAREN138
);
6261 adaptor
.addChild(root_0
, LPAREN138_tree
);
6264 pushFollow(FOLLOW_abstractDeclarator_in_directAbstractDeclarator2929
);
6265 abstractDeclarator139
=abstractDeclarator();
6267 if (state
.failed
) return retval
;
6268 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, abstractDeclarator139
.getTree());
6270 RPAREN140
=(Token
)match(input
,RPAREN
,FOLLOW_RPAREN_in_directAbstractDeclarator2931
); if (state
.failed
) return retval
;
6271 if ( state
.backtracking
==0 ) {
6272 RPAREN140_tree
= (CommonTree
)adaptor
.create(RPAREN140
);
6273 adaptor
.addChild(root_0
, RPAREN140_tree
);
6283 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:536:5: ( OPENBRAC ( unaryExpression )? CLOSEBRAC )?
6285 int LA46_0
= input
.LA(1);
6286 if ( (LA46_0
==OPENBRAC
) ) {
6291 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:537:7: OPENBRAC ( unaryExpression )? CLOSEBRAC
6293 OPENBRAC141
=(Token
)match(input
,OPENBRAC
,FOLLOW_OPENBRAC_in_directAbstractDeclarator2946
); if (state
.failed
) return retval
;
6294 if ( state
.backtracking
==0 ) {
6295 OPENBRAC141_tree
= (CommonTree
)adaptor
.create(OPENBRAC141
);
6296 adaptor
.addChild(root_0
, OPENBRAC141_tree
);
6299 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:537:16: ( unaryExpression )?
6301 int LA45_0
= input
.LA(1);
6302 if ( (LA45_0
==ALIGNTOK
||LA45_0
==CHARACTER_LITERAL
||LA45_0
==CLOCKTOK
||LA45_0
==DECIMAL_LITERAL
||LA45_0
==ENVTOK
||LA45_0
==EVENTTOK
||LA45_0
==HEX_LITERAL
||LA45_0
==IDENTIFIER
||LA45_0
==OCTAL_LITERAL
||(LA45_0
>= SIGN
&& LA45_0
<= SIGNEDTOK
)||LA45_0
==STREAMTOK
||LA45_0
==STRINGTOK
||LA45_0
==STRING_LITERAL
||LA45_0
==TRACETOK
) ) {
6307 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:537:16: unaryExpression
6309 pushFollow(FOLLOW_unaryExpression_in_directAbstractDeclarator2948
);
6310 unaryExpression142
=unaryExpression();
6312 if (state
.failed
) return retval
;
6313 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, unaryExpression142
.getTree());
6320 CLOSEBRAC143
=(Token
)match(input
,CLOSEBRAC
,FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2951
); if (state
.failed
) return retval
;
6321 if ( state
.backtracking
==0 ) {
6322 CLOSEBRAC143_tree
= (CommonTree
)adaptor
.create(CLOSEBRAC143
);
6323 adaptor
.addChild(root_0
, CLOSEBRAC143_tree
);
6333 retval
.stop
= input
.LT(-1);
6335 if ( state
.backtracking
==0 ) {
6336 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6337 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6341 catch (RecognitionException e
) {
6346 // do for sure before leaving
6350 // $ANTLR end "directAbstractDeclarator"
6353 public static class pointer_return
extends ParserRuleReturnScope
{
6356 public CommonTree
getTree() { return tree
; }
6360 // $ANTLR start "pointer"
6361 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:541:1: pointer : POINTER ( typeQualifierList )? -> ^( POINTER ( typeQualifierList )? ) ;
6362 public final CTFParser
.pointer_return
pointer() throws RecognitionException
{
6363 CTFParser
.pointer_return retval
= new CTFParser
.pointer_return();
6364 retval
.start
= input
.LT(1);
6366 CommonTree root_0
= null;
6368 Token POINTER144
=null;
6369 ParserRuleReturnScope typeQualifierList145
=null;
6371 CommonTree POINTER144_tree
=null;
6372 RewriteRuleTokenStream stream_POINTER
=new RewriteRuleTokenStream(adaptor
,"token POINTER");
6373 RewriteRuleSubtreeStream stream_typeQualifierList
=new RewriteRuleSubtreeStream(adaptor
,"rule typeQualifierList");
6376 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:3: ( POINTER ( typeQualifierList )? -> ^( POINTER ( typeQualifierList )? ) )
6377 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:5: POINTER ( typeQualifierList )?
6379 POINTER144
=(Token
)match(input
,POINTER
,FOLLOW_POINTER_in_pointer2969
); if (state
.failed
) return retval
;
6380 if ( state
.backtracking
==0 ) stream_POINTER
.add(POINTER144
);
6382 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:13: ( typeQualifierList )?
6384 int LA47_0
= input
.LA(1);
6385 if ( (LA47_0
==CONSTTOK
) ) {
6390 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:13: typeQualifierList
6392 pushFollow(FOLLOW_typeQualifierList_in_pointer2971
);
6393 typeQualifierList145
=typeQualifierList();
6395 if (state
.failed
) return retval
;
6396 if ( state
.backtracking
==0 ) stream_typeQualifierList
.add(typeQualifierList145
.getTree());
6403 // elements: typeQualifierList, POINTER
6405 // rule labels: retval
6406 // token list labels:
6407 // rule list labels:
6409 if ( state
.backtracking
==0 ) {
6410 retval
.tree
= root_0
;
6411 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
6413 root_0
= (CommonTree
)adaptor
.nil();
6414 // 542:32: -> ^( POINTER ( typeQualifierList )? )
6416 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:35: ^( POINTER ( typeQualifierList )? )
6418 CommonTree root_1
= (CommonTree
)adaptor
.nil();
6419 root_1
= (CommonTree
)adaptor
.becomeRoot(stream_POINTER
.nextNode(), root_1
);
6420 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:45: ( typeQualifierList )?
6421 if ( stream_typeQualifierList
.hasNext() ) {
6422 adaptor
.addChild(root_1
, stream_typeQualifierList
.nextTree());
6424 stream_typeQualifierList
.reset();
6426 adaptor
.addChild(root_0
, root_1
);
6432 retval
.tree
= root_0
;
6437 retval
.stop
= input
.LT(-1);
6439 if ( state
.backtracking
==0 ) {
6440 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6441 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6445 catch (RecognitionException e
) {
6450 // do for sure before leaving
6454 // $ANTLR end "pointer"
6457 public static class typeQualifierList_return
extends ParserRuleReturnScope
{
6460 public CommonTree
getTree() { return tree
; }
6464 // $ANTLR start "typeQualifierList"
6465 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:545:1: typeQualifierList : ( typeQualifier )+ ;
6466 public final CTFParser
.typeQualifierList_return
typeQualifierList() throws RecognitionException
{
6467 CTFParser
.typeQualifierList_return retval
= new CTFParser
.typeQualifierList_return();
6468 retval
.start
= input
.LT(1);
6470 CommonTree root_0
= null;
6472 ParserRuleReturnScope typeQualifier146
=null;
6476 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:546:3: ( ( typeQualifier )+ )
6477 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:546:5: ( typeQualifier )+
6479 root_0
= (CommonTree
)adaptor
.nil();
6482 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:546:5: ( typeQualifier )+
6487 int LA48_0
= input
.LA(1);
6488 if ( (LA48_0
==CONSTTOK
) ) {
6494 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:546:5: typeQualifier
6496 pushFollow(FOLLOW_typeQualifier_in_typeQualifierList2994
);
6497 typeQualifier146
=typeQualifier();
6499 if (state
.failed
) return retval
;
6500 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, typeQualifier146
.getTree());
6506 if ( cnt48
>= 1 ) break loop48
;
6507 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
6508 EarlyExitException eee
= new EarlyExitException(48, input
);
6516 retval
.stop
= input
.LT(-1);
6518 if ( state
.backtracking
==0 ) {
6519 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6520 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6524 catch (RecognitionException e
) {
6529 // do for sure before leaving
6533 // $ANTLR end "typeQualifierList"
6536 public static class typedefName_return
extends ParserRuleReturnScope
{
6539 public CommonTree
getTree() { return tree
; }
6543 // $ANTLR start "typedefName"
6544 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:549:1: typedefName :{...}? IDENTIFIER ;
6545 public final CTFParser
.typedefName_return
typedefName() throws RecognitionException
{
6546 CTFParser
.typedefName_return retval
= new CTFParser
.typedefName_return();
6547 retval
.start
= input
.LT(1);
6549 CommonTree root_0
= null;
6551 Token IDENTIFIER147
=null;
6553 CommonTree IDENTIFIER147_tree
=null;
6556 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:550:3: ({...}? IDENTIFIER )
6557 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:550:5: {...}? IDENTIFIER
6559 root_0
= (CommonTree
)adaptor
.nil();
6562 if ( !((inTypealiasAlias() || isTypeName(input
.LT(1).getText()))) ) {
6563 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
6564 throw new FailedPredicateException(input
, "typedefName", "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
6566 IDENTIFIER147
=(Token
)match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_typedefName3010
); if (state
.failed
) return retval
;
6567 if ( state
.backtracking
==0 ) {
6568 IDENTIFIER147_tree
= (CommonTree
)adaptor
.create(IDENTIFIER147
);
6569 adaptor
.addChild(root_0
, IDENTIFIER147_tree
);
6572 if ( state
.backtracking
==0 ) { if ((inTypedef() || inTypealiasAlias()) && !isTypeName((IDENTIFIER147
!=null?IDENTIFIER147
.getText():null))) { addTypeName((IDENTIFIER147
!=null?IDENTIFIER147
.getText():null)); } }
6575 retval
.stop
= input
.LT(-1);
6577 if ( state
.backtracking
==0 ) {
6578 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6579 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6583 catch (RecognitionException e
) {
6588 // do for sure before leaving
6592 // $ANTLR end "typedefName"
6595 public static class typealiasTarget_return
extends ParserRuleReturnScope
{
6598 public CommonTree
getTree() { return tree
; }
6602 // $ANTLR start "typealiasTarget"
6603 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:559:1: typealiasTarget : declarationSpecifiers ( abstractDeclaratorList )? ;
6604 public final CTFParser
.typealiasTarget_return
typealiasTarget() throws RecognitionException
{
6605 CTFParser
.typealiasTarget_return retval
= new CTFParser
.typealiasTarget_return();
6606 retval
.start
= input
.LT(1);
6608 CommonTree root_0
= null;
6610 ParserRuleReturnScope declarationSpecifiers148
=null;
6611 ParserRuleReturnScope abstractDeclaratorList149
=null;
6615 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:560:3: ( declarationSpecifiers ( abstractDeclaratorList )? )
6616 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:560:5: declarationSpecifiers ( abstractDeclaratorList )?
6618 root_0
= (CommonTree
)adaptor
.nil();
6621 pushFollow(FOLLOW_declarationSpecifiers_in_typealiasTarget3027
);
6622 declarationSpecifiers148
=declarationSpecifiers();
6624 if (state
.failed
) return retval
;
6625 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, declarationSpecifiers148
.getTree());
6627 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:560:27: ( abstractDeclaratorList )?
6629 int LA49_0
= input
.LA(1);
6630 if ( (LA49_0
==IDENTIFIER
||LA49_0
==LPAREN
||LA49_0
==POINTER
) ) {
6635 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:560:27: abstractDeclaratorList
6637 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasTarget3029
);
6638 abstractDeclaratorList149
=abstractDeclaratorList();
6640 if (state
.failed
) return retval
;
6641 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, abstractDeclaratorList149
.getTree());
6650 retval
.stop
= input
.LT(-1);
6652 if ( state
.backtracking
==0 ) {
6653 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6654 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6658 catch (RecognitionException e
) {
6663 // do for sure before leaving
6667 // $ANTLR end "typealiasTarget"
6670 public static class typealiasAlias_return
extends ParserRuleReturnScope
{
6673 public CommonTree
getTree() { return tree
; }
6677 // $ANTLR start "typealiasAlias"
6678 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:569:1: typealiasAlias : ( abstractDeclaratorList | declarationSpecifiers ( abstractDeclaratorList )? );
6679 public final CTFParser
.typealiasAlias_return
typealiasAlias() throws RecognitionException
{
6680 CTFParser
.typealiasAlias_return retval
= new CTFParser
.typealiasAlias_return();
6681 retval
.start
= input
.LT(1);
6683 CommonTree root_0
= null;
6685 ParserRuleReturnScope abstractDeclaratorList150
=null;
6686 ParserRuleReturnScope declarationSpecifiers151
=null;
6687 ParserRuleReturnScope abstractDeclaratorList152
=null;
6694 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:576:3: ( abstractDeclaratorList | declarationSpecifiers ( abstractDeclaratorList )? )
6696 switch ( input
.LA(1) ) {
6705 int LA51_2
= input
.LA(2);
6706 if ( (!(((( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) )&&(inTypealiasAlias() || isTypeName(input
.LT(1).getText())))))) ) {
6709 else if ( ((( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) )&&(inTypealiasAlias() || isTypeName(input
.LT(1).getText())))) ) {
6714 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
6715 int nvaeMark
= input
.mark();
6718 NoViableAltException nvae
=
6719 new NoViableAltException("", 51, 2, input
);
6722 input
.rewind(nvaeMark
);
6734 case FLOATINGPOINTTOK
:
6753 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
6754 NoViableAltException nvae
=
6755 new NoViableAltException("", 51, 0, input
);
6760 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:576:5: abstractDeclaratorList
6762 root_0
= (CommonTree
)adaptor
.nil();
6765 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias3055
);
6766 abstractDeclaratorList150
=abstractDeclaratorList();
6768 if (state
.failed
) return retval
;
6769 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, abstractDeclaratorList150
.getTree());
6774 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:577:5: declarationSpecifiers ( abstractDeclaratorList )?
6776 root_0
= (CommonTree
)adaptor
.nil();
6779 pushFollow(FOLLOW_declarationSpecifiers_in_typealiasAlias3061
);
6780 declarationSpecifiers151
=declarationSpecifiers();
6782 if (state
.failed
) return retval
;
6783 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, declarationSpecifiers151
.getTree());
6785 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:577:27: ( abstractDeclaratorList )?
6787 int LA50_0
= input
.LA(1);
6788 if ( (LA50_0
==IDENTIFIER
||LA50_0
==LPAREN
||LA50_0
==POINTER
) ) {
6793 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:577:27: abstractDeclaratorList
6795 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias3063
);
6796 abstractDeclaratorList152
=abstractDeclaratorList();
6798 if (state
.failed
) return retval
;
6799 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, abstractDeclaratorList152
.getTree());
6810 retval
.stop
= input
.LT(-1);
6812 if ( state
.backtracking
==0 ) {
6813 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6814 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6816 if ( state
.backtracking
==0 ) {
6817 typealiasAliasOff();
6821 catch (RecognitionException e
) {
6826 // do for sure before leaving
6830 // $ANTLR end "typealiasAlias"
6833 public static class typealiasDecl_return
extends ParserRuleReturnScope
{
6836 public CommonTree
getTree() { return tree
; }
6840 // $ANTLR start "typealiasDecl"
6841 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:580:1: typealiasDecl : TYPEALIASTOK typealiasTarget TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) ) ;
6842 public final CTFParser
.typealiasDecl_return
typealiasDecl() throws RecognitionException
{
6843 CTFParser
.typealiasDecl_return retval
= new CTFParser
.typealiasDecl_return();
6844 retval
.start
= input
.LT(1);
6846 CommonTree root_0
= null;
6848 Token TYPEALIASTOK153
=null;
6849 Token TYPE_ASSIGNMENT155
=null;
6850 ParserRuleReturnScope typealiasTarget154
=null;
6851 ParserRuleReturnScope typealiasAlias156
=null;
6853 CommonTree TYPEALIASTOK153_tree
=null;
6854 CommonTree TYPE_ASSIGNMENT155_tree
=null;
6855 RewriteRuleTokenStream stream_TYPE_ASSIGNMENT
=new RewriteRuleTokenStream(adaptor
,"token TYPE_ASSIGNMENT");
6856 RewriteRuleTokenStream stream_TYPEALIASTOK
=new RewriteRuleTokenStream(adaptor
,"token TYPEALIASTOK");
6857 RewriteRuleSubtreeStream stream_typealiasAlias
=new RewriteRuleSubtreeStream(adaptor
,"rule typealiasAlias");
6858 RewriteRuleSubtreeStream stream_typealiasTarget
=new RewriteRuleSubtreeStream(adaptor
,"rule typealiasTarget");
6861 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:581:3: ( TYPEALIASTOK typealiasTarget TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) ) )
6862 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:581:5: TYPEALIASTOK typealiasTarget TYPE_ASSIGNMENT typealiasAlias
6864 TYPEALIASTOK153
=(Token
)match(input
,TYPEALIASTOK
,FOLLOW_TYPEALIASTOK_in_typealiasDecl3077
); if (state
.failed
) return retval
;
6865 if ( state
.backtracking
==0 ) stream_TYPEALIASTOK
.add(TYPEALIASTOK153
);
6867 pushFollow(FOLLOW_typealiasTarget_in_typealiasDecl3079
);
6868 typealiasTarget154
=typealiasTarget();
6870 if (state
.failed
) return retval
;
6871 if ( state
.backtracking
==0 ) stream_typealiasTarget
.add(typealiasTarget154
.getTree());
6872 TYPE_ASSIGNMENT155
=(Token
)match(input
,TYPE_ASSIGNMENT
,FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3081
); if (state
.failed
) return retval
;
6873 if ( state
.backtracking
==0 ) stream_TYPE_ASSIGNMENT
.add(TYPE_ASSIGNMENT155
);
6875 pushFollow(FOLLOW_typealiasAlias_in_typealiasDecl3083
);
6876 typealiasAlias156
=typealiasAlias();
6878 if (state
.failed
) return retval
;
6879 if ( state
.backtracking
==0 ) stream_typealiasAlias
.add(typealiasAlias156
.getTree());
6881 // elements: typealiasTarget, typealiasAlias
6883 // rule labels: retval
6884 // token list labels:
6885 // rule list labels:
6887 if ( state
.backtracking
==0 ) {
6888 retval
.tree
= root_0
;
6889 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
6891 root_0
= (CommonTree
)adaptor
.nil();
6892 // 582:7: -> ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
6894 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:582:10: ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
6896 CommonTree root_1
= (CommonTree
)adaptor
.nil();
6897 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPEALIAS
, "TYPEALIAS"), root_1
);
6898 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:583:14: ^( TYPEALIAS_TARGET typealiasTarget )
6900 CommonTree root_2
= (CommonTree
)adaptor
.nil();
6901 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPEALIAS_TARGET
, "TYPEALIAS_TARGET"), root_2
);
6902 adaptor
.addChild(root_2
, stream_typealiasTarget
.nextTree());
6903 adaptor
.addChild(root_1
, root_2
);
6906 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:584:14: ^( TYPEALIAS_ALIAS typealiasAlias )
6908 CommonTree root_2
= (CommonTree
)adaptor
.nil();
6909 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPEALIAS_ALIAS
, "TYPEALIAS_ALIAS"), root_2
);
6910 adaptor
.addChild(root_2
, stream_typealiasAlias
.nextTree());
6911 adaptor
.addChild(root_1
, root_2
);
6914 adaptor
.addChild(root_0
, root_1
);
6920 retval
.tree
= root_0
;
6925 retval
.stop
= input
.LT(-1);
6927 if ( state
.backtracking
==0 ) {
6928 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6929 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6933 catch (RecognitionException e
) {
6938 // do for sure before leaving
6942 // $ANTLR end "typealiasDecl"
6945 public static class ctfKeyword_return
extends ParserRuleReturnScope
{
6948 public CommonTree
getTree() { return tree
; }
6952 // $ANTLR start "ctfKeyword"
6953 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:590:1: ctfKeyword : ( ALIGNTOK | EVENTTOK | SIGNEDTOK | STRINGTOK );
6954 public final CTFParser
.ctfKeyword_return
ctfKeyword() throws RecognitionException
{
6955 CTFParser
.ctfKeyword_return retval
= new CTFParser
.ctfKeyword_return();
6956 retval
.start
= input
.LT(1);
6958 CommonTree root_0
= null;
6962 CommonTree set157_tree
=null;
6965 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:591:3: ( ALIGNTOK | EVENTTOK | SIGNEDTOK | STRINGTOK )
6966 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:
6968 root_0
= (CommonTree
)adaptor
.nil();
6972 if ( input
.LA(1)==ALIGNTOK
||input
.LA(1)==EVENTTOK
||input
.LA(1)==SIGNEDTOK
||input
.LA(1)==STRINGTOK
) {
6974 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, (CommonTree
)adaptor
.create(set157
));
6975 state
.errorRecovery
=false;
6979 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
6980 MismatchedSetException mse
= new MismatchedSetException(null,input
);
6985 retval
.stop
= input
.LT(-1);
6987 if ( state
.backtracking
==0 ) {
6988 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
6989 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
6993 catch (RecognitionException e
) {
6998 // do for sure before leaving
7002 // $ANTLR end "ctfKeyword"
7005 public static class ctfSpecifier_return
extends ParserRuleReturnScope
{
7008 public CommonTree
getTree() { return tree
; }
7012 // $ANTLR start "ctfSpecifier"
7013 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:597:1: ctfSpecifier : ( ctfSpecifierHead ctfBody -> ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION typealiasDecl ) );
7014 public final CTFParser
.ctfSpecifier_return
ctfSpecifier() throws RecognitionException
{
7015 CTFParser
.ctfSpecifier_return retval
= new CTFParser
.ctfSpecifier_return();
7016 retval
.start
= input
.LT(1);
7018 CommonTree root_0
= null;
7020 ParserRuleReturnScope ctfSpecifierHead158
=null;
7021 ParserRuleReturnScope ctfBody159
=null;
7022 ParserRuleReturnScope typealiasDecl160
=null;
7024 RewriteRuleSubtreeStream stream_typealiasDecl
=new RewriteRuleSubtreeStream(adaptor
,"rule typealiasDecl");
7025 RewriteRuleSubtreeStream stream_ctfSpecifierHead
=new RewriteRuleSubtreeStream(adaptor
,"rule ctfSpecifierHead");
7026 RewriteRuleSubtreeStream stream_ctfBody
=new RewriteRuleSubtreeStream(adaptor
,"rule ctfBody");
7029 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:599:3: ( ctfSpecifierHead ctfBody -> ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION typealiasDecl ) )
7031 int LA52_0
= input
.LA(1);
7032 if ( (LA52_0
==CLOCKTOK
||LA52_0
==ENVTOK
||LA52_0
==EVENTTOK
||LA52_0
==STREAMTOK
||LA52_0
==TRACETOK
) ) {
7035 else if ( (LA52_0
==TYPEALIASTOK
) ) {
7040 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
7041 NoViableAltException nvae
=
7042 new NoViableAltException("", 52, 0, input
);
7048 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:599:5: ctfSpecifierHead ctfBody
7050 pushFollow(FOLLOW_ctfSpecifierHead_in_ctfSpecifier3183
);
7051 ctfSpecifierHead158
=ctfSpecifierHead();
7053 if (state
.failed
) return retval
;
7054 if ( state
.backtracking
==0 ) stream_ctfSpecifierHead
.add(ctfSpecifierHead158
.getTree());
7055 pushFollow(FOLLOW_ctfBody_in_ctfSpecifier3185
);
7056 ctfBody159
=ctfBody();
7058 if (state
.failed
) return retval
;
7059 if ( state
.backtracking
==0 ) stream_ctfBody
.add(ctfBody159
.getTree());
7061 // elements: ctfSpecifierHead, ctfBody
7063 // rule labels: retval
7064 // token list labels:
7065 // rule list labels:
7067 if ( state
.backtracking
==0 ) {
7068 retval
.tree
= root_0
;
7069 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7071 root_0
= (CommonTree
)adaptor
.nil();
7072 // 599:30: -> ^( ctfSpecifierHead ctfBody )
7074 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:599:33: ^( ctfSpecifierHead ctfBody )
7076 CommonTree root_1
= (CommonTree
)adaptor
.nil();
7077 root_1
= (CommonTree
)adaptor
.becomeRoot(stream_ctfSpecifierHead
.nextNode(), root_1
);
7078 adaptor
.addChild(root_1
, stream_ctfBody
.nextTree());
7079 adaptor
.addChild(root_0
, root_1
);
7085 retval
.tree
= root_0
;
7091 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:601:5: typealiasDecl
7093 pushFollow(FOLLOW_typealiasDecl_in_ctfSpecifier3202
);
7094 typealiasDecl160
=typealiasDecl();
7096 if (state
.failed
) return retval
;
7097 if ( state
.backtracking
==0 ) stream_typealiasDecl
.add(typealiasDecl160
.getTree());
7099 // elements: typealiasDecl
7101 // rule labels: retval
7102 // token list labels:
7103 // rule list labels:
7105 if ( state
.backtracking
==0 ) {
7106 retval
.tree
= root_0
;
7107 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7109 root_0
= (CommonTree
)adaptor
.nil();
7110 // 601:19: -> ^( DECLARATION typealiasDecl )
7112 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:601:22: ^( DECLARATION typealiasDecl )
7114 CommonTree root_1
= (CommonTree
)adaptor
.nil();
7115 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(DECLARATION
, "DECLARATION"), root_1
);
7116 adaptor
.addChild(root_1
, stream_typealiasDecl
.nextTree());
7117 adaptor
.addChild(root_0
, root_1
);
7123 retval
.tree
= root_0
;
7130 retval
.stop
= input
.LT(-1);
7132 if ( state
.backtracking
==0 ) {
7133 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
7134 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
7138 catch (RecognitionException e
) {
7143 // do for sure before leaving
7147 // $ANTLR end "ctfSpecifier"
7150 public static class ctfSpecifierHead_return
extends ParserRuleReturnScope
{
7153 public CommonTree
getTree() { return tree
; }
7157 // $ANTLR start "ctfSpecifierHead"
7158 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:604:1: ctfSpecifierHead : ( EVENTTOK -> EVENT | STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK );
7159 public final CTFParser
.ctfSpecifierHead_return
ctfSpecifierHead() throws RecognitionException
{
7160 CTFParser
.ctfSpecifierHead_return retval
= new CTFParser
.ctfSpecifierHead_return();
7161 retval
.start
= input
.LT(1);
7163 CommonTree root_0
= null;
7165 Token EVENTTOK161
=null;
7166 Token STREAMTOK162
=null;
7167 Token TRACETOK163
=null;
7168 Token ENVTOK164
=null;
7169 Token CLOCKTOK165
=null;
7171 CommonTree EVENTTOK161_tree
=null;
7172 CommonTree STREAMTOK162_tree
=null;
7173 CommonTree TRACETOK163_tree
=null;
7174 CommonTree ENVTOK164_tree
=null;
7175 CommonTree CLOCKTOK165_tree
=null;
7176 RewriteRuleTokenStream stream_ENVTOK
=new RewriteRuleTokenStream(adaptor
,"token ENVTOK");
7177 RewriteRuleTokenStream stream_TRACETOK
=new RewriteRuleTokenStream(adaptor
,"token TRACETOK");
7178 RewriteRuleTokenStream stream_STREAMTOK
=new RewriteRuleTokenStream(adaptor
,"token STREAMTOK");
7179 RewriteRuleTokenStream stream_CLOCKTOK
=new RewriteRuleTokenStream(adaptor
,"token CLOCKTOK");
7180 RewriteRuleTokenStream stream_EVENTTOK
=new RewriteRuleTokenStream(adaptor
,"token EVENTTOK");
7183 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:605:3: ( EVENTTOK -> EVENT | STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK )
7185 switch ( input
.LA(1) ) {
7212 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
7213 NoViableAltException nvae
=
7214 new NoViableAltException("", 53, 0, input
);
7219 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:605:5: EVENTTOK
7221 EVENTTOK161
=(Token
)match(input
,EVENTTOK
,FOLLOW_EVENTTOK_in_ctfSpecifierHead3223
); if (state
.failed
) return retval
;
7222 if ( state
.backtracking
==0 ) stream_EVENTTOK
.add(EVENTTOK161
);
7227 // rule labels: retval
7228 // token list labels:
7229 // rule list labels:
7231 if ( state
.backtracking
==0 ) {
7232 retval
.tree
= root_0
;
7233 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7235 root_0
= (CommonTree
)adaptor
.nil();
7238 adaptor
.addChild(root_0
, (CommonTree
)adaptor
.create(EVENT
, "EVENT"));
7242 retval
.tree
= root_0
;
7248 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:606:5: STREAMTOK
7250 STREAMTOK162
=(Token
)match(input
,STREAMTOK
,FOLLOW_STREAMTOK_in_ctfSpecifierHead3233
); if (state
.failed
) return retval
;
7251 if ( state
.backtracking
==0 ) stream_STREAMTOK
.add(STREAMTOK162
);
7256 // rule labels: retval
7257 // token list labels:
7258 // rule list labels:
7260 if ( state
.backtracking
==0 ) {
7261 retval
.tree
= root_0
;
7262 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7264 root_0
= (CommonTree
)adaptor
.nil();
7265 // 606:15: -> STREAM
7267 adaptor
.addChild(root_0
, (CommonTree
)adaptor
.create(STREAM
, "STREAM"));
7271 retval
.tree
= root_0
;
7277 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:607:5: TRACETOK
7279 TRACETOK163
=(Token
)match(input
,TRACETOK
,FOLLOW_TRACETOK_in_ctfSpecifierHead3243
); if (state
.failed
) return retval
;
7280 if ( state
.backtracking
==0 ) stream_TRACETOK
.add(TRACETOK163
);
7285 // rule labels: retval
7286 // token list labels:
7287 // rule list labels:
7289 if ( state
.backtracking
==0 ) {
7290 retval
.tree
= root_0
;
7291 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7293 root_0
= (CommonTree
)adaptor
.nil();
7296 adaptor
.addChild(root_0
, (CommonTree
)adaptor
.create(TRACE
, "TRACE"));
7300 retval
.tree
= root_0
;
7306 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:608:5: ENVTOK
7308 ENVTOK164
=(Token
)match(input
,ENVTOK
,FOLLOW_ENVTOK_in_ctfSpecifierHead3253
); if (state
.failed
) return retval
;
7309 if ( state
.backtracking
==0 ) stream_ENVTOK
.add(ENVTOK164
);
7314 // rule labels: retval
7315 // token list labels:
7316 // rule list labels:
7318 if ( state
.backtracking
==0 ) {
7319 retval
.tree
= root_0
;
7320 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7322 root_0
= (CommonTree
)adaptor
.nil();
7325 adaptor
.addChild(root_0
, (CommonTree
)adaptor
.create(ENV
, "ENV"));
7329 retval
.tree
= root_0
;
7335 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:609:5: CLOCKTOK
7337 CLOCKTOK165
=(Token
)match(input
,CLOCKTOK
,FOLLOW_CLOCKTOK_in_ctfSpecifierHead3263
); if (state
.failed
) return retval
;
7338 if ( state
.backtracking
==0 ) stream_CLOCKTOK
.add(CLOCKTOK165
);
7343 // rule labels: retval
7344 // token list labels:
7345 // rule list labels:
7347 if ( state
.backtracking
==0 ) {
7348 retval
.tree
= root_0
;
7349 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7351 root_0
= (CommonTree
)adaptor
.nil();
7354 adaptor
.addChild(root_0
, (CommonTree
)adaptor
.create(CLOCK
, "CLOCK"));
7358 retval
.tree
= root_0
;
7365 retval
.stop
= input
.LT(-1);
7367 if ( state
.backtracking
==0 ) {
7368 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
7369 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
7373 catch (RecognitionException e
) {
7378 // do for sure before leaving
7382 // $ANTLR end "ctfSpecifierHead"
7385 public static class ctfTypeSpecifier_return
extends ParserRuleReturnScope
{
7388 public CommonTree
getTree() { return tree
; }
7392 // $ANTLR start "ctfTypeSpecifier"
7393 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:612:1: ctfTypeSpecifier : ( FLOATINGPOINTTOK ctfBody -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) );
7394 public final CTFParser
.ctfTypeSpecifier_return
ctfTypeSpecifier() throws RecognitionException
{
7395 CTFParser
.ctfTypeSpecifier_return retval
= new CTFParser
.ctfTypeSpecifier_return();
7396 retval
.start
= input
.LT(1);
7398 CommonTree root_0
= null;
7400 Token FLOATINGPOINTTOK166
=null;
7401 Token INTEGERTOK168
=null;
7402 Token STRINGTOK170
=null;
7403 ParserRuleReturnScope ctfBody167
=null;
7404 ParserRuleReturnScope ctfBody169
=null;
7405 ParserRuleReturnScope ctfBody171
=null;
7407 CommonTree FLOATINGPOINTTOK166_tree
=null;
7408 CommonTree INTEGERTOK168_tree
=null;
7409 CommonTree STRINGTOK170_tree
=null;
7410 RewriteRuleTokenStream stream_FLOATINGPOINTTOK
=new RewriteRuleTokenStream(adaptor
,"token FLOATINGPOINTTOK");
7411 RewriteRuleTokenStream stream_INTEGERTOK
=new RewriteRuleTokenStream(adaptor
,"token INTEGERTOK");
7412 RewriteRuleTokenStream stream_STRINGTOK
=new RewriteRuleTokenStream(adaptor
,"token STRINGTOK");
7413 RewriteRuleSubtreeStream stream_ctfBody
=new RewriteRuleSubtreeStream(adaptor
,"rule ctfBody");
7416 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:614:3: ( FLOATINGPOINTTOK ctfBody -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) )
7418 switch ( input
.LA(1) ) {
7419 case FLOATINGPOINTTOK
:
7435 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
7436 NoViableAltException nvae
=
7437 new NoViableAltException("", 55, 0, input
);
7442 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:614:5: FLOATINGPOINTTOK ctfBody
7444 FLOATINGPOINTTOK166
=(Token
)match(input
,FLOATINGPOINTTOK
,FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3286
); if (state
.failed
) return retval
;
7445 if ( state
.backtracking
==0 ) stream_FLOATINGPOINTTOK
.add(FLOATINGPOINTTOK166
);
7447 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3288
);
7448 ctfBody167
=ctfBody();
7450 if (state
.failed
) return retval
;
7451 if ( state
.backtracking
==0 ) stream_ctfBody
.add(ctfBody167
.getTree());
7453 // elements: ctfBody
7455 // rule labels: retval
7456 // token list labels:
7457 // rule list labels:
7459 if ( state
.backtracking
==0 ) {
7460 retval
.tree
= root_0
;
7461 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7463 root_0
= (CommonTree
)adaptor
.nil();
7464 // 614:30: -> ^( FLOATING_POINT ( ctfBody )? )
7466 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:614:33: ^( FLOATING_POINT ( ctfBody )? )
7468 CommonTree root_1
= (CommonTree
)adaptor
.nil();
7469 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(FLOATING_POINT
, "FLOATING_POINT"), root_1
);
7470 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:614:50: ( ctfBody )?
7471 if ( stream_ctfBody
.hasNext() ) {
7472 adaptor
.addChild(root_1
, stream_ctfBody
.nextTree());
7474 stream_ctfBody
.reset();
7476 adaptor
.addChild(root_0
, root_1
);
7482 retval
.tree
= root_0
;
7488 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:615:5: INTEGERTOK ctfBody
7490 INTEGERTOK168
=(Token
)match(input
,INTEGERTOK
,FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3303
); if (state
.failed
) return retval
;
7491 if ( state
.backtracking
==0 ) stream_INTEGERTOK
.add(INTEGERTOK168
);
7493 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3305
);
7494 ctfBody169
=ctfBody();
7496 if (state
.failed
) return retval
;
7497 if ( state
.backtracking
==0 ) stream_ctfBody
.add(ctfBody169
.getTree());
7499 // elements: ctfBody
7501 // rule labels: retval
7502 // token list labels:
7503 // rule list labels:
7505 if ( state
.backtracking
==0 ) {
7506 retval
.tree
= root_0
;
7507 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7509 root_0
= (CommonTree
)adaptor
.nil();
7510 // 615:24: -> ^( INTEGER ( ctfBody )? )
7512 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:615:27: ^( INTEGER ( ctfBody )? )
7514 CommonTree root_1
= (CommonTree
)adaptor
.nil();
7515 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(INTEGER
, "INTEGER"), root_1
);
7516 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:615:37: ( ctfBody )?
7517 if ( stream_ctfBody
.hasNext() ) {
7518 adaptor
.addChild(root_1
, stream_ctfBody
.nextTree());
7520 stream_ctfBody
.reset();
7522 adaptor
.addChild(root_0
, root_1
);
7528 retval
.tree
= root_0
;
7534 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:5: STRINGTOK ( ctfBody )?
7536 STRINGTOK170
=(Token
)match(input
,STRINGTOK
,FOLLOW_STRINGTOK_in_ctfTypeSpecifier3320
); if (state
.failed
) return retval
;
7537 if ( state
.backtracking
==0 ) stream_STRINGTOK
.add(STRINGTOK170
);
7539 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:15: ( ctfBody )?
7541 int LA54_0
= input
.LA(1);
7542 if ( (LA54_0
==LCURL
) ) {
7547 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:15: ctfBody
7549 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3322
);
7550 ctfBody171
=ctfBody();
7552 if (state
.failed
) return retval
;
7553 if ( state
.backtracking
==0 ) stream_ctfBody
.add(ctfBody171
.getTree());
7560 // elements: ctfBody
7562 // rule labels: retval
7563 // token list labels:
7564 // rule list labels:
7566 if ( state
.backtracking
==0 ) {
7567 retval
.tree
= root_0
;
7568 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7570 root_0
= (CommonTree
)adaptor
.nil();
7571 // 616:24: -> ^( STRING ( ctfBody )? )
7573 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:27: ^( STRING ( ctfBody )? )
7575 CommonTree root_1
= (CommonTree
)adaptor
.nil();
7576 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(STRING
, "STRING"), root_1
);
7577 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:36: ( ctfBody )?
7578 if ( stream_ctfBody
.hasNext() ) {
7579 adaptor
.addChild(root_1
, stream_ctfBody
.nextTree());
7581 stream_ctfBody
.reset();
7583 adaptor
.addChild(root_0
, root_1
);
7589 retval
.tree
= root_0
;
7596 retval
.stop
= input
.LT(-1);
7598 if ( state
.backtracking
==0 ) {
7599 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
7600 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
7604 catch (RecognitionException e
) {
7609 // do for sure before leaving
7613 // $ANTLR end "ctfTypeSpecifier"
7616 public static class ctfBody_return
extends ParserRuleReturnScope
{
7619 public CommonTree
getTree() { return tree
; }
7623 // $ANTLR start "ctfBody"
7624 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:619:1: ctfBody : LCURL ( ctfAssignmentExpressionList )? RCURL -> ( ctfAssignmentExpressionList )? ;
7625 public final CTFParser
.ctfBody_return
ctfBody() throws RecognitionException
{
7626 Symbols_stack
.push(new Symbols_scope());
7628 CTFParser
.ctfBody_return retval
= new CTFParser
.ctfBody_return();
7629 retval
.start
= input
.LT(1);
7631 CommonTree root_0
= null;
7633 Token LCURL172
=null;
7634 Token RCURL174
=null;
7635 ParserRuleReturnScope ctfAssignmentExpressionList173
=null;
7637 CommonTree LCURL172_tree
=null;
7638 CommonTree RCURL174_tree
=null;
7639 RewriteRuleTokenStream stream_LCURL
=new RewriteRuleTokenStream(adaptor
,"token LCURL");
7640 RewriteRuleTokenStream stream_RCURL
=new RewriteRuleTokenStream(adaptor
,"token RCURL");
7641 RewriteRuleSubtreeStream stream_ctfAssignmentExpressionList
=new RewriteRuleSubtreeStream(adaptor
,"rule ctfAssignmentExpressionList");
7644 Symbols_stack
.peek().types
= new HashSet
<String
>();
7647 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:624:3: ( LCURL ( ctfAssignmentExpressionList )? RCURL -> ( ctfAssignmentExpressionList )? )
7648 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:624:5: LCURL ( ctfAssignmentExpressionList )? RCURL
7650 LCURL172
=(Token
)match(input
,LCURL
,FOLLOW_LCURL_in_ctfBody3355
); if (state
.failed
) return retval
;
7651 if ( state
.backtracking
==0 ) stream_LCURL
.add(LCURL172
);
7653 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:624:11: ( ctfAssignmentExpressionList )?
7655 int LA56_0
= input
.LA(1);
7656 if ( (LA56_0
==ALIGNTOK
||(LA56_0
>= BOOLTOK
&& LA56_0
<= CHARTOK
)||LA56_0
==CLOCKTOK
||(LA56_0
>= COMPLEXTOK
&& LA56_0
<= DECIMAL_LITERAL
)||LA56_0
==DOUBLETOK
||(LA56_0
>= ENUMTOK
&& LA56_0
<= ENVTOK
)||(LA56_0
>= EVENTTOK
&& LA56_0
<= FLOATTOK
)||LA56_0
==HEX_LITERAL
||(LA56_0
>= IDENTIFIER
&& LA56_0
<= IMAGINARYTOK
)||LA56_0
==INTEGERTOK
||LA56_0
==INTTOK
||LA56_0
==LONGTOK
||LA56_0
==OCTAL_LITERAL
||(LA56_0
>= SHORTTOK
&& LA56_0
<= SIGNEDTOK
)||LA56_0
==STREAMTOK
||LA56_0
==STRINGTOK
||(LA56_0
>= STRING_LITERAL
&& LA56_0
<= STRUCTTOK
)||(LA56_0
>= TRACETOK
&& LA56_0
<= TYPEDEFTOK
)||(LA56_0
>= UNSIGNEDTOK
&& LA56_0
<= VOIDTOK
)) ) {
7661 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:624:11: ctfAssignmentExpressionList
7663 pushFollow(FOLLOW_ctfAssignmentExpressionList_in_ctfBody3357
);
7664 ctfAssignmentExpressionList173
=ctfAssignmentExpressionList();
7666 if (state
.failed
) return retval
;
7667 if ( state
.backtracking
==0 ) stream_ctfAssignmentExpressionList
.add(ctfAssignmentExpressionList173
.getTree());
7673 RCURL174
=(Token
)match(input
,RCURL
,FOLLOW_RCURL_in_ctfBody3360
); if (state
.failed
) return retval
;
7674 if ( state
.backtracking
==0 ) stream_RCURL
.add(RCURL174
);
7677 // elements: ctfAssignmentExpressionList
7679 // rule labels: retval
7680 // token list labels:
7681 // rule list labels:
7683 if ( state
.backtracking
==0 ) {
7684 retval
.tree
= root_0
;
7685 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
7687 root_0
= (CommonTree
)adaptor
.nil();
7688 // 624:46: -> ( ctfAssignmentExpressionList )?
7690 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:624:49: ( ctfAssignmentExpressionList )?
7691 if ( stream_ctfAssignmentExpressionList
.hasNext() ) {
7692 adaptor
.addChild(root_0
, stream_ctfAssignmentExpressionList
.nextTree());
7694 stream_ctfAssignmentExpressionList
.reset();
7699 retval
.tree
= root_0
;
7704 retval
.stop
= input
.LT(-1);
7706 if ( state
.backtracking
==0 ) {
7707 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
7708 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
7712 catch (RecognitionException e
) {
7717 // do for sure before leaving
7718 Symbols_stack
.pop();
7723 // $ANTLR end "ctfBody"
7726 public static class ctfAssignmentExpressionList_return
extends ParserRuleReturnScope
{
7729 public CommonTree
getTree() { return tree
; }
7733 // $ANTLR start "ctfAssignmentExpressionList"
7734 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:627:1: ctfAssignmentExpressionList : ( ctfAssignmentExpression TERM !)+ ;
7735 public final CTFParser
.ctfAssignmentExpressionList_return
ctfAssignmentExpressionList() throws RecognitionException
{
7736 CTFParser
.ctfAssignmentExpressionList_return retval
= new CTFParser
.ctfAssignmentExpressionList_return();
7737 retval
.start
= input
.LT(1);
7739 CommonTree root_0
= null;
7742 ParserRuleReturnScope ctfAssignmentExpression175
=null;
7744 CommonTree TERM176_tree
=null;
7747 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:628:3: ( ( ctfAssignmentExpression TERM !)+ )
7748 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:628:5: ( ctfAssignmentExpression TERM !)+
7750 root_0
= (CommonTree
)adaptor
.nil();
7753 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:628:5: ( ctfAssignmentExpression TERM !)+
7758 int LA57_0
= input
.LA(1);
7759 if ( (LA57_0
==ALIGNTOK
||(LA57_0
>= BOOLTOK
&& LA57_0
<= CHARTOK
)||LA57_0
==CLOCKTOK
||(LA57_0
>= COMPLEXTOK
&& LA57_0
<= DECIMAL_LITERAL
)||LA57_0
==DOUBLETOK
||(LA57_0
>= ENUMTOK
&& LA57_0
<= ENVTOK
)||(LA57_0
>= EVENTTOK
&& LA57_0
<= FLOATTOK
)||LA57_0
==HEX_LITERAL
||(LA57_0
>= IDENTIFIER
&& LA57_0
<= IMAGINARYTOK
)||LA57_0
==INTEGERTOK
||LA57_0
==INTTOK
||LA57_0
==LONGTOK
||LA57_0
==OCTAL_LITERAL
||(LA57_0
>= SHORTTOK
&& LA57_0
<= SIGNEDTOK
)||LA57_0
==STREAMTOK
||LA57_0
==STRINGTOK
||(LA57_0
>= STRING_LITERAL
&& LA57_0
<= STRUCTTOK
)||(LA57_0
>= TRACETOK
&& LA57_0
<= TYPEDEFTOK
)||(LA57_0
>= UNSIGNEDTOK
&& LA57_0
<= VOIDTOK
)) ) {
7765 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:628:6: ctfAssignmentExpression TERM !
7767 pushFollow(FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3379
);
7768 ctfAssignmentExpression175
=ctfAssignmentExpression();
7770 if (state
.failed
) return retval
;
7771 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, ctfAssignmentExpression175
.getTree());
7773 TERM176
=(Token
)match(input
,TERM
,FOLLOW_TERM_in_ctfAssignmentExpressionList3381
); if (state
.failed
) return retval
;
7778 if ( cnt57
>= 1 ) break loop57
;
7779 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
7780 EarlyExitException eee
= new EarlyExitException(57, input
);
7788 retval
.stop
= input
.LT(-1);
7790 if ( state
.backtracking
==0 ) {
7791 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
7792 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
7796 catch (RecognitionException e
) {
7801 // do for sure before leaving
7805 // $ANTLR end "ctfAssignmentExpressionList"
7808 public static class ctfAssignmentExpression_return
extends ParserRuleReturnScope
{
7811 public CommonTree
getTree() { return tree
; }
7815 // $ANTLR start "ctfAssignmentExpression"
7816 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:631:1: ctfAssignmentExpression : (left= unaryExpression (assignment= ASSIGNMENT right1= unaryExpression -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) ) | ( declarationSpecifiers {...}? declaratorList ) -> ^( TYPEDEF declaratorList declarationSpecifiers ) | typealiasDecl );
7817 public final CTFParser
.ctfAssignmentExpression_return
ctfAssignmentExpression() throws RecognitionException
{
7818 CTFParser
.ctfAssignmentExpression_return retval
= new CTFParser
.ctfAssignmentExpression_return();
7819 retval
.start
= input
.LT(1);
7821 CommonTree root_0
= null;
7823 Token assignment
=null;
7824 Token type_assignment
=null;
7825 ParserRuleReturnScope left
=null;
7826 ParserRuleReturnScope right1
=null;
7827 ParserRuleReturnScope right2
=null;
7828 ParserRuleReturnScope declarationSpecifiers177
=null;
7829 ParserRuleReturnScope declaratorList178
=null;
7830 ParserRuleReturnScope typealiasDecl179
=null;
7832 CommonTree assignment_tree
=null;
7833 CommonTree type_assignment_tree
=null;
7834 RewriteRuleTokenStream stream_TYPE_ASSIGNMENT
=new RewriteRuleTokenStream(adaptor
,"token TYPE_ASSIGNMENT");
7835 RewriteRuleTokenStream stream_ASSIGNMENT
=new RewriteRuleTokenStream(adaptor
,"token ASSIGNMENT");
7836 RewriteRuleSubtreeStream stream_declaratorList
=new RewriteRuleSubtreeStream(adaptor
,"rule declaratorList");
7837 RewriteRuleSubtreeStream stream_typeSpecifier
=new RewriteRuleSubtreeStream(adaptor
,"rule typeSpecifier");
7838 RewriteRuleSubtreeStream stream_unaryExpression
=new RewriteRuleSubtreeStream(adaptor
,"rule unaryExpression");
7839 RewriteRuleSubtreeStream stream_declarationSpecifiers
=new RewriteRuleSubtreeStream(adaptor
,"rule declarationSpecifiers");
7842 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:637:3: (left= unaryExpression (assignment= ASSIGNMENT right1= unaryExpression -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) ) | ( declarationSpecifiers {...}? declaratorList ) -> ^( TYPEDEF declaratorList declarationSpecifiers ) | typealiasDecl )
7844 switch ( input
.LA(1) ) {
7847 int LA59_1
= input
.LA(2);
7848 if ( ((LA59_1
>= ARROW
&& LA59_1
<= ASSIGNMENT
)||LA59_1
==DOT
||LA59_1
==OPENBRAC
||LA59_1
==TYPE_ASSIGNMENT
) ) {
7851 else if ( (LA59_1
==BOOLTOK
||LA59_1
==CHARTOK
||(LA59_1
>= COMPLEXTOK
&& LA59_1
<= CONSTTOK
)||LA59_1
==DOUBLETOK
||LA59_1
==ENUMTOK
||(LA59_1
>= FLOATINGPOINTTOK
&& LA59_1
<= FLOATTOK
)||(LA59_1
>= IDENTIFIER
&& LA59_1
<= IMAGINARYTOK
)||LA59_1
==INTEGERTOK
||LA59_1
==INTTOK
||LA59_1
==LONGTOK
||LA59_1
==POINTER
||LA59_1
==SHORTTOK
||LA59_1
==SIGNEDTOK
||LA59_1
==STRINGTOK
||LA59_1
==STRUCTTOK
||LA59_1
==TYPEDEFTOK
||(LA59_1
>= UNSIGNEDTOK
&& LA59_1
<= VOIDTOK
)) && (( inTypealiasAlias() || isTypeName(input
.LT(1).getText()) ))) {
7858 case CHARACTER_LITERAL
:
7860 case DECIMAL_LITERAL
:
7867 case STRING_LITERAL
:
7875 switch ( input
.LA(2) ) {
7880 case TYPE_ASSIGNMENT
:
7891 case FLOATINGPOINTTOK
:
7916 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
7917 int nvaeMark
= input
.mark();
7920 NoViableAltException nvae
=
7921 new NoViableAltException("", 59, 3, input
);
7924 input
.rewind(nvaeMark
);
7935 case FLOATINGPOINTTOK
:
7953 switch ( input
.LA(2) ) {
7958 case TYPE_ASSIGNMENT
:
7969 case FLOATINGPOINTTOK
:
7995 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
7996 int nvaeMark
= input
.mark();
7999 NoViableAltException nvae
=
8000 new NoViableAltException("", 59, 5, input
);
8003 input
.rewind(nvaeMark
);
8014 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
8015 NoViableAltException nvae
=
8016 new NoViableAltException("", 59, 0, input
);
8021 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:637:5: left= unaryExpression (assignment= ASSIGNMENT right1= unaryExpression -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) )
8023 pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3404
);
8024 left
=unaryExpression();
8026 if (state
.failed
) return retval
;
8027 if ( state
.backtracking
==0 ) stream_unaryExpression
.add(left
.getTree());
8028 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:638:7: (assignment= ASSIGNMENT right1= unaryExpression -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) )
8030 int LA58_0
= input
.LA(1);
8031 if ( (LA58_0
==ASSIGNMENT
) ) {
8034 else if ( (LA58_0
==TYPE_ASSIGNMENT
) ) {
8039 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
8040 NoViableAltException nvae
=
8041 new NoViableAltException("", 58, 0, input
);
8047 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:638:9: assignment= ASSIGNMENT right1= unaryExpression
8049 assignment
=(Token
)match(input
,ASSIGNMENT
,FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3416
); if (state
.failed
) return retval
;
8050 if ( state
.backtracking
==0 ) stream_ASSIGNMENT
.add(assignment
);
8052 pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3420
);
8053 right1
=unaryExpression();
8055 if (state
.failed
) return retval
;
8056 if ( state
.backtracking
==0 ) stream_unaryExpression
.add(right1
.getTree());
8058 // elements: right1, left
8060 // rule labels: right1, left, retval
8061 // token list labels:
8062 // rule list labels:
8064 if ( state
.backtracking
==0 ) {
8065 retval
.tree
= root_0
;
8066 RewriteRuleSubtreeStream stream_right1
=new RewriteRuleSubtreeStream(adaptor
,"rule right1",right1
!=null?right1
.getTree():null);
8067 RewriteRuleSubtreeStream stream_left
=new RewriteRuleSubtreeStream(adaptor
,"rule left",left
!=null?left
.getTree():null);
8068 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
8070 root_0
= (CommonTree
)adaptor
.nil();
8071 // 639:11: -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
8073 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:639:14: ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
8075 CommonTree root_1
= (CommonTree
)adaptor
.nil();
8076 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(CTF_EXPRESSION_VAL
, "CTF_EXPRESSION_VAL"), root_1
);
8077 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:640:18: ^( CTF_LEFT $left)
8079 CommonTree root_2
= (CommonTree
)adaptor
.nil();
8080 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(CTF_LEFT
, "CTF_LEFT"), root_2
);
8081 adaptor
.addChild(root_2
, stream_left
.nextTree());
8082 adaptor
.addChild(root_1
, root_2
);
8085 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:641:18: ^( CTF_RIGHT $right1)
8087 CommonTree root_2
= (CommonTree
)adaptor
.nil();
8088 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(CTF_RIGHT
, "CTF_RIGHT"), root_2
);
8089 adaptor
.addChild(root_2
, stream_right1
.nextTree());
8090 adaptor
.addChild(root_1
, root_2
);
8093 adaptor
.addChild(root_0
, root_1
);
8099 retval
.tree
= root_0
;
8105 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:642:9: type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier
8107 type_assignment
=(Token
)match(input
,TYPE_ASSIGNMENT
,FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3496
); if (state
.failed
) return retval
;
8108 if ( state
.backtracking
==0 ) stream_TYPE_ASSIGNMENT
.add(type_assignment
);
8110 pushFollow(FOLLOW_typeSpecifier_in_ctfAssignmentExpression3500
);
8111 right2
=typeSpecifier();
8113 if (state
.failed
) return retval
;
8114 if ( state
.backtracking
==0 ) stream_typeSpecifier
.add(right2
.getTree());
8116 // elements: left, right2
8118 // rule labels: left, right2, retval
8119 // token list labels:
8120 // rule list labels:
8122 if ( state
.backtracking
==0 ) {
8123 retval
.tree
= root_0
;
8124 RewriteRuleSubtreeStream stream_left
=new RewriteRuleSubtreeStream(adaptor
,"rule left",left
!=null?left
.getTree():null);
8125 RewriteRuleSubtreeStream stream_right2
=new RewriteRuleSubtreeStream(adaptor
,"rule right2",right2
!=null?right2
.getTree():null);
8126 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
8128 root_0
= (CommonTree
)adaptor
.nil();
8129 // 643:11: -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
8131 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:643:14: ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
8133 CommonTree root_1
= (CommonTree
)adaptor
.nil();
8134 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(CTF_EXPRESSION_TYPE
, "CTF_EXPRESSION_TYPE"), root_1
);
8135 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:644:18: ^( CTF_LEFT $left)
8137 CommonTree root_2
= (CommonTree
)adaptor
.nil();
8138 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(CTF_LEFT
, "CTF_LEFT"), root_2
);
8139 adaptor
.addChild(root_2
, stream_left
.nextTree());
8140 adaptor
.addChild(root_1
, root_2
);
8143 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:645:18: ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) )
8145 CommonTree root_2
= (CommonTree
)adaptor
.nil();
8146 root_2
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(CTF_RIGHT
, "CTF_RIGHT"), root_2
);
8147 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:645:30: ^( TYPE_SPECIFIER_LIST $right2)
8149 CommonTree root_3
= (CommonTree
)adaptor
.nil();
8150 root_3
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPE_SPECIFIER_LIST
, "TYPE_SPECIFIER_LIST"), root_3
);
8151 adaptor
.addChild(root_3
, stream_right2
.nextTree());
8152 adaptor
.addChild(root_2
, root_3
);
8155 adaptor
.addChild(root_1
, root_2
);
8158 adaptor
.addChild(root_0
, root_1
);
8164 retval
.tree
= root_0
;
8175 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:647:5: ( declarationSpecifiers {...}? declaratorList )
8177 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:647:5: ( declarationSpecifiers {...}? declaratorList )
8178 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:647:6: declarationSpecifiers {...}? declaratorList
8180 pushFollow(FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3583
);
8181 declarationSpecifiers177
=declarationSpecifiers();
8183 if (state
.failed
) return retval
;
8184 if ( state
.backtracking
==0 ) stream_declarationSpecifiers
.add(declarationSpecifiers177
.getTree());
8185 if ( !((inTypedef())) ) {
8186 if (state
.backtracking
>0) {state
.failed
=true; return retval
;}
8187 throw new FailedPredicateException(input
, "ctfAssignmentExpression", "inTypedef()");
8189 pushFollow(FOLLOW_declaratorList_in_ctfAssignmentExpression3587
);
8190 declaratorList178
=declaratorList();
8192 if (state
.failed
) return retval
;
8193 if ( state
.backtracking
==0 ) stream_declaratorList
.add(declaratorList178
.getTree());
8197 // elements: declarationSpecifiers, declaratorList
8199 // rule labels: retval
8200 // token list labels:
8201 // rule list labels:
8203 if ( state
.backtracking
==0 ) {
8204 retval
.tree
= root_0
;
8205 RewriteRuleSubtreeStream stream_retval
=new RewriteRuleSubtreeStream(adaptor
,"rule retval",retval
!=null?retval
.getTree():null);
8207 root_0
= (CommonTree
)adaptor
.nil();
8208 // 648:7: -> ^( TYPEDEF declaratorList declarationSpecifiers )
8210 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:648:10: ^( TYPEDEF declaratorList declarationSpecifiers )
8212 CommonTree root_1
= (CommonTree
)adaptor
.nil();
8213 root_1
= (CommonTree
)adaptor
.becomeRoot((CommonTree
)adaptor
.create(TYPEDEF
, "TYPEDEF"), root_1
);
8214 adaptor
.addChild(root_1
, stream_declaratorList
.nextTree());
8215 adaptor
.addChild(root_1
, stream_declarationSpecifiers
.nextTree());
8216 adaptor
.addChild(root_0
, root_1
);
8222 retval
.tree
= root_0
;
8228 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:649:5: typealiasDecl
8230 root_0
= (CommonTree
)adaptor
.nil();
8233 pushFollow(FOLLOW_typealiasDecl_in_ctfAssignmentExpression3610
);
8234 typealiasDecl179
=typealiasDecl();
8236 if (state
.failed
) return retval
;
8237 if ( state
.backtracking
==0 ) adaptor
.addChild(root_0
, typealiasDecl179
.getTree());
8243 retval
.stop
= input
.LT(-1);
8245 if ( state
.backtracking
==0 ) {
8246 retval
.tree
= (CommonTree
)adaptor
.rulePostProcessing(root_0
);
8247 adaptor
.setTokenBoundaries(retval
.tree
, retval
.start
, retval
.stop
);
8249 if ( state
.backtracking
==0 ) {
8256 catch (RecognitionException e
) {
8261 // do for sure before leaving
8265 // $ANTLR end "ctfAssignmentExpression"
8267 // $ANTLR start synpred1_CTFParser
8268 public final void synpred1_CTFParser_fragment() throws RecognitionException
{
8269 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:206:5: ( IDENTIFIER )
8270 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:206:6: IDENTIFIER
8272 match(input
,IDENTIFIER
,FOLLOW_IDENTIFIER_in_synpred1_CTFParser553
); if (state
.failed
) return;
8277 // $ANTLR end synpred1_CTFParser
8279 // $ANTLR start synpred2_CTFParser
8280 public final void synpred2_CTFParser_fragment() throws RecognitionException
{
8281 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:208:5: ( ctfKeyword )
8282 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:208:6: ctfKeyword
8284 pushFollow(FOLLOW_ctfKeyword_in_synpred2_CTFParser579
);
8287 if (state
.failed
) return;
8292 // $ANTLR end synpred2_CTFParser
8294 // $ANTLR start synpred3_CTFParser
8295 public final void synpred3_CTFParser_fragment() throws RecognitionException
{
8296 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:209:5: ( STRING_LITERAL )
8297 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:209:6: STRING_LITERAL
8299 match(input
,STRING_LITERAL
,FOLLOW_STRING_LITERAL_in_synpred3_CTFParser599
); if (state
.failed
) return;
8304 // $ANTLR end synpred3_CTFParser
8308 public final boolean synpred1_CTFParser() {
8309 state
.backtracking
++;
8310 int start
= input
.mark();
8312 synpred1_CTFParser_fragment(); // can never throw exception
8313 } catch (RecognitionException re
) {
8314 System
.err
.println("impossible: "+re
);
8316 boolean success
= !state
.failed
;
8317 input
.rewind(start
);
8318 state
.backtracking
--;
8322 public final boolean synpred3_CTFParser() {
8323 state
.backtracking
++;
8324 int start
= input
.mark();
8326 synpred3_CTFParser_fragment(); // can never throw exception
8327 } catch (RecognitionException re
) {
8328 System
.err
.println("impossible: "+re
);
8330 boolean success
= !state
.failed
;
8331 input
.rewind(start
);
8332 state
.backtracking
--;
8336 public final boolean synpred2_CTFParser() {
8337 state
.backtracking
++;
8338 int start
= input
.mark();
8340 synpred2_CTFParser_fragment(); // can never throw exception
8341 } catch (RecognitionException re
) {
8342 System
.err
.println("impossible: "+re
);
8344 boolean success
= !state
.failed
;
8345 input
.rewind(start
);
8346 state
.backtracking
--;
8352 protected DFA24 dfa24
= new DFA24(this);
8353 static final String DFA24_eotS
=
8355 static final String DFA24_eofS
=
8357 static final String DFA24_minS
=
8358 "\1\45\1\23\1\0\1\23\1\0\2\uffff\1\0";
8359 static final String DFA24_maxS
=
8360 "\2\71\1\0\1\71\1\0\2\uffff\1\0";
8361 static final String DFA24_acceptS
=
8362 "\5\uffff\1\1\1\2\1\uffff";
8363 static final String DFA24_specialS
=
8364 "\2\uffff\1\0\1\uffff\1\1\2\uffff\1\2}>";
8365 static final String
[] DFA24_transitionS
= {
8366 "\1\2\23\uffff\1\1",
8367 "\1\3\21\uffff\1\4\23\uffff\1\1",
8369 "\1\3\21\uffff\1\7\23\uffff\1\1",
8376 static final short[] DFA24_eot
= DFA
.unpackEncodedString(DFA24_eotS
);
8377 static final short[] DFA24_eof
= DFA
.unpackEncodedString(DFA24_eofS
);
8378 static final char[] DFA24_min
= DFA
.unpackEncodedStringToUnsignedChars(DFA24_minS
);
8379 static final char[] DFA24_max
= DFA
.unpackEncodedStringToUnsignedChars(DFA24_maxS
);
8380 static final short[] DFA24_accept
= DFA
.unpackEncodedString(DFA24_acceptS
);
8381 static final short[] DFA24_special
= DFA
.unpackEncodedString(DFA24_specialS
);
8382 static final short[][] DFA24_transition
;
8385 int numStates
= DFA24_transitionS
.length
;
8386 DFA24_transition
= new short[numStates
][];
8387 for (int i
=0; i
<numStates
; i
++) {
8388 DFA24_transition
[i
] = DFA
.unpackEncodedString(DFA24_transitionS
[i
]);
8392 protected class DFA24
extends DFA
{
8394 public DFA24(BaseRecognizer recognizer
) {
8395 this.recognizer
= recognizer
;
8396 this.decisionNumber
= 24;
8397 this.eot
= DFA24_eot
;
8398 this.eof
= DFA24_eof
;
8399 this.min
= DFA24_min
;
8400 this.max
= DFA24_max
;
8401 this.accept
= DFA24_accept
;
8402 this.special
= DFA24_special
;
8403 this.transition
= DFA24_transition
;
8406 public String
getDescription() {
8407 return "371:10: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )";
8410 public int specialStateTransition(int s
, IntStream _input
) throws NoViableAltException
{
8411 TokenStream input
= (TokenStream
)_input
;
8415 int LA24_2
= input
.LA(1);
8417 int index24_2
= input
.index();
8420 if ( ((inTypedef())) ) {s
= 5;}
8421 else if ( (true) ) {s
= 6;}
8423 input
.seek(index24_2
);
8424 if ( s
>=0 ) return s
;
8428 int LA24_4
= input
.LA(1);
8430 int index24_4
= input
.index();
8433 if ( ((inTypedef())) ) {s
= 5;}
8434 else if ( (true) ) {s
= 6;}
8436 input
.seek(index24_4
);
8437 if ( s
>=0 ) return s
;
8441 int LA24_7
= input
.LA(1);
8443 int index24_7
= input
.index();
8446 if ( ((inTypedef())) ) {s
= 5;}
8447 else if ( (true) ) {s
= 6;}
8449 input
.seek(index24_7
);
8450 if ( s
>=0 ) return s
;
8453 if (state
.backtracking
>0) {state
.failed
=true; return -1;}
8454 NoViableAltException nvae
=
8455 new NoViableAltException(getDescription(), 24, _s
, input
);
8461 public static final BitSet FOLLOW_declaration_in_parse442
= new BitSet(new long[]{0xA0002560ED0C1500L
,0x000000000000E74AL
});
8462 public static final BitSet FOLLOW_EOF_in_parse445
= new BitSet(new long[]{0x0000000000000002L
});
8463 public static final BitSet FOLLOW_SIGN_in_numberLiteral467
= new BitSet(new long[]{0x4020000800100000L
});
8464 public static final BitSet FOLLOW_HEX_LITERAL_in_numberLiteral478
= new BitSet(new long[]{0x0000000000000002L
});
8465 public static final BitSet FOLLOW_DECIMAL_LITERAL_in_numberLiteral499
= new BitSet(new long[]{0x0000000000000002L
});
8466 public static final BitSet FOLLOW_OCTAL_LITERAL_in_numberLiteral520
= new BitSet(new long[]{0x0000000000000002L
});
8467 public static final BitSet FOLLOW_IDENTIFIER_in_primaryExpression558
= new BitSet(new long[]{0x0000000000000002L
});
8468 public static final BitSet FOLLOW_ctfKeyword_in_primaryExpression584
= new BitSet(new long[]{0x0000000000000002L
});
8469 public static final BitSet FOLLOW_STRING_LITERAL_in_primaryExpression604
= new BitSet(new long[]{0x0000000000000002L
});
8470 public static final BitSet FOLLOW_numberLiteral_in_primaryExpression629
= new BitSet(new long[]{0x0000000000000002L
});
8471 public static final BitSet FOLLOW_enumConstant_in_primaryExpression635
= new BitSet(new long[]{0x0000000000000002L
});
8472 public static final BitSet FOLLOW_CHARACTER_LITERAL_in_primaryExpression641
= new BitSet(new long[]{0x0000000000000002L
});
8473 public static final BitSet FOLLOW_OPENBRAC_in_postfixExpressionSuffix654
= new BitSet(new long[]{0xC020002828101210L
,0x000000000000012AL
});
8474 public static final BitSet FOLLOW_unaryExpression_in_postfixExpressionSuffix656
= new BitSet(new long[]{0x0000000000002000L
});
8475 public static final BitSet FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix658
= new BitSet(new long[]{0x0000000000000002L
});
8476 public static final BitSet FOLLOW_DOT_in_postfixExpressionSuffix668
= new BitSet(new long[]{0x0000002000000000L
});
8477 public static final BitSet FOLLOW_ARROW_in_postfixExpressionSuffix674
= new BitSet(new long[]{0x0000002000000000L
});
8478 public static final BitSet FOLLOW_IDENTIFIER_in_postfixExpressionSuffix677
= new BitSet(new long[]{0x0000000000000002L
});
8479 public static final BitSet FOLLOW_DOT_in_postfixCtfExpression712
= new BitSet(new long[]{0x0000000028001000L
,0x0000000000000102L
});
8480 public static final BitSet FOLLOW_ctfSpecifierHead_in_postfixCtfExpression715
= new BitSet(new long[]{0x0000000000000002L
});
8481 public static final BitSet FOLLOW_primaryExpression_in_postfixExpression748
= new BitSet(new long[]{0x0100000000400022L
});
8482 public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression750
= new BitSet(new long[]{0x0100000000400022L
});
8483 public static final BitSet FOLLOW_ctfSpecifierHead_in_postfixExpression759
= new BitSet(new long[]{0x0100000000400020L
});
8484 public static final BitSet FOLLOW_postfixCtfExpression_in_postfixExpression761
= new BitSet(new long[]{0x0100000000400020L
});
8485 public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression764
= new BitSet(new long[]{0x0100000000400022L
});
8486 public static final BitSet FOLLOW_postfixExpression_in_unaryExpression780
= new BitSet(new long[]{0x0000000000000002L
});
8487 public static final BitSet FOLLOW_STRING_LITERAL_in_enumConstant797
= new BitSet(new long[]{0x0000000000000002L
});
8488 public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant811
= new BitSet(new long[]{0x0000000000000002L
});
8489 public static final BitSet FOLLOW_ctfKeyword_in_enumConstant825
= new BitSet(new long[]{0x0000000000000002L
});
8490 public static final BitSet FOLLOW_declarationSpecifiers_in_declaration856
= new BitSet(new long[]{0x0200002000000000L
,0x0000000000000080L
});
8491 public static final BitSet FOLLOW_declaratorList_in_declaration858
= new BitSet(new long[]{0x0000000000000000L
,0x0000000000000080L
});
8492 public static final BitSet FOLLOW_TERM_in_declaration861
= new BitSet(new long[]{0x0000000000000002L
});
8493 public static final BitSet FOLLOW_ctfSpecifier_in_declaration929
= new BitSet(new long[]{0x0000000000000000L
,0x0000000000000080L
});
8494 public static final BitSet FOLLOW_TERM_in_declaration931
= new BitSet(new long[]{0x0000000000000002L
});
8495 public static final BitSet FOLLOW_storageClassSpecifier_in_declarationSpecifiers969
= new BitSet(new long[]{0xA0002560C50C0502L
,0x000000000000E448L
});
8496 public static final BitSet FOLLOW_typeQualifier_in_declarationSpecifiers979
= new BitSet(new long[]{0xA0002560C50C0502L
,0x000000000000E448L
});
8497 public static final BitSet FOLLOW_typeSpecifier_in_declarationSpecifiers989
= new BitSet(new long[]{0xA0002560C50C0502L
,0x000000000000E448L
});
8498 public static final BitSet FOLLOW_declarator_in_declaratorList1019
= new BitSet(new long[]{0x1000000000000002L
});
8499 public static final BitSet FOLLOW_SEPARATOR_in_declaratorList1022
= new BitSet(new long[]{0x0200002000000000L
});
8500 public static final BitSet FOLLOW_declarator_in_declaratorList1024
= new BitSet(new long[]{0x1000000000000002L
});
8501 public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList1054
= new BitSet(new long[]{0x1000000000000002L
});
8502 public static final BitSet FOLLOW_SEPARATOR_in_abstractDeclaratorList1057
= new BitSet(new long[]{0x0200402000000000L
});
8503 public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList1059
= new BitSet(new long[]{0x1000000000000002L
});
8504 public static final BitSet FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1089
= new BitSet(new long[]{0x0000000000000002L
});
8505 public static final BitSet FOLLOW_FLOATTOK_in_typeSpecifier1105
= new BitSet(new long[]{0x0000000000000002L
});
8506 public static final BitSet FOLLOW_INTTOK_in_typeSpecifier1111
= new BitSet(new long[]{0x0000000000000002L
});
8507 public static final BitSet FOLLOW_LONGTOK_in_typeSpecifier1117
= new BitSet(new long[]{0x0000000000000002L
});
8508 public static final BitSet FOLLOW_SHORTTOK_in_typeSpecifier1123
= new BitSet(new long[]{0x0000000000000002L
});
8509 public static final BitSet FOLLOW_SIGNEDTOK_in_typeSpecifier1129
= new BitSet(new long[]{0x0000000000000002L
});
8510 public static final BitSet FOLLOW_UNSIGNEDTOK_in_typeSpecifier1135
= new BitSet(new long[]{0x0000000000000002L
});
8511 public static final BitSet FOLLOW_CHARTOK_in_typeSpecifier1141
= new BitSet(new long[]{0x0000000000000002L
});
8512 public static final BitSet FOLLOW_DOUBLETOK_in_typeSpecifier1147
= new BitSet(new long[]{0x0000000000000002L
});
8513 public static final BitSet FOLLOW_VOIDTOK_in_typeSpecifier1153
= new BitSet(new long[]{0x0000000000000002L
});
8514 public static final BitSet FOLLOW_BOOLTOK_in_typeSpecifier1159
= new BitSet(new long[]{0x0000000000000002L
});
8515 public static final BitSet FOLLOW_COMPLEXTOK_in_typeSpecifier1165
= new BitSet(new long[]{0x0000000000000002L
});
8516 public static final BitSet FOLLOW_IMAGINARYTOK_in_typeSpecifier1171
= new BitSet(new long[]{0x0000000000000002L
});
8517 public static final BitSet FOLLOW_structSpecifier_in_typeSpecifier1177
= new BitSet(new long[]{0x0000000000000002L
});
8518 public static final BitSet FOLLOW_variantSpecifier_in_typeSpecifier1183
= new BitSet(new long[]{0x0000000000000002L
});
8519 public static final BitSet FOLLOW_enumSpecifier_in_typeSpecifier1189
= new BitSet(new long[]{0x0000000000000002L
});
8520 public static final BitSet FOLLOW_ctfTypeSpecifier_in_typeSpecifier1195
= new BitSet(new long[]{0x0000000000000002L
});
8521 public static final BitSet FOLLOW_typedefName_in_typeSpecifier1205
= new BitSet(new long[]{0x0000000000000002L
});
8522 public static final BitSet FOLLOW_CONSTTOK_in_typeQualifier1218
= new BitSet(new long[]{0x0000000000000002L
});
8523 public static final BitSet FOLLOW_ALIGNTOK_in_alignAttribute1231
= new BitSet(new long[]{0x0000400000000000L
});
8524 public static final BitSet FOLLOW_LPAREN_in_alignAttribute1233
= new BitSet(new long[]{0xC020002828101210L
,0x000000000000012AL
});
8525 public static final BitSet FOLLOW_unaryExpression_in_alignAttribute1235
= new BitSet(new long[]{0x0800000000000000L
});
8526 public static final BitSet FOLLOW_RPAREN_in_alignAttribute1237
= new BitSet(new long[]{0x0000000000000002L
});
8527 public static final BitSet FOLLOW_LCURL_in_structBody1271
= new BitSet(new long[]{0xA4002560C50C0500L
,0x000000000000E648L
});
8528 public static final BitSet FOLLOW_structOrVariantDeclarationList_in_structBody1273
= new BitSet(new long[]{0x0400000000000000L
});
8529 public static final BitSet FOLLOW_RCURL_in_structBody1276
= new BitSet(new long[]{0x0000000000000002L
});
8530 public static final BitSet FOLLOW_STRUCTTOK_in_structSpecifier1304
= new BitSet(new long[]{0x0000082000000000L
});
8531 public static final BitSet FOLLOW_structName_in_structSpecifier1329
= new BitSet(new long[]{0x0000080000000012L
});
8532 public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1351
= new BitSet(new long[]{0x0000000000000002L
});
8533 public static final BitSet FOLLOW_structBody_in_structSpecifier1387
= new BitSet(new long[]{0x0000000000000012L
});
8534 public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1418
= new BitSet(new long[]{0x0000000000000002L
});
8535 public static final BitSet FOLLOW_structBody_in_structSpecifier1534
= new BitSet(new long[]{0x0000000000000012L
});
8536 public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1552
= new BitSet(new long[]{0x0000000000000002L
});
8537 public static final BitSet FOLLOW_IDENTIFIER_in_structName1618
= new BitSet(new long[]{0x0000000000000002L
});
8538 public static final BitSet FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1639
= new BitSet(new long[]{0xA0002560C50C0502L
,0x000000000000E648L
});
8539 public static final BitSet FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1672
= new BitSet(new long[]{0x0200002000000000L
});
8540 public static final BitSet FOLLOW_declaratorList_in_structOrVariantDeclaration1713
= new BitSet(new long[]{0x0000000000000000L
,0x0000000000000080L
});
8541 public static final BitSet FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1751
= new BitSet(new long[]{0x0000000000000000L
,0x0000000000000080L
});
8542 public static final BitSet FOLLOW_typealiasDecl_in_structOrVariantDeclaration1810
= new BitSet(new long[]{0x0000000000000000L
,0x0000000000000080L
});
8543 public static final BitSet FOLLOW_TERM_in_structOrVariantDeclaration1822
= new BitSet(new long[]{0x0000000000000002L
});
8544 public static final BitSet FOLLOW_typeQualifier_in_specifierQualifierList1836
= new BitSet(new long[]{0xA0002560C50C0502L
,0x000000000000E048L
});
8545 public static final BitSet FOLLOW_typeSpecifier_in_specifierQualifierList1840
= new BitSet(new long[]{0xA0002560C50C0502L
,0x000000000000E048L
});
8546 public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1873
= new BitSet(new long[]{0x1000000000000002L
});
8547 public static final BitSet FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1876
= new BitSet(new long[]{0x0200002000000000L
});
8548 public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1878
= new BitSet(new long[]{0x1000000000000002L
});
8549 public static final BitSet FOLLOW_declarator_in_structOrVariantDeclarator1917
= new BitSet(new long[]{0x0000000000004002L
});
8550 public static final BitSet FOLLOW_COLON_in_structOrVariantDeclarator1920
= new BitSet(new long[]{0x4020000800100000L
});
8551 public static final BitSet FOLLOW_numberLiteral_in_structOrVariantDeclarator1922
= new BitSet(new long[]{0x0000000000000002L
});
8552 public static final BitSet FOLLOW_VARIANTTOK_in_variantSpecifier1946
= new BitSet(new long[]{0x0000882000000000L
});
8553 public static final BitSet FOLLOW_variantName_in_variantSpecifier1964
= new BitSet(new long[]{0x0000880000000000L
});
8554 public static final BitSet FOLLOW_variantTag_in_variantSpecifier1994
= new BitSet(new long[]{0x0000080000000002L
});
8555 public static final BitSet FOLLOW_variantBody_in_variantSpecifier2020
= new BitSet(new long[]{0x0000000000000002L
});
8556 public static final BitSet FOLLOW_variantBody_in_variantSpecifier2088
= new BitSet(new long[]{0x0000000000000002L
});
8557 public static final BitSet FOLLOW_variantTag_in_variantSpecifier2109
= new BitSet(new long[]{0x0000080000000000L
});
8558 public static final BitSet FOLLOW_variantBody_in_variantSpecifier2111
= new BitSet(new long[]{0x0000000000000002L
});
8559 public static final BitSet FOLLOW_variantBody_in_variantSpecifier2118
= new BitSet(new long[]{0x0000000000000002L
});
8560 public static final BitSet FOLLOW_IDENTIFIER_in_variantName2150
= new BitSet(new long[]{0x0000000000000002L
});
8561 public static final BitSet FOLLOW_LCURL_in_variantBody2181
= new BitSet(new long[]{0xA0002560C50C0500L
,0x000000000000E648L
});
8562 public static final BitSet FOLLOW_structOrVariantDeclarationList_in_variantBody2183
= new BitSet(new long[]{0x0400000000000000L
});
8563 public static final BitSet FOLLOW_RCURL_in_variantBody2185
= new BitSet(new long[]{0x0000000000000002L
});
8564 public static final BitSet FOLLOW_LT_in_variantTag2212
= new BitSet(new long[]{0x0000002000000000L
});
8565 public static final BitSet FOLLOW_IDENTIFIER_in_variantTag2214
= new BitSet(new long[]{0x0000000100000000L
});
8566 public static final BitSet FOLLOW_GT_in_variantTag2216
= new BitSet(new long[]{0x0000000000000002L
});
8567 public static final BitSet FOLLOW_ENUMTOK_in_enumSpecifier2237
= new BitSet(new long[]{0x0000082000004000L
});
8568 public static final BitSet FOLLOW_enumName_in_enumSpecifier2276
= new BitSet(new long[]{0x0000080000004002L
});
8569 public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2308
= new BitSet(new long[]{0x0000080000000000L
});
8570 public static final BitSet FOLLOW_enumBody_in_enumSpecifier2310
= new BitSet(new long[]{0x0000000000000002L
});
8571 public static final BitSet FOLLOW_enumBody_in_enumSpecifier2340
= new BitSet(new long[]{0x0000000000000002L
});
8572 public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2432
= new BitSet(new long[]{0x0000080000000000L
});
8573 public static final BitSet FOLLOW_enumBody_in_enumSpecifier2434
= new BitSet(new long[]{0x0000000000000002L
});
8574 public static final BitSet FOLLOW_enumBody_in_enumSpecifier2458
= new BitSet(new long[]{0x0000000000000002L
});
8575 public static final BitSet FOLLOW_IDENTIFIER_in_enumName2502
= new BitSet(new long[]{0x0000000000000002L
});
8576 public static final BitSet FOLLOW_LCURL_in_enumBody2523
= new BitSet(new long[]{0x8000002020000010L
,0x0000000000000028L
});
8577 public static final BitSet FOLLOW_enumeratorList_in_enumBody2525
= new BitSet(new long[]{0x1400000000000000L
});
8578 public static final BitSet FOLLOW_SEPARATOR_in_enumBody2527
= new BitSet(new long[]{0x0400000000000000L
});
8579 public static final BitSet FOLLOW_RCURL_in_enumBody2530
= new BitSet(new long[]{0x0000000000000002L
});
8580 public static final BitSet FOLLOW_COLON_in_enumContainerType2551
= new BitSet(new long[]{0xA0002560C50C0500L
,0x000000000000E448L
});
8581 public static final BitSet FOLLOW_declarationSpecifiers_in_enumContainerType2553
= new BitSet(new long[]{0x0000000000000002L
});
8582 public static final BitSet FOLLOW_enumerator_in_enumeratorList2574
= new BitSet(new long[]{0x1000000000000002L
});
8583 public static final BitSet FOLLOW_SEPARATOR_in_enumeratorList2577
= new BitSet(new long[]{0x8000002020000010L
,0x0000000000000028L
});
8584 public static final BitSet FOLLOW_enumerator_in_enumeratorList2579
= new BitSet(new long[]{0x1000000000000002L
});
8585 public static final BitSet FOLLOW_enumConstant_in_enumerator2605
= new BitSet(new long[]{0x0000000000000042L
});
8586 public static final BitSet FOLLOW_enumeratorValue_in_enumerator2607
= new BitSet(new long[]{0x0000000000000002L
});
8587 public static final BitSet FOLLOW_ASSIGNMENT_in_enumeratorValue2621
= new BitSet(new long[]{0xC020002828101210L
,0x000000000000012AL
});
8588 public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2625
= new BitSet(new long[]{0x0000000002000002L
});
8589 public static final BitSet FOLLOW_ELIPSES_in_enumeratorValue2664
= new BitSet(new long[]{0xC020002828101210L
,0x000000000000012AL
});
8590 public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2668
= new BitSet(new long[]{0x0000000000000002L
});
8591 public static final BitSet FOLLOW_pointer_in_declarator2711
= new BitSet(new long[]{0x0200002000000000L
});
8592 public static final BitSet FOLLOW_directDeclarator_in_declarator2714
= new BitSet(new long[]{0x0000000000000002L
});
8593 public static final BitSet FOLLOW_IDENTIFIER_in_directDeclarator2752
= new BitSet(new long[]{0x0100000000000002L
});
8594 public static final BitSet FOLLOW_directDeclaratorSuffix_in_directDeclarator2792
= new BitSet(new long[]{0x0100000000000002L
});
8595 public static final BitSet FOLLOW_OPENBRAC_in_directDeclaratorSuffix2806
= new BitSet(new long[]{0xC020002828101210L
,0x000000000000012AL
});
8596 public static final BitSet FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2808
= new BitSet(new long[]{0x0000000000002000L
});
8597 public static final BitSet FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2810
= new BitSet(new long[]{0x0000000000000002L
});
8598 public static final BitSet FOLLOW_unaryExpression_in_directDeclaratorLength2838
= new BitSet(new long[]{0x0000000000000002L
});
8599 public static final BitSet FOLLOW_pointer_in_abstractDeclarator2851
= new BitSet(new long[]{0x0200402000000002L
});
8600 public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2854
= new BitSet(new long[]{0x0000000000000002L
});
8601 public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2879
= new BitSet(new long[]{0x0000000000000002L
});
8602 public static final BitSet FOLLOW_IDENTIFIER_in_directAbstractDeclarator2916
= new BitSet(new long[]{0x0100000000000002L
});
8603 public static final BitSet FOLLOW_LPAREN_in_directAbstractDeclarator2927
= new BitSet(new long[]{0x0200402000000000L
});
8604 public static final BitSet FOLLOW_abstractDeclarator_in_directAbstractDeclarator2929
= new BitSet(new long[]{0x0800000000000000L
});
8605 public static final BitSet FOLLOW_RPAREN_in_directAbstractDeclarator2931
= new BitSet(new long[]{0x0100000000000002L
});
8606 public static final BitSet FOLLOW_OPENBRAC_in_directAbstractDeclarator2946
= new BitSet(new long[]{0xC020002828103210L
,0x000000000000012AL
});
8607 public static final BitSet FOLLOW_unaryExpression_in_directAbstractDeclarator2948
= new BitSet(new long[]{0x0000000000002000L
});
8608 public static final BitSet FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2951
= new BitSet(new long[]{0x0000000000000002L
});
8609 public static final BitSet FOLLOW_POINTER_in_pointer2969
= new BitSet(new long[]{0x0000000000080002L
});
8610 public static final BitSet FOLLOW_typeQualifierList_in_pointer2971
= new BitSet(new long[]{0x0000000000000002L
});
8611 public static final BitSet FOLLOW_typeQualifier_in_typeQualifierList2994
= new BitSet(new long[]{0x0000000000080002L
});
8612 public static final BitSet FOLLOW_IDENTIFIER_in_typedefName3010
= new BitSet(new long[]{0x0000000000000002L
});
8613 public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasTarget3027
= new BitSet(new long[]{0x0200402000000002L
});
8614 public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasTarget3029
= new BitSet(new long[]{0x0000000000000002L
});
8615 public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias3055
= new BitSet(new long[]{0x0000000000000002L
});
8616 public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasAlias3061
= new BitSet(new long[]{0x0200402000000002L
});
8617 public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias3063
= new BitSet(new long[]{0x0000000000000002L
});
8618 public static final BitSet FOLLOW_TYPEALIASTOK_in_typealiasDecl3077
= new BitSet(new long[]{0xA0002560C50C0500L
,0x000000000000E448L
});
8619 public static final BitSet FOLLOW_typealiasTarget_in_typealiasDecl3079
= new BitSet(new long[]{0x0000000000000000L
,0x0000000000000800L
});
8620 public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3081
= new BitSet(new long[]{0xA2006560C50C0500L
,0x000000000000E448L
});
8621 public static final BitSet FOLLOW_typealiasAlias_in_typealiasDecl3083
= new BitSet(new long[]{0x0000000000000002L
});
8622 public static final BitSet FOLLOW_ctfSpecifierHead_in_ctfSpecifier3183
= new BitSet(new long[]{0x0000080000000000L
});
8623 public static final BitSet FOLLOW_ctfBody_in_ctfSpecifier3185
= new BitSet(new long[]{0x0000000000000002L
});
8624 public static final BitSet FOLLOW_typealiasDecl_in_ctfSpecifier3202
= new BitSet(new long[]{0x0000000000000002L
});
8625 public static final BitSet FOLLOW_EVENTTOK_in_ctfSpecifierHead3223
= new BitSet(new long[]{0x0000000000000002L
});
8626 public static final BitSet FOLLOW_STREAMTOK_in_ctfSpecifierHead3233
= new BitSet(new long[]{0x0000000000000002L
});
8627 public static final BitSet FOLLOW_TRACETOK_in_ctfSpecifierHead3243
= new BitSet(new long[]{0x0000000000000002L
});
8628 public static final BitSet FOLLOW_ENVTOK_in_ctfSpecifierHead3253
= new BitSet(new long[]{0x0000000000000002L
});
8629 public static final BitSet FOLLOW_CLOCKTOK_in_ctfSpecifierHead3263
= new BitSet(new long[]{0x0000000000000002L
});
8630 public static final BitSet FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3286
= new BitSet(new long[]{0x0000080000000000L
});
8631 public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3288
= new BitSet(new long[]{0x0000000000000002L
});
8632 public static final BitSet FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3303
= new BitSet(new long[]{0x0000080000000000L
});
8633 public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3305
= new BitSet(new long[]{0x0000000000000002L
});
8634 public static final BitSet FOLLOW_STRINGTOK_in_ctfTypeSpecifier3320
= new BitSet(new long[]{0x0000080000000002L
});
8635 public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3322
= new BitSet(new long[]{0x0000000000000002L
});
8636 public static final BitSet FOLLOW_LCURL_in_ctfBody3355
= new BitSet(new long[]{0xE4202568ED1C1710L
,0x000000000000E76AL
});
8637 public static final BitSet FOLLOW_ctfAssignmentExpressionList_in_ctfBody3357
= new BitSet(new long[]{0x0400000000000000L
});
8638 public static final BitSet FOLLOW_RCURL_in_ctfBody3360
= new BitSet(new long[]{0x0000000000000002L
});
8639 public static final BitSet FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3379
= new BitSet(new long[]{0x0000000000000000L
,0x0000000000000080L
});
8640 public static final BitSet FOLLOW_TERM_in_ctfAssignmentExpressionList3381
= new BitSet(new long[]{0xE0202568ED1C1712L
,0x000000000000E76AL
});
8641 public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3404
= new BitSet(new long[]{0x0000000000000040L
,0x0000000000000800L
});
8642 public static final BitSet FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3416
= new BitSet(new long[]{0xC020002828101210L
,0x000000000000012AL
});
8643 public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3420
= new BitSet(new long[]{0x0000000000000002L
});
8644 public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3496
= new BitSet(new long[]{0xA0002560C5040500L
,0x000000000000E048L
});
8645 public static final BitSet FOLLOW_typeSpecifier_in_ctfAssignmentExpression3500
= new BitSet(new long[]{0x0000000000000002L
});
8646 public static final BitSet FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3583
= new BitSet(new long[]{0x0200002000000000L
});
8647 public static final BitSet FOLLOW_declaratorList_in_ctfAssignmentExpression3587
= new BitSet(new long[]{0x0000000000000002L
});
8648 public static final BitSet FOLLOW_typealiasDecl_in_ctfAssignmentExpression3610
= new BitSet(new long[]{0x0000000000000002L
});
8649 public static final BitSet FOLLOW_IDENTIFIER_in_synpred1_CTFParser553
= new BitSet(new long[]{0x0000000000000002L
});
8650 public static final BitSet FOLLOW_ctfKeyword_in_synpred2_CTFParser579
= new BitSet(new long[]{0x0000000000000002L
});
8651 public static final BitSet FOLLOW_STRING_LITERAL_in_synpred3_CTFParser599
= new BitSet(new long[]{0x0000000000000002L
});