projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ctf: Remove the callsite support
[deliverable/tracecompass.git] / ctf / org.eclipse.tracecompass.ctf.parser / target / generated-sources / antlr3 / org / eclipse / tracecompass / ctf / parser / CTFParser.java
CommitLineData
73511e67 1// $ANTLR 3.5.2 org/eclipse/tracecompass/ctf/parser/CTFParser.g 2015-08-06 19:37:54
9ad3c628
AM		 2
3/*******************************************************************************
1c98290b 4 * Copyright (c) 2010, 2015 Ericsson, Ecole Polytechnique de Montréal and others
9ad3c628
AM		 5 *
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
10 *
11 * Contributors:
12 * Matthew Khouzam - Initial API and implementation
13 * Simon Marchi - Initial API and implementation
14 * Etienne Bergeron - Update to Antlr 3.5 syntax
15 *******************************************************************************/
16
17package org.eclipse.tracecompass.ctf.parser;
18
19import java.util.Set;
20import java.util.HashSet;
21
22
23import org.antlr.runtime.*;
24import java.util.Stack;
25import java.util.List;
26import java.util.ArrayList;
27import java.util.Map;
28import java.util.HashMap;
29
30import org.antlr.runtime.tree.*;
31
32
33@SuppressWarnings("all")
34public class CTFParser extends Parser {
35 public static final String[] tokenNames = new String[] {
36 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ALIGNTOK", "ARROW", "ASSIGNMENT",
73511e67
AM		 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",
9ad3c628
AM		 48 "STRING_CONTENT", "STRING_LITERAL", "STRUCTTOK", "TERM", "TRACETOK", "TYPEALIASTOK",
49 "TYPEDEFTOK", "TYPE_ASSIGNMENT", "UNICODE_ESCAPE", "UNSIGNEDTOK", "VARIANTTOK",
73511e67
AM		 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",
59 "VARIANT_TAG"
9ad3c628
AM		 60 };
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;
73511e67
AM		 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;
9ad3c628
AM		 183
184 // delegates
185 public Parser[] getDelegates() {
186 return new Parser[] {};
187 }
188
189 // delegators
190
191 protected static class Symbols_scope {
192 Set<String> types;
193 }
194 protected Stack<Symbols_scope> Symbols_stack = new Stack<Symbols_scope>();
195
196
197 public CTFParser(TokenStream input) {
198 this(input, new RecognizerSharedState());
199 }
200 public CTFParser(TokenStream input, RecognizerSharedState state) {
201 super(input, state);
202 }
203
204 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
205
206 public void setTreeAdaptor(TreeAdaptor adaptor) {
207 this.adaptor = adaptor;
208 }
209 public TreeAdaptor getTreeAdaptor() {
210 return adaptor;
211 }
212 @Override public String[] getTokenNames() { return CTFParser.tokenNames; }
213 @Override public String getGrammarFileName() { return "org/eclipse/tracecompass/ctf/parser/CTFParser.g"; }
214
215
216 public CTFParser(TokenStream input, boolean verbose) {
217 this(input);
218 this.verbose = verbose;
219 }
220
221 /**
222 * This method is overriden to disable automatic error recovery.
223 * On a mismatched token, it simply re-throw an exception.
224 */
225 @Override
226 protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow) throws RecognitionException {
227 throw new MismatchedTokenException(ttype, input);
228 }
229
230 /**
231 * Checks if a given name has been defined has a type.
232 * From: http://www.antlr.org/grammar/1153358328744/C.g
233 *
234 * @param name The name to check.
235 * @return True if is is a type, false otherwise.
236 */
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)) {
241 return true;
242 }
243 }
244 return false;
245 }
246
247 void addTypeName(String name) {
248 Symbols_stack.peek().types.add(name);
249 if (verbose) {
8460a46d 250 debug_print("New type: " + name + " " + declaration_stack);
9ad3c628
AM		 251 }
252 }
253
9ad3c628 254 void typedefOn() {
8460a46d
MK		 255 debug_print("typedefOn" + declaration_stack);
256 declaration_stack.peek().isTypedef =true;
9ad3c628
AM		 257 }
258
259 void typedefOff() {
8460a46d
MK		 260 debug_print("typedefOff" + declaration_stack);
261 declaration_stack.peek().isTypedef =false;
9ad3c628
AM		 262 }
263
264 boolean inTypedef() {
8460a46d 265 return declaration_stack.peek().isTypedef;
9ad3c628
AM		 266 }
267
268 boolean _inTypealiasAlias = false;
269
270 void typealiasAliasOn() {
271 debug_print("typealiasAliasOn");
272 _inTypealiasAlias = true;
273 }
274
275 void typealiasAliasOff() {
276 debug_print("typealiasAliasOff");
277 _inTypealiasAlias = false;
278 }
279
280 boolean inTypealiasAlias() {
281 return _inTypealiasAlias;
282 }
283
284 void debug_print(String str) {
285 if (verbose) {
286 System.out.println(str);
287 }
288 }
289
290 /* Prints rule entry and exit while parsing */
291 boolean verbose = false;
292
293
294 public static class parse_return extends ParserRuleReturnScope {
295 CommonTree tree;
296 @Override
297 public CommonTree getTree() { return tree; }
298 };
299
300
301 // $ANTLR start "parse"
73511e67 302 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:189:1: parse : ( declaration )+ EOF -> ^( ROOT ( declaration )+ ) ;
9ad3c628
AM		 303 public final CTFParser.parse_return parse() throws RecognitionException {
304 Symbols_stack.push(new Symbols_scope());
305
306 CTFParser.parse_return retval = new CTFParser.parse_return();
307 retval.start = input.LT(1);
308
309 CommonTree root_0 = null;
310
311 Token EOF2=null;
312 ParserRuleReturnScope declaration1 =null;
313
314 CommonTree EOF2_tree=null;
315 RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
316 RewriteRuleSubtreeStream stream_declaration=new RewriteRuleSubtreeStream(adaptor,"rule declaration");
317
318
319 Symbols_stack.peek().types = new HashSet<String>();
320
321 try {
73511e67
AM		 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
9ad3c628 324 {
73511e67 325 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:194:5: ( declaration )+
9ad3c628
AM		 326 int cnt1=0;
327 loop1:
328 while (true) {
329 int alt1=2;
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)) ) {
332 alt1=1;
333 }
334 else if ( (LA1_0==IDENTIFIER) && (( inTypealiasAlias() || isTypeName(input.LT(1).getText()) ))) {
335 alt1=1;
336 }
73511e67 337 else if ( (LA1_0==CLOCKTOK||LA1_0==ENVTOK||LA1_0==EVENTTOK||LA1_0==STREAMTOK||(LA1_0 >= TRACETOK && LA1_0 <= TYPEALIASTOK)) ) {
9ad3c628
AM		 338 alt1=1;
339 }
340
341 switch (alt1) {
342 case 1 :
73511e67 343 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:194:5: declaration
9ad3c628 344 {
73511e67 345 pushFollow(FOLLOW_declaration_in_parse442);
9ad3c628
AM		 346 declaration1=declaration();
347 state._fsp--;
348 if (state.failed) return retval;
349 if ( state.backtracking==0 ) stream_declaration.add(declaration1.getTree());
350 }
351 break;
352
353 default :
354 if ( cnt1 >= 1 ) break loop1;
355 if (state.backtracking>0) {state.failed=true; return retval;}
356 EarlyExitException eee = new EarlyExitException(1, input);
357 throw eee;
358 }
359 cnt1++;
360 }
361
73511e67 362 EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_parse445); if (state.failed) return retval;
9ad3c628
AM		 363 if ( state.backtracking==0 ) stream_EOF.add(EOF2);
364
365 // AST REWRITE
366 // elements: declaration
367 // token labels:
368 // rule labels: retval
369 // token list labels:
370 // rule list labels:
371 // wildcard 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);
375
376 root_0 = (CommonTree)adaptor.nil();
73511e67 377 // 194:22: -> ^( ROOT ( declaration )+ )
9ad3c628 378 {
73511e67 379 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:194:25: ^( ROOT ( declaration )+ )
9ad3c628
AM		 380 {
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();
385 }
386 while ( stream_declaration.hasNext() ) {
387 adaptor.addChild(root_1, stream_declaration.nextTree());
388 }
389 stream_declaration.reset();
390
391 adaptor.addChild(root_0, root_1);
392 }
393
394 }
395
396
397 retval.tree = root_0;
398 }
399
400 }
401
402 retval.stop = input.LT(-1);
403
404 if ( state.backtracking==0 ) {
405 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
406 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
407 }
408 }
409
410 catch (RecognitionException e) {
411 throw e;
412 }
413
414 finally {
415 // do for sure before leaving
416 Symbols_stack.pop();
417
418 }
419 return retval;
420 }
421 // $ANTLR end "parse"
422
423
424 public static class numberLiteral_return extends ParserRuleReturnScope {
425 CommonTree tree;
426 @Override
427 public CommonTree getTree() { return tree; }
428 };
429
430
431 // $ANTLR start "numberLiteral"
73511e67 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 )* ) ) ;
9ad3c628
AM		 433 public final CTFParser.numberLiteral_return numberLiteral() throws RecognitionException {
434 CTFParser.numberLiteral_return retval = new CTFParser.numberLiteral_return();
435 retval.start = input.LT(1);
436
437 CommonTree root_0 = null;
438
439 Token SIGN3=null;
440 Token HEX_LITERAL4=null;
441 Token DECIMAL_LITERAL5=null;
442 Token OCTAL_LITERAL6=null;
443
444 CommonTree SIGN3_tree=null;
445 CommonTree HEX_LITERAL4_tree=null;
446 CommonTree DECIMAL_LITERAL5_tree=null;
447 CommonTree OCTAL_LITERAL6_tree=null;
9ad3c628
AM		 448 RewriteRuleTokenStream stream_OCTAL_LITERAL=new RewriteRuleTokenStream(adaptor,"token OCTAL_LITERAL");
449 RewriteRuleTokenStream stream_HEX_LITERAL=new RewriteRuleTokenStream(adaptor,"token HEX_LITERAL");
73511e67 450 RewriteRuleTokenStream stream_SIGN=new RewriteRuleTokenStream(adaptor,"token SIGN");
9ad3c628
AM		 451 RewriteRuleTokenStream stream_DECIMAL_LITERAL=new RewriteRuleTokenStream(adaptor,"token DECIMAL_LITERAL");
452
453 try {
73511e67
AM		 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 )* ) )
9ad3c628 456 {
73511e67 457 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:198:5: ( SIGN )*
9ad3c628
AM		 458 loop2:
459 while (true) {
460 int alt2=2;
461 int LA2_0 = input.LA(1);
462 if ( (LA2_0==SIGN) ) {
463 alt2=1;
464 }
465
466 switch (alt2) {
467 case 1 :
73511e67 468 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:198:5: SIGN
9ad3c628 469 {
73511e67 470 SIGN3=(Token)match(input,SIGN,FOLLOW_SIGN_in_numberLiteral467); if (state.failed) return retval;
9ad3c628
AM		 471 if ( state.backtracking==0 ) stream_SIGN.add(SIGN3);
472
473 }
474 break;
475
476 default :
477 break loop2;
478 }
479 }
480
73511e67 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 )* ) )
9ad3c628
AM		 482 int alt3=3;
483 switch ( input.LA(1) ) {
484 case HEX_LITERAL:
485 {
486 alt3=1;
487 }
488 break;
489 case DECIMAL_LITERAL:
490 {
491 alt3=2;
492 }
493 break;
494 case OCTAL_LITERAL:
495 {
496 alt3=3;
497 }
498 break;
499 default:
500 if (state.backtracking>0) {state.failed=true; return retval;}
501 NoViableAltException nvae =
502 new NoViableAltException("", 3, 0, input);
503 throw nvae;
504 }
505 switch (alt3) {
506 case 1 :
73511e67 507 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:199:9: HEX_LITERAL
9ad3c628 508 {
73511e67 509 HEX_LITERAL4=(Token)match(input,HEX_LITERAL,FOLLOW_HEX_LITERAL_in_numberLiteral478); if (state.failed) return retval;
9ad3c628
AM		 510 if ( state.backtracking==0 ) stream_HEX_LITERAL.add(HEX_LITERAL4);
511
512 // AST REWRITE
1c98290b 513 // elements: SIGN, HEX_LITERAL
9ad3c628
AM		 514 // token labels:
515 // rule labels: retval
516 // token list labels:
517 // rule list labels:
518 // wildcard 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);
522
523 root_0 = (CommonTree)adaptor.nil();
73511e67 524 // 199:21: -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
9ad3c628 525 {
73511e67 526 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:199:24: ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
9ad3c628
AM		 527 {
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());
73511e67 531 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:199:59: ( SIGN )*
9ad3c628
AM		 532 while ( stream_SIGN.hasNext() ) {
533 adaptor.addChild(root_1, stream_SIGN.nextNode());
534 }
535 stream_SIGN.reset();
536
537 adaptor.addChild(root_0, root_1);
538 }
539
540 }
541
542
543 retval.tree = root_0;
544 }
545
546 }
547 break;
548 case 2 :
73511e67 549 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:200:9: DECIMAL_LITERAL
9ad3c628 550 {
73511e67 551 DECIMAL_LITERAL5=(Token)match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_numberLiteral499); if (state.failed) return retval;
9ad3c628
AM		 552 if ( state.backtracking==0 ) stream_DECIMAL_LITERAL.add(DECIMAL_LITERAL5);
553
554 // AST REWRITE
73511e67 555 // elements: SIGN, DECIMAL_LITERAL
9ad3c628
AM		 556 // token labels:
557 // rule labels: retval
558 // token list labels:
559 // rule list labels:
560 // wildcard 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);
564
565 root_0 = (CommonTree)adaptor.nil();
73511e67 566 // 200:25: -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
9ad3c628 567 {
73511e67 568 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:200:28: ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
9ad3c628
AM		 569 {
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());
73511e67 573 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:200:67: ( SIGN )*
9ad3c628
AM		 574 while ( stream_SIGN.hasNext() ) {
575 adaptor.addChild(root_1, stream_SIGN.nextNode());
576 }
577 stream_SIGN.reset();
578
579 adaptor.addChild(root_0, root_1);
580 }
581
582 }
583
584
585 retval.tree = root_0;
586 }
587
588 }
589 break;
590 case 3 :
73511e67 591 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:201:9: OCTAL_LITERAL
9ad3c628 592 {
73511e67 593 OCTAL_LITERAL6=(Token)match(input,OCTAL_LITERAL,FOLLOW_OCTAL_LITERAL_in_numberLiteral520); if (state.failed) return retval;
9ad3c628
AM		 594 if ( state.backtracking==0 ) stream_OCTAL_LITERAL.add(OCTAL_LITERAL6);
595
596 // AST REWRITE
1c98290b 597 // elements: OCTAL_LITERAL, SIGN
9ad3c628
AM		 598 // token labels:
599 // rule labels: retval
600 // token list labels:
601 // rule list labels:
602 // wildcard 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);
606
607 root_0 = (CommonTree)adaptor.nil();
73511e67 608 // 201:23: -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
9ad3c628 609 {
73511e67 610 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:201:26: ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
9ad3c628
AM		 611 {
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());
73511e67 615 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:201:63: ( SIGN )*
9ad3c628
AM		 616 while ( stream_SIGN.hasNext() ) {
617 adaptor.addChild(root_1, stream_SIGN.nextNode());
618 }
619 stream_SIGN.reset();
620
621 adaptor.addChild(root_0, root_1);
622 }
623
624 }
625
626
627 retval.tree = root_0;
628 }
629
630 }
631 break;
632
633 }
634
635 }
636
637 retval.stop = input.LT(-1);
638
639 if ( state.backtracking==0 ) {
640 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
641 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
642 }
643 }
644
645 catch (RecognitionException e) {
646 throw e;
647 }
648
649 finally {
650 // do for sure before leaving
651 }
652 return retval;
653 }
654 // $ANTLR end "numberLiteral"
655
656
657 public static class primaryExpression_return extends ParserRuleReturnScope {
658 CommonTree tree;
659 @Override
660 public CommonTree getTree() { return tree; }
661 };
662
663
664 // $ANTLR start "primaryExpression"
73511e67 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 );
9ad3c628
AM		 666 public final CTFParser.primaryExpression_return primaryExpression() throws RecognitionException {
667 CTFParser.primaryExpression_return retval = new CTFParser.primaryExpression_return();
668 retval.start = input.LT(1);
669
670 CommonTree root_0 = null;
671
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;
678
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");
685
686 try {
73511e67 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 )
9ad3c628
AM		 688 int alt4=6;
689 switch ( input.LA(1) ) {
690 case IDENTIFIER:
691 {
692 int LA4_1 = input.LA(2);
693 if ( (synpred1_CTFParser()) ) {
694 alt4=1;
695 }
696 else if ( (true) ) {
697 alt4=5;
698 }
699
700 }
701 break;
702 case ALIGNTOK:
703 case EVENTTOK:
704 case SIGNEDTOK:
705 case STRINGTOK:
706 {
707 int LA4_2 = input.LA(2);
708 if ( (synpred2_CTFParser()) ) {
709 alt4=2;
710 }
711 else if ( (true) ) {
712 alt4=5;
713 }
714
715 }
716 break;
717 case STRING_LITERAL:
718 {
719 int LA4_3 = input.LA(2);
720 if ( (synpred3_CTFParser()) ) {
721 alt4=3;
722 }
723 else if ( (true) ) {
724 alt4=5;
725 }
726
727 }
728 break;
729 case DECIMAL_LITERAL:
730 case HEX_LITERAL:
731 case OCTAL_LITERAL:
732 case SIGN:
733 {
734 alt4=4;
735 }
736 break;
737 case CHARACTER_LITERAL:
738 {
739 alt4=6;
740 }
741 break;
742 default:
743 if (state.backtracking>0) {state.failed=true; return retval;}
744 NoViableAltException nvae =
745 new NoViableAltException("", 4, 0, input);
746 throw nvae;
747 }
748 switch (alt4) {
749 case 1 :
73511e67 750 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:206:5: ( IDENTIFIER )=> IDENTIFIER
9ad3c628 751 {
73511e67 752 IDENTIFIER7=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primaryExpression558); if (state.failed) return retval;
9ad3c628
AM		 753 if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER7);
754
755 // AST REWRITE
756 // elements: IDENTIFIER
757 // token labels:
758 // rule labels: retval
759 // token list labels:
760 // rule list labels:
761 // wildcard 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);
765
766 root_0 = (CommonTree)adaptor.nil();
73511e67 767 // 207:7: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
9ad3c628 768 {
73511e67 769 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:207:10: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
9ad3c628
AM		 770 {
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);
775 }
776
777 }
778
779
780 retval.tree = root_0;
781 }
782
783 }
784 break;
785 case 2 :
73511e67 786 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:208:5: ( ctfKeyword )=> ctfKeyword
9ad3c628 787 {
73511e67 788 pushFollow(FOLLOW_ctfKeyword_in_primaryExpression584);
9ad3c628
AM		 789 ctfKeyword8=ctfKeyword();
790 state._fsp--;
791 if (state.failed) return retval;
792 if ( state.backtracking==0 ) stream_ctfKeyword.add(ctfKeyword8.getTree());
793 // AST REWRITE
794 // elements: ctfKeyword
795 // token labels:
796 // rule labels: retval
797 // token list labels:
798 // rule list labels:
799 // wildcard 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);
803
804 root_0 = (CommonTree)adaptor.nil();
73511e67 805 // 208:32: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
9ad3c628 806 {
73511e67 807 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:208:35: ^( UNARY_EXPRESSION_STRING ctfKeyword )
9ad3c628
AM		 808 {
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);
813 }
814
815 }
816
817
818 retval.tree = root_0;
819 }
820
821 }
822 break;
823 case 3 :
73511e67 824 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:209:5: ( STRING_LITERAL )=> STRING_LITERAL
9ad3c628 825 {
73511e67 826 STRING_LITERAL9=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_primaryExpression604); if (state.failed) return retval;
9ad3c628
AM		 827 if ( state.backtracking==0 ) stream_STRING_LITERAL.add(STRING_LITERAL9);
828
829 // AST REWRITE
830 // elements: STRING_LITERAL
831 // token labels:
832 // rule labels: retval
833 // token list labels:
834 // rule list labels:
835 // wildcard 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);
839
840 root_0 = (CommonTree)adaptor.nil();
73511e67 841 // 210:7: -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
9ad3c628 842 {
73511e67 843 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:210:10: ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
9ad3c628
AM		 844 {
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);
849 }
850
851 }
852
853
854 retval.tree = root_0;
855 }
856
857 }
858 break;
859 case 4 :
73511e67 860 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:212:5: numberLiteral
9ad3c628
AM		 861 {
862 root_0 = (CommonTree)adaptor.nil();
863
864
73511e67 865 pushFollow(FOLLOW_numberLiteral_in_primaryExpression629);
9ad3c628
AM		 866 numberLiteral10=numberLiteral();
867 state._fsp--;
868 if (state.failed) return retval;
869 if ( state.backtracking==0 ) adaptor.addChild(root_0, numberLiteral10.getTree());
870
871 }
872 break;
873 case 5 :
73511e67 874 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:213:5: enumConstant
9ad3c628
AM		 875 {
876 root_0 = (CommonTree)adaptor.nil();
877
878
73511e67 879 pushFollow(FOLLOW_enumConstant_in_primaryExpression635);
9ad3c628
AM		 880 enumConstant11=enumConstant();
881 state._fsp--;
882 if (state.failed) return retval;
883 if ( state.backtracking==0 ) adaptor.addChild(root_0, enumConstant11.getTree());
884
885 }
886 break;
887 case 6 :
73511e67 888 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:214:5: CHARACTER_LITERAL
9ad3c628
AM		 889 {
890 root_0 = (CommonTree)adaptor.nil();
891
892
73511e67 893 CHARACTER_LITERAL12=(Token)match(input,CHARACTER_LITERAL,FOLLOW_CHARACTER_LITERAL_in_primaryExpression641); if (state.failed) return retval;
9ad3c628
AM		 894 if ( state.backtracking==0 ) {
895 CHARACTER_LITERAL12_tree = (CommonTree)adaptor.create(CHARACTER_LITERAL12);
896 adaptor.addChild(root_0, CHARACTER_LITERAL12_tree);
897 }
898
899 }
900 break;
901
902 }
903 retval.stop = input.LT(-1);
904
905 if ( state.backtracking==0 ) {
906 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
907 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
908 }
909 }
910
911 catch (RecognitionException e) {
912 throw e;
913 }
914
915 finally {
916 // do for sure before leaving
917 }
918 return retval;
919 }
920 // $ANTLR end "primaryExpression"
921
922
923 public static class postfixExpressionSuffix_return extends ParserRuleReturnScope {
924 CommonTree tree;
925 @Override
926 public CommonTree getTree() { return tree; }
927 };
928
929
930 // $ANTLR start "postfixExpressionSuffix"
73511e67 931 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:217:1: postfixExpressionSuffix : ( OPENBRAC unaryExpression CLOSEBRAC !| (ref= DOT |ref= ARROW ) IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) );
9ad3c628
AM		 932 public final CTFParser.postfixExpressionSuffix_return postfixExpressionSuffix() throws RecognitionException {
933 CTFParser.postfixExpressionSuffix_return retval = new CTFParser.postfixExpressionSuffix_return();
934 retval.start = input.LT(1);
935
936 CommonTree root_0 = null;
937
938 Token ref=null;
939 Token OPENBRAC13=null;
940 Token CLOSEBRAC15=null;
941 Token IDENTIFIER16=null;
942 ParserRuleReturnScope unaryExpression14 =null;
943
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");
951
952 try {
73511e67 953 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:218:3: ( OPENBRAC unaryExpression CLOSEBRAC !| (ref= DOT |ref= ARROW ) IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) )
9ad3c628
AM		 954 int alt6=2;
955 int LA6_0 = input.LA(1);
956 if ( (LA6_0==OPENBRAC) ) {
957 alt6=1;
958 }
959 else if ( (LA6_0==ARROW||LA6_0==DOT) ) {
960 alt6=2;
961 }
962
963 else {
964 if (state.backtracking>0) {state.failed=true; return retval;}
965 NoViableAltException nvae =
966 new NoViableAltException("", 6, 0, input);
967 throw nvae;
968 }
969
970 switch (alt6) {
971 case 1 :
73511e67 972 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:218:5: OPENBRAC unaryExpression CLOSEBRAC !
9ad3c628
AM		 973 {
974 root_0 = (CommonTree)adaptor.nil();
975
976
73511e67 977 OPENBRAC13=(Token)match(input,OPENBRAC,FOLLOW_OPENBRAC_in_postfixExpressionSuffix654); if (state.failed) return retval;
9ad3c628
AM		 978 if ( state.backtracking==0 ) {
979 OPENBRAC13_tree = (CommonTree)adaptor.create(OPENBRAC13);
980 adaptor.addChild(root_0, OPENBRAC13_tree);
981 }
982
73511e67 983 pushFollow(FOLLOW_unaryExpression_in_postfixExpressionSuffix656);
9ad3c628
AM		 984 unaryExpression14=unaryExpression();
985 state._fsp--;
986 if (state.failed) return retval;
987 if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression14.getTree());
988
73511e67 989 CLOSEBRAC15=(Token)match(input,CLOSEBRAC,FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix658); if (state.failed) return retval;
9ad3c628
AM		 990 }
991 break;
992 case 2 :
73511e67 993 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:219:5: (ref= DOT |ref= ARROW ) IDENTIFIER
9ad3c628 994 {
73511e67 995 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:219:5: (ref= DOT |ref= ARROW )
9ad3c628
AM		 996 int alt5=2;
997 int LA5_0 = input.LA(1);
998 if ( (LA5_0==DOT) ) {
999 alt5=1;
1000 }
1001 else if ( (LA5_0==ARROW) ) {
1002 alt5=2;
1003 }
1004
1005 else {
1006 if (state.backtracking>0) {state.failed=true; return retval;}
1007 NoViableAltException nvae =
1008 new NoViableAltException("", 5, 0, input);
1009 throw nvae;
1010 }
1011
1012 switch (alt5) {
1013 case 1 :
73511e67 1014 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:219:6: ref= DOT
9ad3c628 1015 {
73511e67 1016 ref=(Token)match(input,DOT,FOLLOW_DOT_in_postfixExpressionSuffix668); if (state.failed) return retval;
9ad3c628
AM		 1017 if ( state.backtracking==0 ) stream_DOT.add(ref);
1018
1019 }
1020 break;
1021 case 2 :
73511e67 1022 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:219:16: ref= ARROW
9ad3c628 1023 {
73511e67 1024 ref=(Token)match(input,ARROW,FOLLOW_ARROW_in_postfixExpressionSuffix674); if (state.failed) return retval;
9ad3c628
AM		 1025 if ( state.backtracking==0 ) stream_ARROW.add(ref);
1026
1027 }
1028 break;
1029
1030 }
1031
73511e67 1032 IDENTIFIER16=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_postfixExpressionSuffix677); if (state.failed) return retval;
9ad3c628
AM		 1033 if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER16);
1034
1035 // AST REWRITE
1c98290b 1036 // elements: IDENTIFIER, ref
9ad3c628
AM		 1037 // token labels: ref
1038 // rule labels: retval
1039 // token list labels:
1040 // rule list labels:
1041 // wildcard 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);
1046
1047 root_0 = (CommonTree)adaptor.nil();
73511e67 1048 // 220:7: -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) )
9ad3c628 1049 {
73511e67 1050 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:220:10: ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) )
9ad3c628
AM		 1051 {
1052 CommonTree root_1 = (CommonTree)adaptor.nil();
1053 root_1 = (CommonTree)adaptor.becomeRoot(stream_ref.nextNode(), root_1);
73511e67 1054 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:220:17: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
9ad3c628
AM		 1055 {
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);
1060 }
1061
1062 adaptor.addChild(root_0, root_1);
1063 }
1064
1065 }
1066
1067
1068 retval.tree = root_0;
1069 }
1070
1071 }
1072 break;
1073
1074 }
1075 retval.stop = input.LT(-1);
1076
1077 if ( state.backtracking==0 ) {
1078 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1079 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1080 }
1081 }
1082
1083 catch (RecognitionException e) {
1084 throw e;
1085 }
1086
1087 finally {
1088 // do for sure before leaving
1089 }
1090 return retval;
1091 }
1092 // $ANTLR end "postfixExpressionSuffix"
1093
1094
7a91a2e4
MK		 1095 public static class postfixCtfExpression_return extends ParserRuleReturnScope {
1096 CommonTree tree;
1097 @Override
1098 public CommonTree getTree() { return tree; }
1099 };
1100
1101
1102 // $ANTLR start "postfixCtfExpression"
73511e67 1103 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:223:1: postfixCtfExpression : (ref= DOT ) ctfSpecifierHead -> ^( $ref ^( UNARY_EXPRESSION_STRING ctfSpecifierHead ) ) ;
7a91a2e4
MK		 1104 public final CTFParser.postfixCtfExpression_return postfixCtfExpression() throws RecognitionException {
1105 CTFParser.postfixCtfExpression_return retval = new CTFParser.postfixCtfExpression_return();
1106 retval.start = input.LT(1);
1107
1108 CommonTree root_0 = null;
1109
1110 Token ref=null;
1111 ParserRuleReturnScope ctfSpecifierHead17 =null;
1112
1113 CommonTree ref_tree=null;
1114 RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
1115 RewriteRuleSubtreeStream stream_ctfSpecifierHead=new RewriteRuleSubtreeStream(adaptor,"rule ctfSpecifierHead");
1116
1117 try {
73511e67
AM		 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
7a91a2e4 1120 {
73511e67
AM		 1121 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:224:5: (ref= DOT )
1122 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:224:6: ref= DOT
7a91a2e4 1123 {
73511e67 1124 ref=(Token)match(input,DOT,FOLLOW_DOT_in_postfixCtfExpression712); if (state.failed) return retval;
7a91a2e4
MK		 1125 if ( state.backtracking==0 ) stream_DOT.add(ref);
1126
1127 }
1128
73511e67 1129 pushFollow(FOLLOW_ctfSpecifierHead_in_postfixCtfExpression715);
7a91a2e4
MK		 1130 ctfSpecifierHead17=ctfSpecifierHead();
1131 state._fsp--;
1132 if (state.failed) return retval;
1133 if ( state.backtracking==0 ) stream_ctfSpecifierHead.add(ctfSpecifierHead17.getTree());
1134 // AST REWRITE
1c98290b 1135 // elements: ref, ctfSpecifierHead
7a91a2e4
MK		 1136 // token labels: ref
1137 // rule labels: retval
1138 // token list labels:
1139 // rule list labels:
1140 // wildcard 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);
1145
1146 root_0 = (CommonTree)adaptor.nil();
73511e67 1147 // 225:7: -> ^( $ref ^( UNARY_EXPRESSION_STRING ctfSpecifierHead ) )
7a91a2e4 1148 {
73511e67 1149 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:225:10: ^( $ref ^( UNARY_EXPRESSION_STRING ctfSpecifierHead ) )
7a91a2e4
MK		 1150 {
1151 CommonTree root_1 = (CommonTree)adaptor.nil();
1152 root_1 = (CommonTree)adaptor.becomeRoot(stream_ref.nextNode(), root_1);
73511e67 1153 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:225:17: ^( UNARY_EXPRESSION_STRING ctfSpecifierHead )
7a91a2e4
MK		 1154 {
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);
1159 }
1160
1161 adaptor.addChild(root_0, root_1);
1162 }
1163
1164 }
1165
1166
1167 retval.tree = root_0;
1168 }
1169
1170 }
1171
1172 retval.stop = input.LT(-1);
1173
1174 if ( state.backtracking==0 ) {
1175 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1176 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1177 }
1178 }
1179
1180 catch (RecognitionException e) {
1181 throw e;
1182 }
1183
1184 finally {
1185 // do for sure before leaving
1186 }
1187 return retval;
1188 }
1189 // $ANTLR end "postfixCtfExpression"
1190
1191
9ad3c628
AM		 1192 public static class postfixExpression_return extends ParserRuleReturnScope {
1193 CommonTree tree;
1194 @Override
1195 public CommonTree getTree() { return tree; }
1196 };
1197
1198
1199 // $ANTLR start "postfixExpression"
73511e67 1200 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:228:1: postfixExpression : ( ( primaryExpression ( postfixExpressionSuffix )* ) | ( ctfSpecifierHead ( postfixCtfExpression )* ( postfixExpressionSuffix )+ ) );
9ad3c628
AM		 1201 public final CTFParser.postfixExpression_return postfixExpression() throws RecognitionException {
1202 CTFParser.postfixExpression_return retval = new CTFParser.postfixExpression_return();
1203 retval.start = input.LT(1);
1204
1205 CommonTree root_0 = null;
1206
7a91a2e4
MK		 1207 ParserRuleReturnScope primaryExpression18 =null;
1208 ParserRuleReturnScope postfixExpressionSuffix19 =null;
1209 ParserRuleReturnScope ctfSpecifierHead20 =null;
1210 ParserRuleReturnScope postfixCtfExpression21 =null;
1211 ParserRuleReturnScope postfixExpressionSuffix22 =null;
9ad3c628
AM		 1212
1213
1214 try {
73511e67 1215 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:3: ( ( primaryExpression ( postfixExpressionSuffix )* ) | ( ctfSpecifierHead ( postfixCtfExpression )* ( postfixExpressionSuffix )+ ) )
7a91a2e4 1216 int alt10=2;
9ad3c628
AM		 1217 switch ( input.LA(1) ) {
1218 case ALIGNTOK:
1219 case CHARACTER_LITERAL:
1220 case DECIMAL_LITERAL:
1221 case HEX_LITERAL:
1222 case IDENTIFIER:
1223 case OCTAL_LITERAL:
1224 case SIGN:
1225 case SIGNEDTOK:
1226 case STRINGTOK:
1227 case STRING_LITERAL:
1228 {
7a91a2e4 1229 alt10=1;
9ad3c628
AM		 1230 }
1231 break;
1232 case EVENTTOK:
1233 {
7a91a2e4 1234 alt10=1;
9ad3c628
AM		 1235 }
1236 break;
9ad3c628
AM		 1237 case CLOCKTOK:
1238 case ENVTOK:
1239 case STREAMTOK:
1240 case TRACETOK:
1241 {
7a91a2e4 1242 alt10=2;
9ad3c628
AM		 1243 }
1244 break;
1245 default:
1246 if (state.backtracking>0) {state.failed=true; return retval;}
1247 NoViableAltException nvae =
7a91a2e4 1248 new NoViableAltException("", 10, 0, input);
9ad3c628
AM		 1249 throw nvae;
1250 }
7a91a2e4 1251 switch (alt10) {
9ad3c628 1252 case 1 :
73511e67 1253 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:5: ( primaryExpression ( postfixExpressionSuffix )* )
9ad3c628
AM		 1254 {
1255 root_0 = (CommonTree)adaptor.nil();
1256
1257
73511e67
AM		 1258 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:5: ( primaryExpression ( postfixExpressionSuffix )* )
1259 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:6: primaryExpression ( postfixExpressionSuffix )*
7a91a2e4 1260 {
73511e67 1261 pushFollow(FOLLOW_primaryExpression_in_postfixExpression748);
7a91a2e4 1262 primaryExpression18=primaryExpression();
9ad3c628
AM		 1263 state._fsp--;
1264 if (state.failed) return retval;
7a91a2e4 1265 if ( state.backtracking==0 ) adaptor.addChild(root_0, primaryExpression18.getTree());
9ad3c628 1266
73511e67 1267 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:24: ( postfixExpressionSuffix )*
9ad3c628
AM		 1268 loop7:
1269 while (true) {
1270 int alt7=2;
1271 int LA7_0 = input.LA(1);
1272 if ( (LA7_0==ARROW||LA7_0==DOT||LA7_0==OPENBRAC) ) {
1273 alt7=1;
1274 }
1275
1276 switch (alt7) {
1277 case 1 :
73511e67 1278 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:229:24: postfixExpressionSuffix
9ad3c628 1279 {
73511e67 1280 pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression750);
7a91a2e4 1281 postfixExpressionSuffix19=postfixExpressionSuffix();
9ad3c628
AM		 1282 state._fsp--;
1283 if (state.failed) return retval;
7a91a2e4 1284 if ( state.backtracking==0 ) adaptor.addChild(root_0, postfixExpressionSuffix19.getTree());
9ad3c628
AM		 1285
1286 }
1287 break;
1288
1289 default :
1290 break loop7;
1291 }
1292 }
1293
7a91a2e4
MK		 1294 }
1295
9ad3c628
AM		 1296 }
1297 break;
1298 case 2 :
73511e67 1299 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:5: ( ctfSpecifierHead ( postfixCtfExpression )* ( postfixExpressionSuffix )+ )
9ad3c628
AM		 1300 {
1301 root_0 = (CommonTree)adaptor.nil();
1302
1303
73511e67
AM		 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 )+
7a91a2e4 1306 {
73511e67 1307 pushFollow(FOLLOW_ctfSpecifierHead_in_postfixExpression759);
7a91a2e4 1308 ctfSpecifierHead20=ctfSpecifierHead();
9ad3c628
AM		 1309 state._fsp--;
1310 if (state.failed) return retval;
7a91a2e4 1311 if ( state.backtracking==0 ) adaptor.addChild(root_0, ctfSpecifierHead20.getTree());
9ad3c628 1312
73511e67 1313 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:23: ( postfixCtfExpression )*
9ad3c628
AM		 1314 loop8:
1315 while (true) {
1316 int alt8=2;
1317 int LA8_0 = input.LA(1);
7a91a2e4
MK		 1318 if ( (LA8_0==DOT) ) {
1319 int LA8_2 = input.LA(2);
73511e67 1320 if ( (LA8_2==CLOCKTOK||LA8_2==ENVTOK||LA8_2==EVENTTOK||LA8_2==STREAMTOK||LA8_2==TRACETOK) ) {
7a91a2e4
MK		 1321 alt8=1;
1322 }
1323
9ad3c628
AM		 1324 }
1325
1326 switch (alt8) {
1327 case 1 :
73511e67 1328 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:23: postfixCtfExpression
7a91a2e4 1329 {
73511e67 1330 pushFollow(FOLLOW_postfixCtfExpression_in_postfixExpression761);
7a91a2e4
MK		 1331 postfixCtfExpression21=postfixCtfExpression();
1332 state._fsp--;
1333 if (state.failed) return retval;
1334 if ( state.backtracking==0 ) adaptor.addChild(root_0, postfixCtfExpression21.getTree());
1335
1336 }
1337 break;
1338
1339 default :
1340 break loop8;
1341 }
1342 }
1343
73511e67 1344 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:45: ( postfixExpressionSuffix )+
7a91a2e4
MK		 1345 int cnt9=0;
1346 loop9:
1347 while (true) {
1348 int alt9=2;
1349 int LA9_0 = input.LA(1);
1350 if ( (LA9_0==ARROW||LA9_0==DOT||LA9_0==OPENBRAC) ) {
1351 alt9=1;
1352 }
1353
1354 switch (alt9) {
1355 case 1 :
73511e67 1356 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:230:45: postfixExpressionSuffix
9ad3c628 1357 {
73511e67 1358 pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression764);
7a91a2e4 1359 postfixExpressionSuffix22=postfixExpressionSuffix();
9ad3c628
AM		 1360 state._fsp--;
1361 if (state.failed) return retval;
7a91a2e4 1362 if ( state.backtracking==0 ) adaptor.addChild(root_0, postfixExpressionSuffix22.getTree());
9ad3c628
AM		 1363
1364 }
1365 break;
1366
1367 default :
7a91a2e4 1368 if ( cnt9 >= 1 ) break loop9;
9ad3c628 1369 if (state.backtracking>0) {state.failed=true; return retval;}
7a91a2e4 1370 EarlyExitException eee = new EarlyExitException(9, input);
9ad3c628
AM		 1371 throw eee;
1372 }
7a91a2e4
MK		 1373 cnt9++;
1374 }
1375
9ad3c628
AM		 1376 }
1377
1378 }
1379 break;
1380
1381 }
1382 retval.stop = input.LT(-1);
1383
1384 if ( state.backtracking==0 ) {
1385 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1386 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1387 }
1388 }
1389
1390 catch (RecognitionException e) {
1391 throw e;
1392 }
1393
1394 finally {
1395 // do for sure before leaving
1396 }
1397 return retval;
1398 }
1399 // $ANTLR end "postfixExpression"
1400
1401
1402 public static class unaryExpression_return extends ParserRuleReturnScope {
1403 CommonTree tree;
1404 @Override
1405 public CommonTree getTree() { return tree; }
1406 };
1407
1408
1409 // $ANTLR start "unaryExpression"
73511e67 1410 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:233:1: unaryExpression : postfixExpression ;
9ad3c628
AM		 1411 public final CTFParser.unaryExpression_return unaryExpression() throws RecognitionException {
1412 CTFParser.unaryExpression_return retval = new CTFParser.unaryExpression_return();
1413 retval.start = input.LT(1);
1414
1415 CommonTree root_0 = null;
1416
7a91a2e4 1417 ParserRuleReturnScope postfixExpression23 =null;
9ad3c628
AM		 1418
1419
1420 try {
73511e67
AM		 1421 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:234:3: ( postfixExpression )
1422 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:234:5: postfixExpression
9ad3c628
AM		 1423 {
1424 root_0 = (CommonTree)adaptor.nil();
1425
1426
73511e67 1427 pushFollow(FOLLOW_postfixExpression_in_unaryExpression780);
7a91a2e4 1428 postfixExpression23=postfixExpression();
9ad3c628
AM		 1429 state._fsp--;
1430 if (state.failed) return retval;
7a91a2e4 1431 if ( state.backtracking==0 ) adaptor.addChild(root_0, postfixExpression23.getTree());
9ad3c628
AM		 1432
1433 }
1434
1435 retval.stop = input.LT(-1);
1436
1437 if ( state.backtracking==0 ) {
1438 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1439 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1440 }
1441 }
1442
1443 catch (RecognitionException e) {
1444 throw e;
1445 }
1446
1447 finally {
1448 // do for sure before leaving
1449 }
1450 return retval;
1451 }
1452 // $ANTLR end "unaryExpression"
1453
1454
1455 public static class enumConstant_return extends ParserRuleReturnScope {
1456 CommonTree tree;
1457 @Override
1458 public CommonTree getTree() { return tree; }
1459 };
1460
1461
1462 // $ANTLR start "enumConstant"
73511e67 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 ) );
9ad3c628
AM		 1464 public final CTFParser.enumConstant_return enumConstant() throws RecognitionException {
1465 CTFParser.enumConstant_return retval = new CTFParser.enumConstant_return();
1466 retval.start = input.LT(1);
1467
1468 CommonTree root_0 = null;
1469
7a91a2e4
MK		 1470 Token STRING_LITERAL24=null;
1471 Token IDENTIFIER25=null;
1472 ParserRuleReturnScope ctfKeyword26 =null;
9ad3c628 1473
7a91a2e4
MK		 1474 CommonTree STRING_LITERAL24_tree=null;
1475 CommonTree IDENTIFIER25_tree=null;
9ad3c628
AM		 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");
1479
1480 try {
73511e67 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 ) )
7a91a2e4 1482 int alt11=3;
9ad3c628
AM		 1483 switch ( input.LA(1) ) {
1484 case STRING_LITERAL:
1485 {
7a91a2e4 1486 alt11=1;
9ad3c628
AM		 1487 }
1488 break;
1489 case IDENTIFIER:
1490 {
7a91a2e4 1491 alt11=2;
9ad3c628
AM		 1492 }
1493 break;
1494 case ALIGNTOK:
1495 case EVENTTOK:
1496 case SIGNEDTOK:
1497 case STRINGTOK:
1498 {
7a91a2e4 1499 alt11=3;
9ad3c628
AM		 1500 }
1501 break;
1502 default:
1503 if (state.backtracking>0) {state.failed=true; return retval;}
1504 NoViableAltException nvae =
7a91a2e4 1505 new NoViableAltException("", 11, 0, input);
9ad3c628
AM		 1506 throw nvae;
1507 }
7a91a2e4 1508 switch (alt11) {
9ad3c628 1509 case 1 :
73511e67 1510 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:239:5: STRING_LITERAL
9ad3c628 1511 {
73511e67 1512 STRING_LITERAL24=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_enumConstant797); if (state.failed) return retval;
7a91a2e4 1513 if ( state.backtracking==0 ) stream_STRING_LITERAL.add(STRING_LITERAL24);
9ad3c628
AM		 1514
1515 // AST REWRITE
1516 // elements: STRING_LITERAL
1517 // token labels:
1518 // rule labels: retval
1519 // token list labels:
1520 // rule list labels:
1521 // wildcard 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);
1525
1526 root_0 = (CommonTree)adaptor.nil();
73511e67 1527 // 239:20: -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
9ad3c628 1528 {
73511e67 1529 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:239:23: ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
9ad3c628
AM		 1530 {
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);
1535 }
1536
1537 }
1538
1539
1540 retval.tree = root_0;
1541 }
1542
1543 }
1544 break;
1545 case 2 :
73511e67 1546 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:240:5: IDENTIFIER
9ad3c628 1547 {
73511e67 1548 IDENTIFIER25=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumConstant811); if (state.failed) return retval;
7a91a2e4 1549 if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER25);
9ad3c628
AM		 1550
1551 // AST REWRITE
1552 // elements: IDENTIFIER
1553 // token labels:
1554 // rule labels: retval
1555 // token list labels:
1556 // rule list labels:
1557 // wildcard 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);
1561
1562 root_0 = (CommonTree)adaptor.nil();
73511e67 1563 // 240:16: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
9ad3c628 1564 {
73511e67 1565 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:240:19: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
9ad3c628
AM		 1566 {
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);
1571 }
1572
1573 }
1574
1575
1576 retval.tree = root_0;
1577 }
1578
1579 }
1580 break;
1581 case 3 :
73511e67 1582 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:241:5: ctfKeyword
9ad3c628 1583 {
73511e67 1584 pushFollow(FOLLOW_ctfKeyword_in_enumConstant825);
7a91a2e4 1585 ctfKeyword26=ctfKeyword();
9ad3c628
AM		 1586 state._fsp--;
1587 if (state.failed) return retval;
7a91a2e4 1588 if ( state.backtracking==0 ) stream_ctfKeyword.add(ctfKeyword26.getTree());
9ad3c628
AM		 1589 // AST REWRITE
1590 // elements: ctfKeyword
1591 // token labels:
1592 // rule labels: retval
1593 // token list labels:
1594 // rule list labels:
1595 // wildcard 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);
1599
1600 root_0 = (CommonTree)adaptor.nil();
73511e67 1601 // 241:16: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
9ad3c628 1602 {
73511e67 1603 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:241:19: ^( UNARY_EXPRESSION_STRING ctfKeyword )
9ad3c628
AM		 1604 {
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);
1609 }
1610
1611 }
1612
1613
1614 retval.tree = root_0;
1615 }
1616
1617 }
1618 break;
1619
1620 }
1621 retval.stop = input.LT(-1);
1622
1623 if ( state.backtracking==0 ) {
1624 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1625 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1626 }
1627 }
1628
1629 catch (RecognitionException e) {
1630 throw e;
1631 }
1632
1633 finally {
1634 // do for sure before leaving
1635 }
1636 return retval;
1637 }
1638 // $ANTLR end "enumConstant"
1639
1640
8460a46d
MK		 1641 protected static class declaration_scope {
1642 boolean isTypedef;
1643 }
1644 protected Stack<declaration_scope> declaration_stack = new Stack<declaration_scope>();
1645
9ad3c628
AM		 1646 public static class declaration_return extends ParserRuleReturnScope {
1647 CommonTree tree;
1648 @Override
1649 public CommonTree getTree() { return tree; }
1650 };
1651
1652
1653 // $ANTLR start "declaration"
73511e67 1654 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:246:1: declaration : ( declarationSpecifiers ( declaratorList )? TERM -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) ) -> ^( DECLARATION declarationSpecifiers ( declaratorList )? ) | ctfSpecifier TERM !);
9ad3c628 1655 public final CTFParser.declaration_return declaration() throws RecognitionException {
8460a46d 1656 declaration_stack.push(new declaration_scope());
9ad3c628
AM		 1657 CTFParser.declaration_return retval = new CTFParser.declaration_return();
1658 retval.start = input.LT(1);
1659
1660 CommonTree root_0 = null;
1661
9ad3c628 1662 Token TERM29=null;
7a91a2e4
MK		 1663 Token TERM31=null;
1664 ParserRuleReturnScope declarationSpecifiers27 =null;
1665 ParserRuleReturnScope declaratorList28 =null;
1666 ParserRuleReturnScope ctfSpecifier30 =null;
9ad3c628 1667
9ad3c628 1668 CommonTree TERM29_tree=null;
7a91a2e4 1669 CommonTree TERM31_tree=null;
9ad3c628
AM		 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");
1673
8460a46d
MK		 1674
1675 typedefOff();
1676
9ad3c628 1677 try {
73511e67 1678 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:253:3: ( declarationSpecifiers ( declaratorList )? TERM -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) ) -> ^( DECLARATION declarationSpecifiers ( declaratorList )? ) | ctfSpecifier TERM !)
7a91a2e4
MK		 1679 int alt13=2;
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)) ) {
1682 alt13=1;
9ad3c628 1683 }
7a91a2e4
MK		 1684 else if ( (LA13_0==IDENTIFIER) && (( inTypealiasAlias() || isTypeName(input.LT(1).getText()) ))) {
1685 alt13=1;
9ad3c628 1686 }
73511e67 1687 else if ( (LA13_0==CLOCKTOK||LA13_0==ENVTOK||LA13_0==EVENTTOK||LA13_0==STREAMTOK||(LA13_0 >= TRACETOK && LA13_0 <= TYPEALIASTOK)) ) {
7a91a2e4 1688 alt13=2;
9ad3c628
AM		 1689 }
1690
1691 else {
1692 if (state.backtracking>0) {state.failed=true; return retval;}
1693 NoViableAltException nvae =
7a91a2e4 1694 new NoViableAltException("", 13, 0, input);
9ad3c628
AM		 1695 throw nvae;
1696 }
1697
7a91a2e4 1698 switch (alt13) {
9ad3c628 1699 case 1 :
73511e67 1700 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:253:5: declarationSpecifiers ( declaratorList )? TERM
9ad3c628 1701 {
73511e67 1702 pushFollow(FOLLOW_declarationSpecifiers_in_declaration856);
7a91a2e4 1703 declarationSpecifiers27=declarationSpecifiers();
9ad3c628
AM		 1704 state._fsp--;
1705 if (state.failed) return retval;
7a91a2e4 1706 if ( state.backtracking==0 ) stream_declarationSpecifiers.add(declarationSpecifiers27.getTree());
73511e67 1707 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:253:27: ( declaratorList )?
7a91a2e4
MK		 1708 int alt12=2;
1709 int LA12_0 = input.LA(1);
1710 if ( (LA12_0==IDENTIFIER||LA12_0==POINTER) ) {
1711 alt12=1;
1712 }
1713 switch (alt12) {
9ad3c628 1714 case 1 :
73511e67 1715 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:253:27: declaratorList
9ad3c628 1716 {
73511e67 1717 pushFollow(FOLLOW_declaratorList_in_declaration858);
7a91a2e4 1718 declaratorList28=declaratorList();
9ad3c628
AM		 1719 state._fsp--;
1720 if (state.failed) return retval;
7a91a2e4 1721 if ( state.backtracking==0 ) stream_declaratorList.add(declaratorList28.getTree());
9ad3c628
AM		 1722 }
1723 break;
1724
1725 }
1726
73511e67 1727 TERM29=(Token)match(input,TERM,FOLLOW_TERM_in_declaration861); if (state.failed) return retval;
7a91a2e4 1728 if ( state.backtracking==0 ) stream_TERM.add(TERM29);
9ad3c628
AM		 1729
1730 // AST REWRITE
1c98290b 1731 // elements: declarationSpecifiers, declaratorList, declarationSpecifiers, declaratorList
9ad3c628
AM		 1732 // token labels:
1733 // rule labels: retval
1734 // token list labels:
1735 // rule list labels:
1736 // wildcard 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);
1740
1741 root_0 = (CommonTree)adaptor.nil();
73511e67 1742 // 256:7: -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) )
9ad3c628 1743 if (inTypedef()) {
73511e67 1744 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:257:10: ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) )
9ad3c628
AM		 1745 {
1746 CommonTree root_1 = (CommonTree)adaptor.nil();
1747 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DECLARATION, "DECLARATION"), root_1);
73511e67 1748 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:257:24: ^( TYPEDEF declaratorList declarationSpecifiers )
9ad3c628
AM		 1749 {
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);
1755 }
1756
1757 adaptor.addChild(root_0, root_1);
1758 }
1759
1760 }
1761
73511e67 1762 else // 258:7: -> ^( DECLARATION declarationSpecifiers ( declaratorList )? )
9ad3c628 1763 {
73511e67 1764 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:258:10: ^( DECLARATION declarationSpecifiers ( declaratorList )? )
9ad3c628
AM		 1765 {
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());
73511e67 1769 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:258:46: ( declaratorList )?
9ad3c628
AM		 1770 if ( stream_declaratorList.hasNext() ) {
1771 adaptor.addChild(root_1, stream_declaratorList.nextTree());
1772 }
1773 stream_declaratorList.reset();
1774
1775 adaptor.addChild(root_0, root_1);
1776 }
1777
1778 }
1779
1780
1781 retval.tree = root_0;
1782 }
1783
1784 }
1785 break;
1786 case 2 :
73511e67 1787 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:259:5: ctfSpecifier TERM !
9ad3c628
AM		 1788 {
1789 root_0 = (CommonTree)adaptor.nil();
1790
1791
73511e67 1792 pushFollow(FOLLOW_ctfSpecifier_in_declaration929);
7a91a2e4 1793 ctfSpecifier30=ctfSpecifier();
9ad3c628
AM		 1794 state._fsp--;
1795 if (state.failed) return retval;
7a91a2e4 1796 if ( state.backtracking==0 ) adaptor.addChild(root_0, ctfSpecifier30.getTree());
9ad3c628 1797
73511e67 1798 TERM31=(Token)match(input,TERM,FOLLOW_TERM_in_declaration931); if (state.failed) return retval;
9ad3c628
AM		 1799 }
1800 break;
1801
1802 }
1803 retval.stop = input.LT(-1);
1804
1805 if ( state.backtracking==0 ) {
1806 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1807 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1808 }
9ad3c628
AM		 1809 }
1810
1811 catch (RecognitionException e) {
1812 throw e;
1813 }
1814
1815 finally {
1816 // do for sure before leaving
8460a46d 1817 declaration_stack.pop();
9ad3c628
AM		 1818 }
1819 return retval;
1820 }
1821 // $ANTLR end "declaration"
1822
1823
1824 public static class declarationSpecifiers_return extends ParserRuleReturnScope {
1825 CommonTree tree;
1826 @Override
1827 public CommonTree getTree() { return tree; }
1828 };
1829
1830
1831 // $ANTLR start "declarationSpecifiers"
73511e67 1832 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:262:1: declarationSpecifiers : ( storageClassSpecifier | typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
9ad3c628
AM		 1833 public final CTFParser.declarationSpecifiers_return declarationSpecifiers() throws RecognitionException {
1834 CTFParser.declarationSpecifiers_return retval = new CTFParser.declarationSpecifiers_return();
1835 retval.start = input.LT(1);
1836
1837 CommonTree root_0 = null;
1838
7a91a2e4
MK		 1839 ParserRuleReturnScope storageClassSpecifier32 =null;
1840 ParserRuleReturnScope typeQualifier33 =null;
1841 ParserRuleReturnScope typeSpecifier34 =null;
9ad3c628
AM		 1842
1843 RewriteRuleSubtreeStream stream_typeSpecifier=new RewriteRuleSubtreeStream(adaptor,"rule typeSpecifier");
9ad3c628 1844 RewriteRuleSubtreeStream stream_storageClassSpecifier=new RewriteRuleSubtreeStream(adaptor,"rule storageClassSpecifier");
73511e67 1845 RewriteRuleSubtreeStream stream_typeQualifier=new RewriteRuleSubtreeStream(adaptor,"rule typeQualifier");
9ad3c628
AM		 1846
1847 try {
73511e67
AM		 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 )+
9ad3c628 1850 {
73511e67 1851 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:263:5: ( storageClassSpecifier | typeQualifier | typeSpecifier )+
7a91a2e4
MK		 1852 int cnt14=0;
1853 loop14:
9ad3c628 1854 while (true) {
7a91a2e4 1855 int alt14=4;
9ad3c628
AM		 1856 switch ( input.LA(1) ) {
1857 case IDENTIFIER:
1858 {
7a91a2e4 1859 int LA14_2 = input.LA(2);
9ad3c628 1860 if ( ((( inTypealiasAlias() || isTypeName(input.LT(1).getText()) )&&(inTypealiasAlias() || isTypeName(input.LT(1).getText())))) ) {
7a91a2e4 1861 alt14=3;
9ad3c628
AM		 1862 }
1863
1864 }
1865 break;
1866 case TYPEDEFTOK:
1867 {
7a91a2e4 1868 alt14=1;
9ad3c628
AM		 1869 }
1870 break;
1871 case CONSTTOK:
1872 {
7a91a2e4 1873 alt14=2;
9ad3c628
AM		 1874 }
1875 break;
1876 case BOOLTOK:
1877 case CHARTOK:
1878 case COMPLEXTOK:
1879 case DOUBLETOK:
1880 case ENUMTOK:
1881 case FLOATINGPOINTTOK:
1882 case FLOATTOK:
1883 case IMAGINARYTOK:
1884 case INTEGERTOK:
1885 case INTTOK:
1886 case LONGTOK:
1887 case SHORTTOK:
1888 case SIGNEDTOK:
1889 case STRINGTOK:
1890 case STRUCTTOK:
1891 case UNSIGNEDTOK:
1892 case VARIANTTOK:
1893 case VOIDTOK:
1894 {
7a91a2e4 1895 alt14=3;
9ad3c628
AM		 1896 }
1897 break;
1898 }
7a91a2e4 1899 switch (alt14) {
9ad3c628 1900 case 1 :
73511e67 1901 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:266:9: storageClassSpecifier
9ad3c628 1902 {
73511e67 1903 pushFollow(FOLLOW_storageClassSpecifier_in_declarationSpecifiers969);
7a91a2e4 1904 storageClassSpecifier32=storageClassSpecifier();
9ad3c628
AM		 1905 state._fsp--;
1906 if (state.failed) return retval;
7a91a2e4 1907 if ( state.backtracking==0 ) stream_storageClassSpecifier.add(storageClassSpecifier32.getTree());
9ad3c628
AM		 1908 }
1909 break;
1910 case 2 :
73511e67 1911 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:267:9: typeQualifier
9ad3c628 1912 {
73511e67 1913 pushFollow(FOLLOW_typeQualifier_in_declarationSpecifiers979);
7a91a2e4 1914 typeQualifier33=typeQualifier();
9ad3c628
AM		 1915 state._fsp--;
1916 if (state.failed) return retval;
7a91a2e4 1917 if ( state.backtracking==0 ) stream_typeQualifier.add(typeQualifier33.getTree());
9ad3c628
AM		 1918 }
1919 break;
1920 case 3 :
73511e67 1921 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:268:9: typeSpecifier
9ad3c628 1922 {
73511e67 1923 pushFollow(FOLLOW_typeSpecifier_in_declarationSpecifiers989);
7a91a2e4 1924 typeSpecifier34=typeSpecifier();
9ad3c628
AM		 1925 state._fsp--;
1926 if (state.failed) return retval;
7a91a2e4 1927 if ( state.backtracking==0 ) stream_typeSpecifier.add(typeSpecifier34.getTree());
9ad3c628
AM		 1928 }
1929 break;
1930
1931 default :
7a91a2e4 1932 if ( cnt14 >= 1 ) break loop14;
9ad3c628 1933 if (state.backtracking>0) {state.failed=true; return retval;}
7a91a2e4 1934 EarlyExitException eee = new EarlyExitException(14, input);
9ad3c628
AM		 1935 throw eee;
1936 }
7a91a2e4 1937 cnt14++;
9ad3c628
AM		 1938 }
1939
1940 // AST REWRITE
1c98290b 1941 // elements: typeQualifier, typeSpecifier
9ad3c628
AM		 1942 // token labels:
1943 // rule labels: retval
1944 // token list labels:
1945 // rule list labels:
1946 // wildcard 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);
1950
1951 root_0 = (CommonTree)adaptor.nil();
73511e67 1952 // 269:6: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
9ad3c628 1953 {
73511e67 1954 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:269:9: ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
9ad3c628
AM		 1955 {
1956 CommonTree root_1 = (CommonTree)adaptor.nil();
1957 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_SPECIFIER_LIST, "TYPE_SPECIFIER_LIST"), root_1);
73511e67 1958 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:269:31: ( typeQualifier )*
9ad3c628
AM		 1959 while ( stream_typeQualifier.hasNext() ) {
1960 adaptor.addChild(root_1, stream_typeQualifier.nextTree());
1961 }
1962 stream_typeQualifier.reset();
1963
73511e67 1964 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:269:46: ( typeSpecifier )*
9ad3c628
AM		 1965 while ( stream_typeSpecifier.hasNext() ) {
1966 adaptor.addChild(root_1, stream_typeSpecifier.nextTree());
1967 }
1968 stream_typeSpecifier.reset();
1969
1970 adaptor.addChild(root_0, root_1);
1971 }
1972
1973 }
1974
1975
1976 retval.tree = root_0;
1977 }
1978
1979 }
1980
1981 retval.stop = input.LT(-1);
1982
1983 if ( state.backtracking==0 ) {
1984 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1985 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
1986 }
1987 }
1988
1989 catch (RecognitionException e) {
1990 throw e;
1991 }
1992
1993 finally {
1994 // do for sure before leaving
1995 }
1996 return retval;
1997 }
1998 // $ANTLR end "declarationSpecifiers"
1999
2000
2001 public static class declaratorList_return extends ParserRuleReturnScope {
2002 CommonTree tree;
2003 @Override
2004 public CommonTree getTree() { return tree; }
2005 };
2006
2007
2008 // $ANTLR start "declaratorList"
73511e67 2009 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:272:1: declaratorList : declarator ( SEPARATOR declarator )* -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) ;
9ad3c628
AM		 2010 public final CTFParser.declaratorList_return declaratorList() throws RecognitionException {
2011 CTFParser.declaratorList_return retval = new CTFParser.declaratorList_return();
2012 retval.start = input.LT(1);
2013
2014 CommonTree root_0 = null;
2015
7a91a2e4 2016 Token SEPARATOR36=null;
9ad3c628 2017 ParserRuleReturnScope declarator35 =null;
7a91a2e4 2018 ParserRuleReturnScope declarator37 =null;
9ad3c628 2019
7a91a2e4 2020 CommonTree SEPARATOR36_tree=null;
9ad3c628
AM		 2021 RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
2022 RewriteRuleSubtreeStream stream_declarator=new RewriteRuleSubtreeStream(adaptor,"rule declarator");
2023
2024 try {
73511e67
AM		 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 )*
9ad3c628 2027 {
73511e67 2028 pushFollow(FOLLOW_declarator_in_declaratorList1019);
7a91a2e4 2029 declarator35=declarator();
9ad3c628
AM		 2030 state._fsp--;
2031 if (state.failed) return retval;
7a91a2e4 2032 if ( state.backtracking==0 ) stream_declarator.add(declarator35.getTree());
73511e67 2033 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:273:16: ( SEPARATOR declarator )*
7a91a2e4 2034 loop15:
9ad3c628 2035 while (true) {
7a91a2e4
MK		 2036 int alt15=2;
2037 int LA15_0 = input.LA(1);
2038 if ( (LA15_0==SEPARATOR) ) {
2039 alt15=1;
9ad3c628
AM		 2040 }
2041
7a91a2e4 2042 switch (alt15) {
9ad3c628 2043 case 1 :
73511e67 2044 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:273:17: SEPARATOR declarator
9ad3c628 2045 {
73511e67 2046 SEPARATOR36=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_declaratorList1022); if (state.failed) return retval;
7a91a2e4 2047 if ( state.backtracking==0 ) stream_SEPARATOR.add(SEPARATOR36);
9ad3c628 2048
73511e67 2049 pushFollow(FOLLOW_declarator_in_declaratorList1024);
7a91a2e4 2050 declarator37=declarator();
9ad3c628
AM		 2051 state._fsp--;
2052 if (state.failed) return retval;
7a91a2e4 2053 if ( state.backtracking==0 ) stream_declarator.add(declarator37.getTree());
9ad3c628
AM		 2054 }
2055 break;
2056
2057 default :
7a91a2e4 2058 break loop15;
9ad3c628
AM		 2059 }
2060 }
2061
2062 // AST REWRITE
2063 // elements: declarator
2064 // token labels:
2065 // rule labels: retval
2066 // token list labels:
2067 // rule list labels:
2068 // wildcard 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);
2072
2073 root_0 = (CommonTree)adaptor.nil();
73511e67 2074 // 274:7: -> ^( TYPE_DECLARATOR_LIST ( declarator )+ )
9ad3c628 2075 {
73511e67 2076 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:274:10: ^( TYPE_DECLARATOR_LIST ( declarator )+ )
9ad3c628
AM		 2077 {
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();
2082 }
2083 while ( stream_declarator.hasNext() ) {
2084 adaptor.addChild(root_1, stream_declarator.nextTree());
2085 }
2086 stream_declarator.reset();
2087
2088 adaptor.addChild(root_0, root_1);
2089 }
2090
2091 }
2092
2093
2094 retval.tree = root_0;
2095 }
2096
2097 }
2098
2099 retval.stop = input.LT(-1);
2100
2101 if ( state.backtracking==0 ) {
2102 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2103 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2104 }
2105 }
2106
2107 catch (RecognitionException e) {
2108 throw e;
2109 }
2110
2111 finally {
2112 // do for sure before leaving
2113 }
2114 return retval;
2115 }
2116 // $ANTLR end "declaratorList"
2117
2118
2119 public static class abstractDeclaratorList_return extends ParserRuleReturnScope {
2120 CommonTree tree;
2121 @Override
2122 public CommonTree getTree() { return tree; }
2123 };
2124
2125
2126 // $ANTLR start "abstractDeclaratorList"
73511e67 2127 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:277:1: abstractDeclaratorList : abstractDeclarator ( SEPARATOR abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ ) ;
9ad3c628
AM		 2128 public final CTFParser.abstractDeclaratorList_return abstractDeclaratorList() throws RecognitionException {
2129 CTFParser.abstractDeclaratorList_return retval = new CTFParser.abstractDeclaratorList_return();
2130 retval.start = input.LT(1);
2131
2132 CommonTree root_0 = null;
2133
7a91a2e4 2134 Token SEPARATOR39=null;
9ad3c628 2135 ParserRuleReturnScope abstractDeclarator38 =null;
7a91a2e4 2136 ParserRuleReturnScope abstractDeclarator40 =null;
9ad3c628 2137
7a91a2e4 2138 CommonTree SEPARATOR39_tree=null;
9ad3c628
AM		 2139 RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
2140 RewriteRuleSubtreeStream stream_abstractDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule abstractDeclarator");
2141
2142 try {
73511e67
AM		 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 )*
9ad3c628 2145 {
73511e67 2146 pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList1054);
7a91a2e4 2147 abstractDeclarator38=abstractDeclarator();
9ad3c628
AM		 2148 state._fsp--;
2149 if (state.failed) return retval;
7a91a2e4 2150 if ( state.backtracking==0 ) stream_abstractDeclarator.add(abstractDeclarator38.getTree());
73511e67 2151 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:278:24: ( SEPARATOR abstractDeclarator )*
7a91a2e4 2152 loop16:
9ad3c628 2153 while (true) {
7a91a2e4
MK		 2154 int alt16=2;
2155 int LA16_0 = input.LA(1);
2156 if ( (LA16_0==SEPARATOR) ) {
2157 alt16=1;
9ad3c628
AM		 2158 }
2159
7a91a2e4 2160 switch (alt16) {
9ad3c628 2161 case 1 :
73511e67 2162 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:278:25: SEPARATOR abstractDeclarator
9ad3c628 2163 {
73511e67 2164 SEPARATOR39=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_abstractDeclaratorList1057); if (state.failed) return retval;
7a91a2e4 2165 if ( state.backtracking==0 ) stream_SEPARATOR.add(SEPARATOR39);
9ad3c628 2166
73511e67 2167 pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList1059);
7a91a2e4 2168 abstractDeclarator40=abstractDeclarator();
9ad3c628
AM		 2169 state._fsp--;
2170 if (state.failed) return retval;
7a91a2e4 2171 if ( state.backtracking==0 ) stream_abstractDeclarator.add(abstractDeclarator40.getTree());
9ad3c628
AM		 2172 }
2173 break;
2174
2175 default :
7a91a2e4 2176 break loop16;
9ad3c628
AM		 2177 }
2178 }
2179
2180 // AST REWRITE
2181 // elements: abstractDeclarator
2182 // token labels:
2183 // rule labels: retval
2184 // token list labels:
2185 // rule list labels:
2186 // wildcard 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);
2190
2191 root_0 = (CommonTree)adaptor.nil();
73511e67 2192 // 279:7: -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ )
9ad3c628 2193 {
73511e67 2194 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:279:10: ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ )
9ad3c628
AM		 2195 {
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();
2200 }
2201 while ( stream_abstractDeclarator.hasNext() ) {
2202 adaptor.addChild(root_1, stream_abstractDeclarator.nextTree());
2203 }
2204 stream_abstractDeclarator.reset();
2205
2206 adaptor.addChild(root_0, root_1);
2207 }
2208
2209 }
2210
2211
2212 retval.tree = root_0;
2213 }
2214
2215 }
2216
2217 retval.stop = input.LT(-1);
2218
2219 if ( state.backtracking==0 ) {
2220 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2221 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2222 }
2223 }
2224
2225 catch (RecognitionException e) {
2226 throw e;
2227 }
2228
2229 finally {
2230 // do for sure before leaving
2231 }
2232 return retval;
2233 }
2234 // $ANTLR end "abstractDeclaratorList"
2235
2236
2237 public static class storageClassSpecifier_return extends ParserRuleReturnScope {
2238 CommonTree tree;
2239 @Override
2240 public CommonTree getTree() { return tree; }
2241 };
2242
2243
2244 // $ANTLR start "storageClassSpecifier"
73511e67 2245 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:282:1: storageClassSpecifier : TYPEDEFTOK ;
9ad3c628
AM		 2246 public final CTFParser.storageClassSpecifier_return storageClassSpecifier() throws RecognitionException {
2247 CTFParser.storageClassSpecifier_return retval = new CTFParser.storageClassSpecifier_return();
2248 retval.start = input.LT(1);
2249
2250 CommonTree root_0 = null;
2251
7a91a2e4 2252 Token TYPEDEFTOK41=null;
9ad3c628 2253
7a91a2e4 2254 CommonTree TYPEDEFTOK41_tree=null;
9ad3c628
AM		 2255
2256 try {
73511e67
AM		 2257 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:283:3: ( TYPEDEFTOK )
2258 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:283:5: TYPEDEFTOK
9ad3c628
AM		 2259 {
2260 root_0 = (CommonTree)adaptor.nil();
2261
2262
73511e67 2263 TYPEDEFTOK41=(Token)match(input,TYPEDEFTOK,FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1089); if (state.failed) return retval;
9ad3c628 2264 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2265 TYPEDEFTOK41_tree = (CommonTree)adaptor.create(TYPEDEFTOK41);
2266 adaptor.addChild(root_0, TYPEDEFTOK41_tree);
9ad3c628
AM		 2267 }
2268
2269 if ( state.backtracking==0 ) { typedefOn(); }
2270 }
2271
2272 retval.stop = input.LT(-1);
2273
2274 if ( state.backtracking==0 ) {
2275 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2276 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2277 }
2278 }
2279
2280 catch (RecognitionException e) {
2281 throw e;
2282 }
2283
2284 finally {
2285 // do for sure before leaving
2286 }
2287 return retval;
2288 }
2289 // $ANTLR end "storageClassSpecifier"
2290
2291
2292 public static class typeSpecifier_return extends ParserRuleReturnScope {
2293 CommonTree tree;
2294 @Override
2295 public CommonTree getTree() { return tree; }
2296 };
2297
2298
2299 // $ANTLR start "typeSpecifier"
73511e67 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 );
9ad3c628
AM		 2301 public final CTFParser.typeSpecifier_return typeSpecifier() throws RecognitionException {
2302 CTFParser.typeSpecifier_return retval = new CTFParser.typeSpecifier_return();
2303 retval.start = input.LT(1);
2304
2305 CommonTree root_0 = null;
2306
7a91a2e4
MK		 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;
2324
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;
9ad3c628
AM		 2337
2338 try {
73511e67 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 )
7a91a2e4
MK		 2340 int alt17=17;
2341 int LA17_0 = input.LA(1);
2342 if ( (LA17_0==FLOATTOK) ) {
2343 alt17=1;
9ad3c628 2344 }
7a91a2e4
MK		 2345 else if ( (LA17_0==INTTOK) ) {
2346 alt17=2;
9ad3c628 2347 }
7a91a2e4
MK		 2348 else if ( (LA17_0==LONGTOK) ) {
2349 alt17=3;
9ad3c628 2350 }
7a91a2e4
MK		 2351 else if ( (LA17_0==SHORTTOK) ) {
2352 alt17=4;
9ad3c628 2353 }
7a91a2e4
MK		 2354 else if ( (LA17_0==SIGNEDTOK) ) {
2355 alt17=5;
9ad3c628 2356 }
7a91a2e4
MK		 2357 else if ( (LA17_0==UNSIGNEDTOK) ) {
2358 alt17=6;
9ad3c628 2359 }
7a91a2e4
MK		 2360 else if ( (LA17_0==CHARTOK) ) {
2361 alt17=7;
9ad3c628 2362 }
7a91a2e4
MK		 2363 else if ( (LA17_0==DOUBLETOK) ) {
2364 alt17=8;
9ad3c628 2365 }
7a91a2e4
MK		 2366 else if ( (LA17_0==VOIDTOK) ) {
2367 alt17=9;
9ad3c628 2368 }
7a91a2e4
MK		 2369 else if ( (LA17_0==BOOLTOK) ) {
2370 alt17=10;
9ad3c628 2371 }
7a91a2e4
MK		 2372 else if ( (LA17_0==COMPLEXTOK) ) {
2373 alt17=11;
9ad3c628 2374 }
7a91a2e4
MK		 2375 else if ( (LA17_0==IMAGINARYTOK) ) {
2376 alt17=12;
9ad3c628 2377 }
7a91a2e4
MK		 2378 else if ( (LA17_0==STRUCTTOK) ) {
2379 alt17=13;
9ad3c628 2380 }
7a91a2e4
MK		 2381 else if ( (LA17_0==VARIANTTOK) ) {
2382 alt17=14;
9ad3c628 2383 }
7a91a2e4
MK		 2384 else if ( (LA17_0==ENUMTOK) ) {
2385 alt17=15;
9ad3c628 2386 }
7a91a2e4
MK		 2387 else if ( (LA17_0==FLOATINGPOINTTOK||LA17_0==INTEGERTOK||LA17_0==STRINGTOK) ) {
2388 alt17=16;
9ad3c628 2389 }
7a91a2e4
MK		 2390 else if ( (LA17_0==IDENTIFIER) && (( inTypealiasAlias() || isTypeName(input.LT(1).getText()) ))) {
2391 alt17=17;
9ad3c628
AM		 2392 }
2393
7a91a2e4 2394 switch (alt17) {
9ad3c628 2395 case 1 :
73511e67 2396 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:287:5: FLOATTOK
9ad3c628
AM		 2397 {
2398 root_0 = (CommonTree)adaptor.nil();
2399
2400
73511e67 2401 FLOATTOK42=(Token)match(input,FLOATTOK,FOLLOW_FLOATTOK_in_typeSpecifier1105); if (state.failed) return retval;
9ad3c628 2402 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2403 FLOATTOK42_tree = (CommonTree)adaptor.create(FLOATTOK42);
2404 adaptor.addChild(root_0, FLOATTOK42_tree);
9ad3c628
AM		 2405 }
2406
2407 }
2408 break;
2409 case 2 :
73511e67 2410 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:288:5: INTTOK
9ad3c628
AM		 2411 {
2412 root_0 = (CommonTree)adaptor.nil();
2413
2414
73511e67 2415 INTTOK43=(Token)match(input,INTTOK,FOLLOW_INTTOK_in_typeSpecifier1111); if (state.failed) return retval;
9ad3c628 2416 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2417 INTTOK43_tree = (CommonTree)adaptor.create(INTTOK43);
2418 adaptor.addChild(root_0, INTTOK43_tree);
9ad3c628
AM		 2419 }
2420
2421 }
2422 break;
2423 case 3 :
73511e67 2424 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:289:5: LONGTOK
9ad3c628
AM		 2425 {
2426 root_0 = (CommonTree)adaptor.nil();
2427
2428
73511e67 2429 LONGTOK44=(Token)match(input,LONGTOK,FOLLOW_LONGTOK_in_typeSpecifier1117); if (state.failed) return retval;
9ad3c628 2430 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2431 LONGTOK44_tree = (CommonTree)adaptor.create(LONGTOK44);
2432 adaptor.addChild(root_0, LONGTOK44_tree);
9ad3c628
AM		 2433 }
2434
2435 }
2436 break;
2437 case 4 :
73511e67 2438 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:290:5: SHORTTOK
9ad3c628
AM		 2439 {
2440 root_0 = (CommonTree)adaptor.nil();
2441
2442
73511e67 2443 SHORTTOK45=(Token)match(input,SHORTTOK,FOLLOW_SHORTTOK_in_typeSpecifier1123); if (state.failed) return retval;
9ad3c628 2444 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2445 SHORTTOK45_tree = (CommonTree)adaptor.create(SHORTTOK45);
2446 adaptor.addChild(root_0, SHORTTOK45_tree);
9ad3c628
AM		 2447 }
2448
2449 }
2450 break;
2451 case 5 :
73511e67 2452 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:291:5: SIGNEDTOK
9ad3c628
AM		 2453 {
2454 root_0 = (CommonTree)adaptor.nil();
2455
2456
73511e67 2457 SIGNEDTOK46=(Token)match(input,SIGNEDTOK,FOLLOW_SIGNEDTOK_in_typeSpecifier1129); if (state.failed) return retval;
9ad3c628 2458 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2459 SIGNEDTOK46_tree = (CommonTree)adaptor.create(SIGNEDTOK46);
2460 adaptor.addChild(root_0, SIGNEDTOK46_tree);
9ad3c628
AM		 2461 }
2462
2463 }
2464 break;
2465 case 6 :
73511e67 2466 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:292:5: UNSIGNEDTOK
9ad3c628
AM		 2467 {
2468 root_0 = (CommonTree)adaptor.nil();
2469
2470
73511e67 2471 UNSIGNEDTOK47=(Token)match(input,UNSIGNEDTOK,FOLLOW_UNSIGNEDTOK_in_typeSpecifier1135); if (state.failed) return retval;
9ad3c628 2472 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2473 UNSIGNEDTOK47_tree = (CommonTree)adaptor.create(UNSIGNEDTOK47);
2474 adaptor.addChild(root_0, UNSIGNEDTOK47_tree);
9ad3c628
AM		 2475 }
2476
2477 }
2478 break;
2479 case 7 :
73511e67 2480 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:293:5: CHARTOK
9ad3c628
AM		 2481 {
2482 root_0 = (CommonTree)adaptor.nil();
2483
2484
73511e67 2485 CHARTOK48=(Token)match(input,CHARTOK,FOLLOW_CHARTOK_in_typeSpecifier1141); if (state.failed) return retval;
9ad3c628 2486 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2487 CHARTOK48_tree = (CommonTree)adaptor.create(CHARTOK48);
2488 adaptor.addChild(root_0, CHARTOK48_tree);
9ad3c628
AM		 2489 }
2490
2491 }
2492 break;
2493 case 8 :
73511e67 2494 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:294:5: DOUBLETOK
9ad3c628
AM		 2495 {
2496 root_0 = (CommonTree)adaptor.nil();
2497
2498
73511e67 2499 DOUBLETOK49=(Token)match(input,DOUBLETOK,FOLLOW_DOUBLETOK_in_typeSpecifier1147); if (state.failed) return retval;
9ad3c628 2500 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2501 DOUBLETOK49_tree = (CommonTree)adaptor.create(DOUBLETOK49);
2502 adaptor.addChild(root_0, DOUBLETOK49_tree);
9ad3c628
AM		 2503 }
2504
2505 }
2506 break;
2507 case 9 :
73511e67 2508 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:295:5: VOIDTOK
9ad3c628
AM		 2509 {
2510 root_0 = (CommonTree)adaptor.nil();
2511
2512
73511e67 2513 VOIDTOK50=(Token)match(input,VOIDTOK,FOLLOW_VOIDTOK_in_typeSpecifier1153); if (state.failed) return retval;
9ad3c628 2514 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2515 VOIDTOK50_tree = (CommonTree)adaptor.create(VOIDTOK50);
2516 adaptor.addChild(root_0, VOIDTOK50_tree);
9ad3c628
AM		 2517 }
2518
2519 }
2520 break;
2521 case 10 :
73511e67 2522 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:296:5: BOOLTOK
9ad3c628
AM		 2523 {
2524 root_0 = (CommonTree)adaptor.nil();
2525
2526
73511e67 2527 BOOLTOK51=(Token)match(input,BOOLTOK,FOLLOW_BOOLTOK_in_typeSpecifier1159); if (state.failed) return retval;
9ad3c628 2528 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2529 BOOLTOK51_tree = (CommonTree)adaptor.create(BOOLTOK51);
2530 adaptor.addChild(root_0, BOOLTOK51_tree);
9ad3c628
AM		 2531 }
2532
2533 }
2534 break;
2535 case 11 :
73511e67 2536 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:297:5: COMPLEXTOK
9ad3c628
AM		 2537 {
2538 root_0 = (CommonTree)adaptor.nil();
2539
2540
73511e67 2541 COMPLEXTOK52=(Token)match(input,COMPLEXTOK,FOLLOW_COMPLEXTOK_in_typeSpecifier1165); if (state.failed) return retval;
9ad3c628 2542 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2543 COMPLEXTOK52_tree = (CommonTree)adaptor.create(COMPLEXTOK52);
2544 adaptor.addChild(root_0, COMPLEXTOK52_tree);
9ad3c628
AM		 2545 }
2546
2547 }
2548 break;
2549 case 12 :
73511e67 2550 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:298:5: IMAGINARYTOK
9ad3c628
AM		 2551 {
2552 root_0 = (CommonTree)adaptor.nil();
2553
2554
73511e67 2555 IMAGINARYTOK53=(Token)match(input,IMAGINARYTOK,FOLLOW_IMAGINARYTOK_in_typeSpecifier1171); if (state.failed) return retval;
9ad3c628 2556 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2557 IMAGINARYTOK53_tree = (CommonTree)adaptor.create(IMAGINARYTOK53);
2558 adaptor.addChild(root_0, IMAGINARYTOK53_tree);
9ad3c628
AM		 2559 }
2560
2561 }
2562 break;
2563 case 13 :
73511e67 2564 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:299:5: structSpecifier
9ad3c628
AM		 2565 {
2566 root_0 = (CommonTree)adaptor.nil();
2567
2568
73511e67 2569 pushFollow(FOLLOW_structSpecifier_in_typeSpecifier1177);
7a91a2e4 2570 structSpecifier54=structSpecifier();
9ad3c628
AM		 2571 state._fsp--;
2572 if (state.failed) return retval;
7a91a2e4 2573 if ( state.backtracking==0 ) adaptor.addChild(root_0, structSpecifier54.getTree());
9ad3c628
AM		 2574
2575 }
2576 break;
2577 case 14 :
73511e67 2578 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:300:5: variantSpecifier
9ad3c628
AM		 2579 {
2580 root_0 = (CommonTree)adaptor.nil();
2581
2582
73511e67 2583 pushFollow(FOLLOW_variantSpecifier_in_typeSpecifier1183);
7a91a2e4 2584 variantSpecifier55=variantSpecifier();
9ad3c628
AM		 2585 state._fsp--;
2586 if (state.failed) return retval;
7a91a2e4 2587 if ( state.backtracking==0 ) adaptor.addChild(root_0, variantSpecifier55.getTree());
9ad3c628
AM		 2588
2589 }
2590 break;
2591 case 15 :
73511e67 2592 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:301:5: enumSpecifier
9ad3c628
AM		 2593 {
2594 root_0 = (CommonTree)adaptor.nil();
2595
2596
73511e67 2597 pushFollow(FOLLOW_enumSpecifier_in_typeSpecifier1189);
7a91a2e4 2598 enumSpecifier56=enumSpecifier();
9ad3c628
AM		 2599 state._fsp--;
2600 if (state.failed) return retval;
7a91a2e4 2601 if ( state.backtracking==0 ) adaptor.addChild(root_0, enumSpecifier56.getTree());
9ad3c628
AM		 2602
2603 }
2604 break;
2605 case 16 :
73511e67 2606 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:302:5: ctfTypeSpecifier
9ad3c628
AM		 2607 {
2608 root_0 = (CommonTree)adaptor.nil();
2609
2610
73511e67 2611 pushFollow(FOLLOW_ctfTypeSpecifier_in_typeSpecifier1195);
7a91a2e4 2612 ctfTypeSpecifier57=ctfTypeSpecifier();
9ad3c628
AM		 2613 state._fsp--;
2614 if (state.failed) return retval;
7a91a2e4 2615 if ( state.backtracking==0 ) adaptor.addChild(root_0, ctfTypeSpecifier57.getTree());
9ad3c628
AM		 2616
2617 }
2618 break;
2619 case 17 :
73511e67 2620 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:303:5: {...}? => typedefName
9ad3c628
AM		 2621 {
2622 root_0 = (CommonTree)adaptor.nil();
2623
2624
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()) ");
2628 }
73511e67 2629 pushFollow(FOLLOW_typedefName_in_typeSpecifier1205);
7a91a2e4 2630 typedefName58=typedefName();
9ad3c628
AM		 2631 state._fsp--;
2632 if (state.failed) return retval;
7a91a2e4 2633 if ( state.backtracking==0 ) adaptor.addChild(root_0, typedefName58.getTree());
9ad3c628
AM		 2634
2635 }
2636 break;
2637
2638 }
2639 retval.stop = input.LT(-1);
2640
2641 if ( state.backtracking==0 ) {
2642 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2643 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2644 }
2645 }
2646
2647 catch (RecognitionException e) {
2648 throw e;
2649 }
2650
2651 finally {
2652 // do for sure before leaving
2653 }
2654 return retval;
2655 }
2656 // $ANTLR end "typeSpecifier"
2657
2658
2659 public static class typeQualifier_return extends ParserRuleReturnScope {
2660 CommonTree tree;
2661 @Override
2662 public CommonTree getTree() { return tree; }
2663 };
2664
2665
2666 // $ANTLR start "typeQualifier"
73511e67 2667 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:306:1: typeQualifier : CONSTTOK ;
9ad3c628
AM		 2668 public final CTFParser.typeQualifier_return typeQualifier() throws RecognitionException {
2669 CTFParser.typeQualifier_return retval = new CTFParser.typeQualifier_return();
2670 retval.start = input.LT(1);
2671
2672 CommonTree root_0 = null;
2673
7a91a2e4 2674 Token CONSTTOK59=null;
9ad3c628 2675
7a91a2e4 2676 CommonTree CONSTTOK59_tree=null;
9ad3c628
AM		 2677
2678 try {
73511e67
AM		 2679 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:307:3: ( CONSTTOK )
2680 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:307:5: CONSTTOK
9ad3c628
AM		 2681 {
2682 root_0 = (CommonTree)adaptor.nil();
2683
2684
73511e67 2685 CONSTTOK59=(Token)match(input,CONSTTOK,FOLLOW_CONSTTOK_in_typeQualifier1218); if (state.failed) return retval;
9ad3c628 2686 if ( state.backtracking==0 ) {
7a91a2e4
MK		 2687 CONSTTOK59_tree = (CommonTree)adaptor.create(CONSTTOK59);
2688 adaptor.addChild(root_0, CONSTTOK59_tree);
9ad3c628
AM		 2689 }
2690
2691 }
2692
2693 retval.stop = input.LT(-1);
2694
2695 if ( state.backtracking==0 ) {
2696 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2697 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2698 }
2699 }
2700
2701 catch (RecognitionException e) {
2702 throw e;
2703 }
2704
2705 finally {
2706 // do for sure before leaving
2707 }
2708 return retval;
2709 }
2710 // $ANTLR end "typeQualifier"
2711
2712
2713 public static class alignAttribute_return extends ParserRuleReturnScope {
2714 CommonTree tree;
2715 @Override
2716 public CommonTree getTree() { return tree; }
2717 };
2718
2719
2720 // $ANTLR start "alignAttribute"
73511e67 2721 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:310:1: alignAttribute : ALIGNTOK LPAREN unaryExpression RPAREN -> ^( ALIGN unaryExpression ) ;
9ad3c628
AM		 2722 public final CTFParser.alignAttribute_return alignAttribute() throws RecognitionException {
2723 CTFParser.alignAttribute_return retval = new CTFParser.alignAttribute_return();
2724 retval.start = input.LT(1);
2725
2726 CommonTree root_0 = null;
2727
7a91a2e4
MK		 2728 Token ALIGNTOK60=null;
2729 Token LPAREN61=null;
2730 Token RPAREN63=null;
2731 ParserRuleReturnScope unaryExpression62 =null;
9ad3c628 2732
7a91a2e4
MK		 2733 CommonTree ALIGNTOK60_tree=null;
2734 CommonTree LPAREN61_tree=null;
2735 CommonTree RPAREN63_tree=null;
73511e67 2736 RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
9ad3c628
AM		 2737 RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
2738 RewriteRuleTokenStream stream_ALIGNTOK=new RewriteRuleTokenStream(adaptor,"token ALIGNTOK");
9ad3c628
AM		 2739 RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
2740
2741 try {
73511e67
AM		 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
9ad3c628 2744 {
73511e67 2745 ALIGNTOK60=(Token)match(input,ALIGNTOK,FOLLOW_ALIGNTOK_in_alignAttribute1231); if (state.failed) return retval;
7a91a2e4 2746 if ( state.backtracking==0 ) stream_ALIGNTOK.add(ALIGNTOK60);
9ad3c628 2747
73511e67 2748 LPAREN61=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_alignAttribute1233); if (state.failed) return retval;
7a91a2e4 2749 if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN61);
9ad3c628 2750
73511e67 2751 pushFollow(FOLLOW_unaryExpression_in_alignAttribute1235);
7a91a2e4 2752 unaryExpression62=unaryExpression();
9ad3c628
AM		 2753 state._fsp--;
2754 if (state.failed) return retval;
7a91a2e4 2755 if ( state.backtracking==0 ) stream_unaryExpression.add(unaryExpression62.getTree());
73511e67 2756 RPAREN63=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_alignAttribute1237); if (state.failed) return retval;
7a91a2e4 2757 if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN63);
9ad3c628
AM		 2758
2759 // AST REWRITE
2760 // elements: unaryExpression
2761 // token labels:
2762 // rule labels: retval
2763 // token list labels:
2764 // rule list labels:
2765 // wildcard 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);
2769
2770 root_0 = (CommonTree)adaptor.nil();
73511e67 2771 // 311:44: -> ^( ALIGN unaryExpression )
9ad3c628 2772 {
73511e67 2773 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:311:47: ^( ALIGN unaryExpression )
9ad3c628
AM		 2774 {
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);
2779 }
2780
2781 }
2782
2783
2784 retval.tree = root_0;
2785 }
2786
2787 }
2788
2789 retval.stop = input.LT(-1);
2790
2791 if ( state.backtracking==0 ) {
2792 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2793 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2794 }
2795 }
2796
2797 catch (RecognitionException e) {
2798 throw e;
2799 }
2800
2801 finally {
2802 // do for sure before leaving
2803 }
2804 return retval;
2805 }
2806 // $ANTLR end "alignAttribute"
2807
2808
2809 public static class structBody_return extends ParserRuleReturnScope {
2810 CommonTree tree;
2811 @Override
2812 public CommonTree getTree() { return tree; }
2813 };
2814
2815
2816 // $ANTLR start "structBody"
73511e67 2817 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:315:1: structBody : LCURL ( structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY ( structOrVariantDeclarationList )? ) ;
9ad3c628
AM		 2818 public final CTFParser.structBody_return structBody() throws RecognitionException {
2819 Symbols_stack.push(new Symbols_scope());
2820
2821 CTFParser.structBody_return retval = new CTFParser.structBody_return();
2822 retval.start = input.LT(1);
2823
2824 CommonTree root_0 = null;
2825
7a91a2e4
MK		 2826 Token LCURL64=null;
2827 Token RCURL66=null;
2828 ParserRuleReturnScope structOrVariantDeclarationList65 =null;
9ad3c628 2829
7a91a2e4
MK		 2830 CommonTree LCURL64_tree=null;
2831 CommonTree RCURL66_tree=null;
9ad3c628
AM		 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");
2835
2836
2837 Symbols_stack.peek().types = new HashSet<String>();
2838
2839 try {
73511e67
AM		 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
9ad3c628 2842 {
73511e67 2843 LCURL64=(Token)match(input,LCURL,FOLLOW_LCURL_in_structBody1271); if (state.failed) return retval;
7a91a2e4 2844 if ( state.backtracking==0 ) stream_LCURL.add(LCURL64);
9ad3c628 2845
73511e67 2846 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:320:11: ( structOrVariantDeclarationList )?
7a91a2e4
MK		 2847 int alt18=2;
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)) ) {
2850 alt18=1;
9ad3c628 2851 }
7a91a2e4
MK		 2852 else if ( (LA18_0==IDENTIFIER) && (( inTypealiasAlias() || isTypeName(input.LT(1).getText()) ))) {
2853 alt18=1;
9ad3c628 2854 }
7a91a2e4
MK		 2855 else if ( (LA18_0==TYPEALIASTOK) ) {
2856 alt18=1;
9ad3c628 2857 }
7a91a2e4 2858 switch (alt18) {
9ad3c628 2859 case 1 :
73511e67 2860 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:320:11: structOrVariantDeclarationList
9ad3c628 2861 {
73511e67 2862 pushFollow(FOLLOW_structOrVariantDeclarationList_in_structBody1273);
7a91a2e4 2863 structOrVariantDeclarationList65=structOrVariantDeclarationList();
9ad3c628
AM		 2864 state._fsp--;
2865 if (state.failed) return retval;
7a91a2e4 2866 if ( state.backtracking==0 ) stream_structOrVariantDeclarationList.add(structOrVariantDeclarationList65.getTree());
9ad3c628
AM		 2867 }
2868 break;
2869
2870 }
2871
73511e67 2872 RCURL66=(Token)match(input,RCURL,FOLLOW_RCURL_in_structBody1276); if (state.failed) return retval;
7a91a2e4 2873 if ( state.backtracking==0 ) stream_RCURL.add(RCURL66);
9ad3c628
AM		 2874
2875 // AST REWRITE
2876 // elements: structOrVariantDeclarationList
2877 // token labels:
2878 // rule labels: retval
2879 // token list labels:
2880 // rule list labels:
2881 // wildcard 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);
2885
2886 root_0 = (CommonTree)adaptor.nil();
73511e67 2887 // 321:7: -> ^( STRUCT_BODY ( structOrVariantDeclarationList )? )
9ad3c628 2888 {
73511e67 2889 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:321:10: ^( STRUCT_BODY ( structOrVariantDeclarationList )? )
9ad3c628
AM		 2890 {
2891 CommonTree root_1 = (CommonTree)adaptor.nil();
2892 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(STRUCT_BODY, "STRUCT_BODY"), root_1);
73511e67 2893 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:321:24: ( structOrVariantDeclarationList )?
9ad3c628
AM		 2894 if ( stream_structOrVariantDeclarationList.hasNext() ) {
2895 adaptor.addChild(root_1, stream_structOrVariantDeclarationList.nextTree());
2896 }
2897 stream_structOrVariantDeclarationList.reset();
2898
2899 adaptor.addChild(root_0, root_1);
2900 }
2901
2902 }
2903
2904
2905 retval.tree = root_0;
2906 }
2907
2908 }
2909
2910 retval.stop = input.LT(-1);
2911
2912 if ( state.backtracking==0 ) {
2913 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2914 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
2915 }
2916 }
2917
2918 catch (RecognitionException e) {
2919 throw e;
2920 }
2921
2922 finally {
2923 // do for sure before leaving
2924 Symbols_stack.pop();
2925
2926 }
2927 return retval;
2928 }
2929 // $ANTLR end "structBody"
2930
2931
2932 public static class structSpecifier_return extends ParserRuleReturnScope {
2933 CommonTree tree;
2934 @Override
2935 public CommonTree getTree() { return tree; }
2936 };
2937
2938
2939 // $ANTLR start "structSpecifier"
73511e67 2940 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:324:1: structSpecifier : STRUCTTOK ( ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) ) | ( structBody ( alignAttribute |) ) ) -> ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? ) ;
9ad3c628
AM		 2941 public final CTFParser.structSpecifier_return structSpecifier() throws RecognitionException {
2942 CTFParser.structSpecifier_return retval = new CTFParser.structSpecifier_return();
2943 retval.start = input.LT(1);
2944
2945 CommonTree root_0 = null;
2946
7a91a2e4
MK		 2947 Token STRUCTTOK67=null;
2948 ParserRuleReturnScope structName68 =null;
9ad3c628
AM		 2949 ParserRuleReturnScope alignAttribute69 =null;
2950 ParserRuleReturnScope structBody70 =null;
2951 ParserRuleReturnScope alignAttribute71 =null;
7a91a2e4
MK		 2952 ParserRuleReturnScope structBody72 =null;
2953 ParserRuleReturnScope alignAttribute73 =null;
9ad3c628 2954
7a91a2e4 2955 CommonTree STRUCTTOK67_tree=null;
9ad3c628
AM		 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");
2960
2961 try {
73511e67
AM		 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 |) ) )
9ad3c628 2964 {
73511e67 2965 STRUCTTOK67=(Token)match(input,STRUCTTOK,FOLLOW_STRUCTTOK_in_structSpecifier1304); if (state.failed) return retval;
7a91a2e4 2966 if ( state.backtracking==0 ) stream_STRUCTTOK.add(STRUCTTOK67);
9ad3c628 2967
73511e67 2968 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:326:3: ( ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) ) | ( structBody ( alignAttribute |) ) )
7a91a2e4
MK		 2969 int alt22=2;
2970 int LA22_0 = input.LA(1);
2971 if ( (LA22_0==IDENTIFIER) ) {
2972 alt22=1;
9ad3c628 2973 }
7a91a2e4
MK		 2974 else if ( (LA22_0==LCURL) ) {
2975 alt22=2;
9ad3c628
AM		 2976 }
2977
2978 else {
2979 if (state.backtracking>0) {state.failed=true; return retval;}
2980 NoViableAltException nvae =
7a91a2e4 2981 new NoViableAltException("", 22, 0, input);
9ad3c628
AM		 2982 throw nvae;
2983 }
2984
7a91a2e4 2985 switch (alt22) {
9ad3c628 2986 case 1 :
73511e67 2987 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:328:5: ( structName ( alignAttribute | ( structBody ( alignAttribute |) ) |) )
9ad3c628 2988 {
73511e67
AM		 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 |) ) |)
9ad3c628 2991 {
73511e67 2992 pushFollow(FOLLOW_structName_in_structSpecifier1329);
7a91a2e4 2993 structName68=structName();
9ad3c628
AM		 2994 state._fsp--;
2995 if (state.failed) return retval;
7a91a2e4 2996 if ( state.backtracking==0 ) stream_structName.add(structName68.getTree());
73511e67 2997 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:330:9: ( alignAttribute | ( structBody ( alignAttribute |) ) |)
7a91a2e4 2998 int alt20=3;
9ad3c628
AM		 2999 switch ( input.LA(1) ) {
3000 case ALIGNTOK:
3001 {
7a91a2e4 3002 alt20=1;
9ad3c628
AM		 3003 }
3004 break;
3005 case LCURL:
3006 {
3007 switch ( input.LA(2) ) {
3008 case BOOLTOK:
3009 case CHARTOK:
3010 case COMPLEXTOK:
3011 case CONSTTOK:
3012 case DOUBLETOK:
3013 case ENUMTOK:
3014 case FLOATINGPOINTTOK:
3015 case FLOATTOK:
3016 case IMAGINARYTOK:
3017 case INTEGERTOK:
3018 case INTTOK:
3019 case LONGTOK:
3020 case RCURL:
3021 case SHORTTOK:
3022 case STRUCTTOK:
3023 case TYPEALIASTOK:
3024 case TYPEDEFTOK:
3025 case UNSIGNEDTOK:
3026 case VARIANTTOK:
3027 case VOIDTOK:
3028 {
7a91a2e4 3029 alt20=2;
9ad3c628
AM		 3030 }
3031 break;
3032 case SIGNEDTOK:
3033 {
7a91a2e4
MK		 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)) ) {
3036 alt20=2;
9ad3c628 3037 }
7a91a2e4
MK		 3038 else if ( (LA20_5==ASSIGNMENT||LA20_5==RCURL||LA20_5==SEPARATOR) ) {
3039 alt20=3;
9ad3c628
AM		 3040 }
3041
3042 else {
3043 if (state.backtracking>0) {state.failed=true; return retval;}
3044 int nvaeMark = input.mark();
3045 try {
3046 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
3047 input.consume();
3048 }
3049 NoViableAltException nvae =
7a91a2e4 3050 new NoViableAltException("", 20, 5, input);
9ad3c628
AM		 3051 throw nvae;
3052 } finally {
3053 input.rewind(nvaeMark);
3054 }
3055 }
3056
3057 }
3058 break;
3059 case STRINGTOK:
3060 {
7a91a2e4
MK		 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)) ) {
3063 alt20=2;
9ad3c628 3064 }
7a91a2e4
MK		 3065 else if ( (LA20_6==ASSIGNMENT||LA20_6==RCURL||LA20_6==SEPARATOR) ) {
3066 alt20=3;
9ad3c628
AM		 3067 }
3068
3069 else {
3070 if (state.backtracking>0) {state.failed=true; return retval;}
3071 int nvaeMark = input.mark();
3072 try {
3073 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
3074 input.consume();
3075 }
3076 NoViableAltException nvae =
7a91a2e4 3077 new NoViableAltException("", 20, 6, input);
9ad3c628
AM		 3078 throw nvae;
3079 } finally {
3080 input.rewind(nvaeMark);
3081 }
3082 }
3083
3084 }
3085 break;
3086 case IDENTIFIER:
3087 {
7a91a2e4
MK		 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)) ) {
3090 alt20=2;
9ad3c628 3091 }
7a91a2e4
MK		 3092 else if ( (LA20_7==ASSIGNMENT||LA20_7==RCURL||LA20_7==SEPARATOR) ) {
3093 alt20=3;
9ad3c628
AM		 3094 }
3095
3096 else {
3097 if (state.backtracking>0) {state.failed=true; return retval;}
3098 int nvaeMark = input.mark();
3099 try {
3100 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
3101 input.consume();
3102 }
3103 NoViableAltException nvae =
7a91a2e4 3104 new NoViableAltException("", 20, 7, input);
9ad3c628
AM		 3105 throw nvae;
3106 } finally {
3107 input.rewind(nvaeMark);
3108 }
3109 }
3110
3111 }
3112 break;
3113 case ALIGNTOK:
3114 case EVENTTOK:
3115 case STRING_LITERAL:
3116 {
7a91a2e4 3117 alt20=3;
9ad3c628
AM		 3118 }
3119 break;
3120 default:
3121 if (state.backtracking>0) {state.failed=true; return retval;}
3122 int nvaeMark = input.mark();
3123 try {
3124 input.consume();
3125 NoViableAltException nvae =
7a91a2e4 3126 new NoViableAltException("", 20, 2, input);
9ad3c628
AM		 3127 throw nvae;
3128 } finally {
3129 input.rewind(nvaeMark);
3130 }
3131 }
3132 }
3133 break;
3134 case EOF:
3135 case BOOLTOK:
3136 case CHARTOK:
3137 case COMPLEXTOK:
3138 case CONSTTOK:
3139 case DOUBLETOK:
3140 case ENUMTOK:
3141 case FLOATINGPOINTTOK:
3142 case FLOATTOK:
3143 case IDENTIFIER:
3144 case IMAGINARYTOK:
3145 case INTEGERTOK:
3146 case INTTOK:
3147 case LONGTOK:
3148 case LPAREN:
3149 case POINTER:
3150 case SHORTTOK:
3151 case SIGNEDTOK:
3152 case STRINGTOK:
3153 case STRUCTTOK:
3154 case TERM:
3155 case TYPEDEFTOK:
3156 case TYPE_ASSIGNMENT:
3157 case UNSIGNEDTOK:
3158 case VARIANTTOK:
3159 case VOIDTOK:
3160 {
7a91a2e4 3161 alt20=3;
9ad3c628
AM		 3162 }
3163 break;
3164 default:
3165 if (state.backtracking>0) {state.failed=true; return retval;}
3166 NoViableAltException nvae =
7a91a2e4 3167 new NoViableAltException("", 20, 0, input);
9ad3c628
AM		 3168 throw nvae;
3169 }
7a91a2e4 3170 switch (alt20) {
9ad3c628 3171 case 1 :
73511e67 3172 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:331:11: alignAttribute
9ad3c628 3173 {
73511e67 3174 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1351);
7a91a2e4 3175 alignAttribute69=alignAttribute();
9ad3c628
AM		 3176 state._fsp--;
3177 if (state.failed) return retval;
7a91a2e4 3178 if ( state.backtracking==0 ) stream_alignAttribute.add(alignAttribute69.getTree());
9ad3c628
AM		 3179 }
3180 break;
3181 case 2 :
73511e67 3182 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:333:11: ( structBody ( alignAttribute |) )
9ad3c628 3183 {
73511e67
AM		 3184 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:333:11: ( structBody ( alignAttribute |) )
3185 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:334:13: structBody ( alignAttribute |)
9ad3c628 3186 {
73511e67 3187 pushFollow(FOLLOW_structBody_in_structSpecifier1387);
7a91a2e4 3188 structBody70=structBody();
9ad3c628
AM		 3189 state._fsp--;
3190 if (state.failed) return retval;
7a91a2e4 3191 if ( state.backtracking==0 ) stream_structBody.add(structBody70.getTree());
73511e67 3192 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:335:13: ( alignAttribute |)
7a91a2e4
MK		 3193 int alt19=2;
3194 int LA19_0 = input.LA(1);
3195 if ( (LA19_0==ALIGNTOK) ) {
3196 alt19=1;
9ad3c628 3197 }
7a91a2e4
MK		 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)) ) {
3199 alt19=2;
9ad3c628
AM		 3200 }
3201
3202 else {
3203 if (state.backtracking>0) {state.failed=true; return retval;}
3204 NoViableAltException nvae =
7a91a2e4 3205 new NoViableAltException("", 19, 0, input);
9ad3c628
AM		 3206 throw nvae;
3207 }
3208
7a91a2e4 3209 switch (alt19) {
9ad3c628 3210 case 1 :
73511e67 3211 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:336:14: alignAttribute
9ad3c628 3212 {
73511e67 3213 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1418);
7a91a2e4 3214 alignAttribute71=alignAttribute();
9ad3c628
AM		 3215 state._fsp--;
3216 if (state.failed) return retval;
7a91a2e4 3217 if ( state.backtracking==0 ) stream_alignAttribute.add(alignAttribute71.getTree());
9ad3c628
AM		 3218 }
3219 break;
3220 case 2 :
73511e67 3221 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:339:13:
9ad3c628
AM		 3222 {
3223 }
3224 break;
3225
3226 }
3227
3228 }
3229
3230 }
3231 break;
3232 case 3 :
73511e67 3233 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:343:9:
9ad3c628
AM		 3234 {
3235 }
3236 break;
3237
3238 }
3239
3240 }
3241
3242 }
3243 break;
3244 case 2 :
73511e67 3245 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:347:5: ( structBody ( alignAttribute |) )
9ad3c628 3246 {
73511e67
AM		 3247 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:347:5: ( structBody ( alignAttribute |) )
3248 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:348:7: structBody ( alignAttribute |)
9ad3c628 3249 {
73511e67 3250 pushFollow(FOLLOW_structBody_in_structSpecifier1534);
7a91a2e4 3251 structBody72=structBody();
9ad3c628
AM		 3252 state._fsp--;
3253 if (state.failed) return retval;
7a91a2e4 3254 if ( state.backtracking==0 ) stream_structBody.add(structBody72.getTree());
73511e67 3255 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:349:7: ( alignAttribute |)
7a91a2e4
MK		 3256 int alt21=2;
3257 int LA21_0 = input.LA(1);
3258 if ( (LA21_0==ALIGNTOK) ) {
3259 alt21=1;
9ad3c628 3260 }
7a91a2e4
MK		 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)) ) {
3262 alt21=2;
9ad3c628
AM		 3263 }
3264
3265 else {
3266 if (state.backtracking>0) {state.failed=true; return retval;}
3267 NoViableAltException nvae =
7a91a2e4 3268 new NoViableAltException("", 21, 0, input);
9ad3c628
AM		 3269 throw nvae;
3270 }
3271
7a91a2e4 3272 switch (alt21) {
9ad3c628 3273 case 1 :
73511e67 3274 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:350:9: alignAttribute
9ad3c628 3275 {
73511e67 3276 pushFollow(FOLLOW_alignAttribute_in_structSpecifier1552);
7a91a2e4 3277 alignAttribute73=alignAttribute();
9ad3c628
AM		 3278 state._fsp--;
3279 if (state.failed) return retval;
7a91a2e4 3280 if ( state.backtracking==0 ) stream_alignAttribute.add(alignAttribute73.getTree());
9ad3c628
AM		 3281 }
3282 break;
3283 case 2 :
73511e67 3284 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:353:7:
9ad3c628
AM		 3285 {
3286 }
3287 break;
3288
3289 }
3290
3291 }
3292
3293 }
3294 break;
3295
3296 }
3297
3298 // AST REWRITE
73511e67 3299 // elements: structName, structBody, alignAttribute
9ad3c628
AM		 3300 // token labels:
3301 // rule labels: retval
3302 // token list labels:
3303 // rule list labels:
3304 // wildcard 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);
3308
3309 root_0 = (CommonTree)adaptor.nil();
73511e67 3310 // 355:5: -> ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? )
9ad3c628 3311 {
73511e67 3312 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:355:8: ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? )
9ad3c628
AM		 3313 {
3314 CommonTree root_1 = (CommonTree)adaptor.nil();
3315 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(STRUCT, "STRUCT"), root_1);
73511e67 3316 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:355:17: ( structName )?
9ad3c628
AM		 3317 if ( stream_structName.hasNext() ) {
3318 adaptor.addChild(root_1, stream_structName.nextTree());
3319 }
3320 stream_structName.reset();
3321
73511e67 3322 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:355:29: ( structBody )?
9ad3c628
AM		 3323 if ( stream_structBody.hasNext() ) {
3324 adaptor.addChild(root_1, stream_structBody.nextTree());
3325 }
3326 stream_structBody.reset();
3327
73511e67 3328 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:355:41: ( alignAttribute )?
9ad3c628
AM		 3329 if ( stream_alignAttribute.hasNext() ) {
3330 adaptor.addChild(root_1, stream_alignAttribute.nextTree());
3331 }
3332 stream_alignAttribute.reset();
3333
3334 adaptor.addChild(root_0, root_1);
3335 }
3336
3337 }
3338
3339
3340 retval.tree = root_0;
3341 }
3342
3343 }
3344
3345 retval.stop = input.LT(-1);
3346
3347 if ( state.backtracking==0 ) {
3348 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3349 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3350 }
3351 }
3352
3353 catch (RecognitionException e) {
3354 throw e;
3355 }
3356
3357 finally {
3358 // do for sure before leaving
3359 }
3360 return retval;
3361 }
3362 // $ANTLR end "structSpecifier"
3363
3364
3365 public static class structName_return extends ParserRuleReturnScope {
3366 CommonTree tree;
3367 @Override
3368 public CommonTree getTree() { return tree; }
3369 };
3370
3371
3372 // $ANTLR start "structName"
73511e67 3373 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:358:1: structName : IDENTIFIER -> ^( STRUCT_NAME IDENTIFIER ) ;
9ad3c628
AM		 3374 public final CTFParser.structName_return structName() throws RecognitionException {
3375 CTFParser.structName_return retval = new CTFParser.structName_return();
3376 retval.start = input.LT(1);
3377
3378 CommonTree root_0 = null;
3379
7a91a2e4 3380 Token IDENTIFIER74=null;
9ad3c628 3381
7a91a2e4 3382 CommonTree IDENTIFIER74_tree=null;
9ad3c628
AM		 3383 RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
3384
3385 try {
73511e67
AM		 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
9ad3c628 3388 {
73511e67 3389 IDENTIFIER74=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_structName1618); if (state.failed) return retval;
7a91a2e4 3390 if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER74);
9ad3c628
AM		 3391
3392 // AST REWRITE
3393 // elements: IDENTIFIER
3394 // token labels:
3395 // rule labels: retval
3396 // token list labels:
3397 // rule list labels:
3398 // wildcard 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);
3402
3403 root_0 = (CommonTree)adaptor.nil();
73511e67 3404 // 359:16: -> ^( STRUCT_NAME IDENTIFIER )
9ad3c628 3405 {
73511e67 3406 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:359:19: ^( STRUCT_NAME IDENTIFIER )
9ad3c628
AM		 3407 {
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);
3412 }
3413
3414 }
3415
3416
3417 retval.tree = root_0;
3418 }
3419
3420 }
3421
3422 retval.stop = input.LT(-1);
3423
3424 if ( state.backtracking==0 ) {
3425 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3426 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3427 }
3428 }
3429
3430 catch (RecognitionException e) {
3431 throw e;
3432 }
3433
3434 finally {
3435 // do for sure before leaving
3436 }
3437 return retval;
3438 }
3439 // $ANTLR end "structName"
3440
3441
3442 public static class structOrVariantDeclarationList_return extends ParserRuleReturnScope {
3443 CommonTree tree;
3444 @Override
3445 public CommonTree getTree() { return tree; }
3446 };
3447
3448
3449 // $ANTLR start "structOrVariantDeclarationList"
73511e67 3450 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:362:1: structOrVariantDeclarationList : ( structOrVariantDeclaration )+ ;
9ad3c628
AM		 3451 public final CTFParser.structOrVariantDeclarationList_return structOrVariantDeclarationList() throws RecognitionException {
3452 CTFParser.structOrVariantDeclarationList_return retval = new CTFParser.structOrVariantDeclarationList_return();
3453 retval.start = input.LT(1);
3454
3455 CommonTree root_0 = null;
3456
7a91a2e4 3457 ParserRuleReturnScope structOrVariantDeclaration75 =null;
9ad3c628
AM		 3458
3459
3460 try {
73511e67
AM		 3461 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:363:3: ( ( structOrVariantDeclaration )+ )
3462 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:363:5: ( structOrVariantDeclaration )+
9ad3c628
AM		 3463 {
3464 root_0 = (CommonTree)adaptor.nil();
3465
3466
73511e67 3467 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:363:5: ( structOrVariantDeclaration )+
7a91a2e4
MK		 3468 int cnt23=0;
3469 loop23:
9ad3c628 3470 while (true) {
7a91a2e4
MK		 3471 int alt23=2;
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)) ) {
3474 alt23=1;
9ad3c628 3475 }
7a91a2e4
MK		 3476 else if ( (LA23_0==IDENTIFIER) && (( inTypealiasAlias() || isTypeName(input.LT(1).getText()) ))) {
3477 alt23=1;
9ad3c628 3478 }
7a91a2e4
MK		 3479 else if ( (LA23_0==TYPEALIASTOK) ) {
3480 alt23=1;
9ad3c628
AM		 3481 }
3482
7a91a2e4 3483 switch (alt23) {
9ad3c628 3484 case 1 :
73511e67 3485 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:363:5: structOrVariantDeclaration
9ad3c628 3486 {
73511e67 3487 pushFollow(FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1639);
7a91a2e4 3488 structOrVariantDeclaration75=structOrVariantDeclaration();
9ad3c628
AM		 3489 state._fsp--;
3490 if (state.failed) return retval;
7a91a2e4 3491 if ( state.backtracking==0 ) adaptor.addChild(root_0, structOrVariantDeclaration75.getTree());
9ad3c628
AM		 3492
3493 }
3494 break;
3495
3496 default :
7a91a2e4 3497 if ( cnt23 >= 1 ) break loop23;
9ad3c628 3498 if (state.backtracking>0) {state.failed=true; return retval;}
7a91a2e4 3499 EarlyExitException eee = new EarlyExitException(23, input);
9ad3c628
AM		 3500 throw eee;
3501 }
7a91a2e4 3502 cnt23++;
9ad3c628
AM		 3503 }
3504
3505 }
3506
3507 retval.stop = input.LT(-1);
3508
3509 if ( state.backtracking==0 ) {
3510 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3511 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3512 }
3513 }
3514
3515 catch (RecognitionException e) {
3516 throw e;
3517 }
3518
3519 finally {
3520 // do for sure before leaving
3521 }
3522 return retval;
3523 }
3524 // $ANTLR end "structOrVariantDeclarationList"
3525
3526
3527 public static class structOrVariantDeclaration_return extends ParserRuleReturnScope {
3528 CommonTree tree;
3529 @Override
3530 public CommonTree getTree() { return tree; }
3531 };
3532
3533
3534 // $ANTLR start "structOrVariantDeclaration"
73511e67 3535 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:366:1: structOrVariantDeclaration : ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl ) TERM ;
9ad3c628
AM		 3536 public final CTFParser.structOrVariantDeclaration_return structOrVariantDeclaration() throws RecognitionException {
3537 CTFParser.structOrVariantDeclaration_return retval = new CTFParser.structOrVariantDeclaration_return();
3538 retval.start = input.LT(1);
3539
3540 CommonTree root_0 = null;
3541
7a91a2e4
MK		 3542 Token TERM80=null;
3543 ParserRuleReturnScope declarationSpecifiers76 =null;
3544 ParserRuleReturnScope declaratorList77 =null;
3545 ParserRuleReturnScope structOrVariantDeclaratorList78 =null;
3546 ParserRuleReturnScope typealiasDecl79 =null;
9ad3c628 3547
7a91a2e4 3548 CommonTree TERM80_tree=null;
9ad3c628 3549 RewriteRuleTokenStream stream_TERM=new RewriteRuleTokenStream(adaptor,"token TERM");
9ad3c628 3550 RewriteRuleSubtreeStream stream_typealiasDecl=new RewriteRuleSubtreeStream(adaptor,"rule typealiasDecl");
73511e67 3551 RewriteRuleSubtreeStream stream_declaratorList=new RewriteRuleSubtreeStream(adaptor,"rule declaratorList");
9ad3c628 3552 RewriteRuleSubtreeStream stream_structOrVariantDeclaratorList=new RewriteRuleSubtreeStream(adaptor,"rule structOrVariantDeclaratorList");
73511e67 3553 RewriteRuleSubtreeStream stream_declarationSpecifiers=new RewriteRuleSubtreeStream(adaptor,"rule declarationSpecifiers");
9ad3c628
AM		 3554
3555 try {
73511e67
AM		 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
9ad3c628 3558 {
73511e67 3559 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:368:3: ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl )
7a91a2e4
MK		 3560 int alt25=2;
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)) ) {
3563 alt25=1;
9ad3c628 3564 }
7a91a2e4
MK		 3565 else if ( (LA25_0==IDENTIFIER) && (( inTypealiasAlias() || isTypeName(input.LT(1).getText()) ))) {
3566 alt25=1;
9ad3c628 3567 }
7a91a2e4
MK		 3568 else if ( (LA25_0==TYPEALIASTOK) ) {
3569 alt25=2;
9ad3c628
AM		 3570 }
3571
3572 else {
3573 if (state.backtracking>0) {state.failed=true; return retval;}
3574 NoViableAltException nvae =
7a91a2e4 3575 new NoViableAltException("", 25, 0, input);
9ad3c628
AM		 3576 throw nvae;
3577 }
3578
7a91a2e4 3579 switch (alt25) {
9ad3c628 3580 case 1 :
73511e67 3581 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:369:7: ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) )
9ad3c628 3582 {
73511e67
AM		 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 ) )
9ad3c628 3585 {
73511e67 3586 pushFollow(FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1672);
7a91a2e4 3587 declarationSpecifiers76=declarationSpecifiers();
9ad3c628
AM		 3588 state._fsp--;
3589 if (state.failed) return retval;
7a91a2e4 3590 if ( state.backtracking==0 ) stream_declarationSpecifiers.add(declarationSpecifiers76.getTree());
73511e67 3591 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:371:10: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )
7a91a2e4
MK		 3592 int alt24=2;
3593 alt24 = dfa24.predict(input);
3594 switch (alt24) {
9ad3c628 3595 case 1 :
73511e67 3596 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:373:12: {...}? => declaratorList
9ad3c628
AM		 3597 {
3598 if ( !((inTypedef())) ) {
3599 if (state.backtracking>0) {state.failed=true; return retval;}
3600 throw new FailedPredicateException(input, "structOrVariantDeclaration", "inTypedef()");
3601 }
73511e67 3602 pushFollow(FOLLOW_declaratorList_in_structOrVariantDeclaration1713);
7a91a2e4 3603 declaratorList77=declaratorList();
9ad3c628
AM		 3604 state._fsp--;
3605 if (state.failed) return retval;
7a91a2e4 3606 if ( state.backtracking==0 ) stream_declaratorList.add(declaratorList77.getTree());
9ad3c628
AM		 3607 // AST REWRITE
3608 // elements: declaratorList, declarationSpecifiers
3609 // token labels:
3610 // rule labels: retval
3611 // token list labels:
3612 // rule list labels:
3613 // wildcard 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);
3617
3618 root_0 = (CommonTree)adaptor.nil();
73511e67 3619 // 374:14: -> ^( TYPEDEF declaratorList declarationSpecifiers )
9ad3c628 3620 {
73511e67 3621 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:374:17: ^( TYPEDEF declaratorList declarationSpecifiers )
9ad3c628
AM		 3622 {
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);
3628 }
3629
3630 }
3631
3632
3633 retval.tree = root_0;
3634 }
3635
3636 }
3637 break;
3638 case 2 :
73511e67 3639 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:375:14: structOrVariantDeclaratorList
9ad3c628 3640 {
73511e67 3641 pushFollow(FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1751);
7a91a2e4 3642 structOrVariantDeclaratorList78=structOrVariantDeclaratorList();
9ad3c628
AM		 3643 state._fsp--;
3644 if (state.failed) return retval;
7a91a2e4 3645 if ( state.backtracking==0 ) stream_structOrVariantDeclaratorList.add(structOrVariantDeclaratorList78.getTree());
9ad3c628 3646 // AST REWRITE
73511e67 3647 // elements: declarationSpecifiers, structOrVariantDeclaratorList
9ad3c628
AM		 3648 // token labels:
3649 // rule labels: retval
3650 // token list labels:
3651 // rule list labels:
3652 // wildcard 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);
3656
3657 root_0 = (CommonTree)adaptor.nil();
73511e67 3658 // 376:14: -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList )
9ad3c628 3659 {
73511e67 3660 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:376:17: ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList )
9ad3c628
AM		 3661 {
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);
3667 }
3668
3669 }
3670
3671
3672 retval.tree = root_0;
3673 }
3674
3675 }
3676 break;
3677
3678 }
3679
3680 }
3681
3682 }
3683 break;
3684 case 2 :
73511e67 3685 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:381:5: typealiasDecl
9ad3c628 3686 {
73511e67 3687 pushFollow(FOLLOW_typealiasDecl_in_structOrVariantDeclaration1810);
7a91a2e4 3688 typealiasDecl79=typealiasDecl();
9ad3c628
AM		 3689 state._fsp--;
3690 if (state.failed) return retval;
7a91a2e4 3691 if ( state.backtracking==0 ) stream_typealiasDecl.add(typealiasDecl79.getTree());
9ad3c628
AM		 3692 // AST REWRITE
3693 // elements: typealiasDecl
3694 // token labels:
3695 // rule labels: retval
3696 // token list labels:
3697 // rule list labels:
3698 // wildcard 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);
3702
3703 root_0 = (CommonTree)adaptor.nil();
73511e67 3704 // 381:19: -> typealiasDecl
9ad3c628
AM		 3705 {
3706 adaptor.addChild(root_0, stream_typealiasDecl.nextTree());
3707 }
3708
3709
3710 retval.tree = root_0;
3711 }
3712
3713 }
3714 break;
3715
3716 }
3717
73511e67 3718 TERM80=(Token)match(input,TERM,FOLLOW_TERM_in_structOrVariantDeclaration1822); if (state.failed) return retval;
7a91a2e4 3719 if ( state.backtracking==0 ) stream_TERM.add(TERM80);
9ad3c628
AM		 3720
3721 }
3722
3723 retval.stop = input.LT(-1);
3724
3725 if ( state.backtracking==0 ) {
3726 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3727 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3728 }
3729 }
3730
3731 catch (RecognitionException e) {
3732 throw e;
3733 }
3734
3735 finally {
3736 // do for sure before leaving
3737 }
3738 return retval;
3739 }
3740 // $ANTLR end "structOrVariantDeclaration"
3741
3742
3743 public static class specifierQualifierList_return extends ParserRuleReturnScope {
3744 CommonTree tree;
3745 @Override
3746 public CommonTree getTree() { return tree; }
3747 };
3748
3749
3750 // $ANTLR start "specifierQualifierList"
73511e67 3751 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:386:1: specifierQualifierList : ( typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
9ad3c628
AM		 3752 public final CTFParser.specifierQualifierList_return specifierQualifierList() throws RecognitionException {
3753 CTFParser.specifierQualifierList_return retval = new CTFParser.specifierQualifierList_return();
3754 retval.start = input.LT(1);
3755
3756 CommonTree root_0 = null;
3757
7a91a2e4
MK		 3758 ParserRuleReturnScope typeQualifier81 =null;
3759 ParserRuleReturnScope typeSpecifier82 =null;
9ad3c628
AM		 3760
3761 RewriteRuleSubtreeStream stream_typeSpecifier=new RewriteRuleSubtreeStream(adaptor,"rule typeSpecifier");
3762 RewriteRuleSubtreeStream stream_typeQualifier=new RewriteRuleSubtreeStream(adaptor,"rule typeQualifier");
3763
3764 try {
73511e67
AM		 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 )+
9ad3c628 3767 {
73511e67 3768 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:387:5: ( typeQualifier | typeSpecifier )+
7a91a2e4
MK		 3769 int cnt26=0;
3770 loop26:
9ad3c628 3771 while (true) {
7a91a2e4
MK		 3772 int alt26=3;
3773 int LA26_0 = input.LA(1);
3774 if ( (LA26_0==CONSTTOK) ) {
3775 alt26=1;
9ad3c628 3776 }
7a91a2e4
MK		 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)) ) {
3778 alt26=2;
9ad3c628 3779 }
7a91a2e4
MK		 3780 else if ( (LA26_0==IDENTIFIER) && (( inTypealiasAlias() || isTypeName(input.LT(1).getText()) ))) {
3781 alt26=2;
9ad3c628
AM		 3782 }
3783
7a91a2e4 3784 switch (alt26) {
9ad3c628 3785 case 1 :
73511e67 3786 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:387:6: typeQualifier
9ad3c628 3787 {
73511e67 3788 pushFollow(FOLLOW_typeQualifier_in_specifierQualifierList1836);
7a91a2e4 3789 typeQualifier81=typeQualifier();
9ad3c628
AM		 3790 state._fsp--;
3791 if (state.failed) return retval;
7a91a2e4 3792 if ( state.backtracking==0 ) stream_typeQualifier.add(typeQualifier81.getTree());
9ad3c628
AM		 3793 }
3794 break;
3795 case 2 :
73511e67 3796 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:387:22: typeSpecifier
9ad3c628 3797 {
73511e67 3798 pushFollow(FOLLOW_typeSpecifier_in_specifierQualifierList1840);
7a91a2e4 3799 typeSpecifier82=typeSpecifier();
9ad3c628
AM		 3800 state._fsp--;
3801 if (state.failed) return retval;
7a91a2e4 3802 if ( state.backtracking==0 ) stream_typeSpecifier.add(typeSpecifier82.getTree());
9ad3c628
AM		 3803 }
3804 break;
3805
3806 default :
7a91a2e4 3807 if ( cnt26 >= 1 ) break loop26;
9ad3c628 3808 if (state.backtracking>0) {state.failed=true; return retval;}
7a91a2e4 3809 EarlyExitException eee = new EarlyExitException(26, input);
9ad3c628
AM		 3810 throw eee;
3811 }
7a91a2e4 3812 cnt26++;
9ad3c628
AM		 3813 }
3814
3815 // AST REWRITE
73511e67 3816 // elements: typeQualifier, typeSpecifier
9ad3c628
AM		 3817 // token labels:
3818 // rule labels: retval
3819 // token list labels:
3820 // rule list labels:
3821 // wildcard 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);
3825
3826 root_0 = (CommonTree)adaptor.nil();
73511e67 3827 // 388:7: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
9ad3c628 3828 {
73511e67 3829 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:388:10: ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
9ad3c628
AM		 3830 {
3831 CommonTree root_1 = (CommonTree)adaptor.nil();
3832 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_SPECIFIER_LIST, "TYPE_SPECIFIER_LIST"), root_1);
73511e67 3833 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:388:32: ( typeQualifier )*
9ad3c628
AM		 3834 while ( stream_typeQualifier.hasNext() ) {
3835 adaptor.addChild(root_1, stream_typeQualifier.nextTree());
3836 }
3837 stream_typeQualifier.reset();
3838
73511e67 3839 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:388:47: ( typeSpecifier )*
9ad3c628
AM		 3840 while ( stream_typeSpecifier.hasNext() ) {
3841 adaptor.addChild(root_1, stream_typeSpecifier.nextTree());
3842 }
3843 stream_typeSpecifier.reset();
3844
3845 adaptor.addChild(root_0, root_1);
3846 }
3847
3848 }
3849
3850
3851 retval.tree = root_0;
3852 }
3853
3854 }
3855
3856 retval.stop = input.LT(-1);
3857
3858 if ( state.backtracking==0 ) {
3859 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3860 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3861 }
3862 }
3863
3864 catch (RecognitionException e) {
3865 throw e;
3866 }
3867
3868 finally {
3869 // do for sure before leaving
3870 }
3871 return retval;
3872 }
3873 // $ANTLR end "specifierQualifierList"
3874
3875
3876 public static class structOrVariantDeclaratorList_return extends ParserRuleReturnScope {
3877 CommonTree tree;
3878 @Override
3879 public CommonTree getTree() { return tree; }
3880 };
3881
3882
3883 // $ANTLR start "structOrVariantDeclaratorList"
73511e67 3884 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:391:1: structOrVariantDeclaratorList : structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ ) ;
9ad3c628
AM		 3885 public final CTFParser.structOrVariantDeclaratorList_return structOrVariantDeclaratorList() throws RecognitionException {
3886 CTFParser.structOrVariantDeclaratorList_return retval = new CTFParser.structOrVariantDeclaratorList_return();
3887 retval.start = input.LT(1);
3888
3889 CommonTree root_0 = null;
3890
7a91a2e4 3891 Token SEPARATOR84=null;
9ad3c628 3892 ParserRuleReturnScope structOrVariantDeclarator83 =null;
7a91a2e4 3893 ParserRuleReturnScope structOrVariantDeclarator85 =null;
9ad3c628 3894
7a91a2e4 3895 CommonTree SEPARATOR84_tree=null;
9ad3c628
AM		 3896 RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
3897 RewriteRuleSubtreeStream stream_structOrVariantDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule structOrVariantDeclarator");
3898
3899 try {
73511e67
AM		 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 )*
9ad3c628 3902 {
73511e67 3903 pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1873);
7a91a2e4 3904 structOrVariantDeclarator83=structOrVariantDeclarator();
9ad3c628
AM		 3905 state._fsp--;
3906 if (state.failed) return retval;
7a91a2e4 3907 if ( state.backtracking==0 ) stream_structOrVariantDeclarator.add(structOrVariantDeclarator83.getTree());
73511e67 3908 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:392:31: ( SEPARATOR structOrVariantDeclarator )*
7a91a2e4 3909 loop27:
9ad3c628 3910 while (true) {
7a91a2e4
MK		 3911 int alt27=2;
3912 int LA27_0 = input.LA(1);
3913 if ( (LA27_0==SEPARATOR) ) {
3914 alt27=1;
9ad3c628
AM		 3915 }
3916
7a91a2e4 3917 switch (alt27) {
9ad3c628 3918 case 1 :
73511e67 3919 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:392:32: SEPARATOR structOrVariantDeclarator
9ad3c628 3920 {
73511e67 3921 SEPARATOR84=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1876); if (state.failed) return retval;
7a91a2e4 3922 if ( state.backtracking==0 ) stream_SEPARATOR.add(SEPARATOR84);
9ad3c628 3923
73511e67 3924 pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1878);
7a91a2e4 3925 structOrVariantDeclarator85=structOrVariantDeclarator();
9ad3c628
AM		 3926 state._fsp--;
3927 if (state.failed) return retval;
7a91a2e4 3928 if ( state.backtracking==0 ) stream_structOrVariantDeclarator.add(structOrVariantDeclarator85.getTree());
9ad3c628
AM		 3929 }
3930 break;
3931
3932 default :
7a91a2e4 3933 break loop27;
9ad3c628
AM		 3934 }
3935 }
3936
3937 // AST REWRITE
3938 // elements: structOrVariantDeclarator
3939 // token labels:
3940 // rule labels: retval
3941 // token list labels:
3942 // rule list labels:
3943 // wildcard 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);
3947
3948 root_0 = (CommonTree)adaptor.nil();
73511e67 3949 // 393:7: -> ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ )
9ad3c628 3950 {
73511e67 3951 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:393:10: ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ )
9ad3c628
AM		 3952 {
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();
3957 }
3958 while ( stream_structOrVariantDeclarator.hasNext() ) {
3959 adaptor.addChild(root_1, stream_structOrVariantDeclarator.nextTree());
3960 }
3961 stream_structOrVariantDeclarator.reset();
3962
3963 adaptor.addChild(root_0, root_1);
3964 }
3965
3966 }
3967
3968
3969 retval.tree = root_0;
3970 }
3971
3972 }
3973
3974 retval.stop = input.LT(-1);
3975
3976 if ( state.backtracking==0 ) {
3977 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3978 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
3979 }
3980 }
3981
3982 catch (RecognitionException e) {
3983 throw e;
3984 }
3985
3986 finally {
3987 // do for sure before leaving
3988 }
3989 return retval;
3990 }
3991 // $ANTLR end "structOrVariantDeclaratorList"
3992
3993
3994 public static class structOrVariantDeclarator_return extends ParserRuleReturnScope {
3995 CommonTree tree;
3996 @Override
3997 public CommonTree getTree() { return tree; }
3998 };
3999
4000
4001 // $ANTLR start "structOrVariantDeclarator"
73511e67 4002 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:396:1: structOrVariantDeclarator : ( declarator ( COLON numberLiteral )? ) -> declarator ;
9ad3c628
AM		 4003 public final CTFParser.structOrVariantDeclarator_return structOrVariantDeclarator() throws RecognitionException {
4004 CTFParser.structOrVariantDeclarator_return retval = new CTFParser.structOrVariantDeclarator_return();
4005 retval.start = input.LT(1);
4006
4007 CommonTree root_0 = null;
4008
7a91a2e4
MK		 4009 Token COLON87=null;
4010 ParserRuleReturnScope declarator86 =null;
4011 ParserRuleReturnScope numberLiteral88 =null;
9ad3c628 4012
7a91a2e4 4013 CommonTree COLON87_tree=null;
9ad3c628
AM		 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");
4017
4018 try {
73511e67
AM		 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 )? )
9ad3c628 4021 {
73511e67
AM		 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 )?
9ad3c628 4024 {
73511e67 4025 pushFollow(FOLLOW_declarator_in_structOrVariantDeclarator1917);
7a91a2e4 4026 declarator86=declarator();
9ad3c628
AM		 4027 state._fsp--;
4028 if (state.failed) return retval;
7a91a2e4 4029 if ( state.backtracking==0 ) stream_declarator.add(declarator86.getTree());
73511e67 4030 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:399:17: ( COLON numberLiteral )?
7a91a2e4
MK		 4031 int alt28=2;
4032 int LA28_0 = input.LA(1);
4033 if ( (LA28_0==COLON) ) {
4034 alt28=1;
4035 }
4036 switch (alt28) {
9ad3c628 4037 case 1 :
73511e67 4038 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:399:18: COLON numberLiteral
9ad3c628 4039 {
73511e67 4040 COLON87=(Token)match(input,COLON,FOLLOW_COLON_in_structOrVariantDeclarator1920); if (state.failed) return retval;
7a91a2e4 4041 if ( state.backtracking==0 ) stream_COLON.add(COLON87);
9ad3c628 4042
73511e67 4043 pushFollow(FOLLOW_numberLiteral_in_structOrVariantDeclarator1922);
7a91a2e4 4044 numberLiteral88=numberLiteral();
9ad3c628
AM		 4045 state._fsp--;
4046 if (state.failed) return retval;
7a91a2e4 4047 if ( state.backtracking==0 ) stream_numberLiteral.add(numberLiteral88.getTree());
9ad3c628
AM		 4048 }
4049 break;
4050
4051 }
4052
4053 }
4054
4055 // AST REWRITE
4056 // elements: declarator
4057 // token labels:
4058 // rule labels: retval
4059 // token list labels:
4060 // rule list labels:
4061 // wildcard 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);
4065
4066 root_0 = (CommonTree)adaptor.nil();
73511e67 4067 // 399:41: -> declarator
9ad3c628
AM		 4068 {
4069 adaptor.addChild(root_0, stream_declarator.nextTree());
4070 }
4071
4072
4073 retval.tree = root_0;
4074 }
4075
4076 }
4077
4078 retval.stop = input.LT(-1);
4079
4080 if ( state.backtracking==0 ) {
4081 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4082 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4083 }
4084 }
4085
4086 catch (RecognitionException e) {
4087 throw e;
4088 }
4089
4090 finally {
4091 // do for sure before leaving
4092 }
4093 return retval;
4094 }
4095 // $ANTLR end "structOrVariantDeclarator"
4096
4097
4098 public static class variantSpecifier_return extends ParserRuleReturnScope {
4099 CommonTree tree;
4100 @Override
4101 public CommonTree getTree() { return tree; }
4102 };
4103
4104
4105 // $ANTLR start "variantSpecifier"
73511e67 4106 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:403:1: variantSpecifier : VARIANTTOK ( ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? ) ;
9ad3c628
AM		 4107 public final CTFParser.variantSpecifier_return variantSpecifier() throws RecognitionException {
4108 CTFParser.variantSpecifier_return retval = new CTFParser.variantSpecifier_return();
4109 retval.start = input.LT(1);
4110
4111 CommonTree root_0 = null;
4112
7a91a2e4
MK		 4113 Token VARIANTTOK89=null;
4114 ParserRuleReturnScope variantName90 =null;
4115 ParserRuleReturnScope variantTag91 =null;
4116 ParserRuleReturnScope variantBody92 =null;
9ad3c628 4117 ParserRuleReturnScope variantBody93 =null;
7a91a2e4
MK		 4118 ParserRuleReturnScope variantTag94 =null;
4119 ParserRuleReturnScope variantBody95 =null;
4120 ParserRuleReturnScope variantBody96 =null;
9ad3c628 4121
7a91a2e4 4122 CommonTree VARIANTTOK89_tree=null;
9ad3c628 4123 RewriteRuleTokenStream stream_VARIANTTOK=new RewriteRuleTokenStream(adaptor,"token VARIANTTOK");
9ad3c628 4124 RewriteRuleSubtreeStream stream_variantBody=new RewriteRuleSubtreeStream(adaptor,"rule variantBody");
73511e67
AM		 4125 RewriteRuleSubtreeStream stream_variantTag=new RewriteRuleSubtreeStream(adaptor,"rule variantTag");
4126 RewriteRuleSubtreeStream stream_variantName=new RewriteRuleSubtreeStream(adaptor,"rule variantName");
9ad3c628
AM		 4127
4128 try {
73511e67
AM		 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 )
9ad3c628 4131 {
73511e67 4132 VARIANTTOK89=(Token)match(input,VARIANTTOK,FOLLOW_VARIANTTOK_in_variantSpecifier1946); if (state.failed) return retval;
7a91a2e4 4133 if ( state.backtracking==0 ) stream_VARIANTTOK.add(VARIANTTOK89);
9ad3c628 4134
73511e67 4135 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:405:3: ( ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody )
7a91a2e4 4136 int alt31=3;
9ad3c628
AM		 4137 switch ( input.LA(1) ) {
4138 case IDENTIFIER:
4139 {
7a91a2e4 4140 alt31=1;
9ad3c628
AM		 4141 }
4142 break;
4143 case LT:
4144 {
7a91a2e4 4145 alt31=2;
9ad3c628
AM		 4146 }
4147 break;
4148 case LCURL:
4149 {
7a91a2e4 4150 alt31=3;
9ad3c628
AM		 4151 }
4152 break;
4153 default:
4154 if (state.backtracking>0) {state.failed=true; return retval;}
4155 NoViableAltException nvae =
7a91a2e4 4156 new NoViableAltException("", 31, 0, input);
9ad3c628
AM		 4157 throw nvae;
4158 }
7a91a2e4 4159 switch (alt31) {
9ad3c628 4160 case 1 :
73511e67 4161 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:406:5: ( variantName ( ( variantTag ( variantBody |) ) | variantBody ) )
9ad3c628 4162 {
73511e67
AM		 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 )
9ad3c628 4165 {
73511e67 4166 pushFollow(FOLLOW_variantName_in_variantSpecifier1964);
7a91a2e4 4167 variantName90=variantName();
9ad3c628
AM		 4168 state._fsp--;
4169 if (state.failed) return retval;
7a91a2e4 4170 if ( state.backtracking==0 ) stream_variantName.add(variantName90.getTree());
73511e67 4171 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:408:7: ( ( variantTag ( variantBody |) ) | variantBody )
7a91a2e4
MK		 4172 int alt30=2;
4173 int LA30_0 = input.LA(1);
4174 if ( (LA30_0==LT) ) {
4175 alt30=1;
9ad3c628 4176 }
7a91a2e4
MK		 4177 else if ( (LA30_0==LCURL) ) {
4178 alt30=2;
9ad3c628
AM		 4179 }
4180
4181 else {
4182 if (state.backtracking>0) {state.failed=true; return retval;}
4183 NoViableAltException nvae =
7a91a2e4 4184 new NoViableAltException("", 30, 0, input);
9ad3c628
AM		 4185 throw nvae;
4186 }
4187
7a91a2e4 4188 switch (alt30) {
9ad3c628 4189 case 1 :
73511e67 4190 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:409:9: ( variantTag ( variantBody |) )
9ad3c628 4191 {
73511e67
AM		 4192 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:409:9: ( variantTag ( variantBody |) )
4193 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:410:11: variantTag ( variantBody |)
9ad3c628 4194 {
73511e67 4195 pushFollow(FOLLOW_variantTag_in_variantSpecifier1994);
7a91a2e4 4196 variantTag91=variantTag();
9ad3c628
AM		 4197 state._fsp--;
4198 if (state.failed) return retval;
7a91a2e4 4199 if ( state.backtracking==0 ) stream_variantTag.add(variantTag91.getTree());
73511e67 4200 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:411:11: ( variantBody |)
7a91a2e4
MK		 4201 int alt29=2;
4202 int LA29_0 = input.LA(1);
4203 if ( (LA29_0==LCURL) ) {
9ad3c628
AM		 4204 switch ( input.LA(2) ) {
4205 case BOOLTOK:
4206 case CHARTOK:
4207 case COMPLEXTOK:
4208 case CONSTTOK:
4209 case DOUBLETOK:
4210 case ENUMTOK:
4211 case FLOATINGPOINTTOK:
4212 case FLOATTOK:
4213 case IMAGINARYTOK:
4214 case INTEGERTOK:
4215 case INTTOK:
4216 case LONGTOK:
4217 case SHORTTOK:
4218 case STRUCTTOK:
4219 case TYPEALIASTOK:
4220 case TYPEDEFTOK:
4221 case UNSIGNEDTOK:
4222 case VARIANTTOK:
4223 case VOIDTOK:
4224 {
7a91a2e4 4225 alt29=1;
9ad3c628
AM		 4226 }
4227 break;
4228 case SIGNEDTOK:
4229 {
7a91a2e4
MK		 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)) ) {
4232 alt29=1;
9ad3c628 4233 }
7a91a2e4
MK		 4234 else if ( (LA29_4==ASSIGNMENT||LA29_4==RCURL||LA29_4==SEPARATOR) ) {
4235 alt29=2;
9ad3c628
AM		 4236 }
4237
4238 else {
4239 if (state.backtracking>0) {state.failed=true; return retval;}
4240 int nvaeMark = input.mark();
4241 try {
4242 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
4243 input.consume();
4244 }
4245 NoViableAltException nvae =
7a91a2e4 4246 new NoViableAltException("", 29, 4, input);
9ad3c628
AM		 4247 throw nvae;
4248 } finally {
4249 input.rewind(nvaeMark);
4250 }
4251 }
4252
4253 }
4254 break;
4255 case STRINGTOK:
4256 {
7a91a2e4
MK		 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)) ) {
4259 alt29=1;
9ad3c628 4260 }
7a91a2e4
MK		 4261 else if ( (LA29_5==ASSIGNMENT||LA29_5==RCURL||LA29_5==SEPARATOR) ) {
4262 alt29=2;
9ad3c628
AM		 4263 }
4264
4265 else {
4266 if (state.backtracking>0) {state.failed=true; return retval;}
4267 int nvaeMark = input.mark();
4268 try {
4269 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
4270 input.consume();
4271 }
4272 NoViableAltException nvae =
7a91a2e4 4273 new NoViableAltException("", 29, 5, input);
9ad3c628
AM		 4274 throw nvae;
4275 } finally {
4276 input.rewind(nvaeMark);
4277 }
4278 }
4279
4280 }
4281 break;
4282 case IDENTIFIER:
4283 {
7a91a2e4
MK		 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)) ) {
4286 alt29=1;
9ad3c628 4287 }
7a91a2e4
MK		 4288 else if ( (LA29_6==ASSIGNMENT||LA29_6==RCURL||LA29_6==SEPARATOR) ) {
4289 alt29=2;
9ad3c628
AM		 4290 }
4291
4292 else {
4293 if (state.backtracking>0) {state.failed=true; return retval;}
4294 int nvaeMark = input.mark();
4295 try {
4296 for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
4297 input.consume();
4298 }
4299 NoViableAltException nvae =
7a91a2e4 4300 new NoViableAltException("", 29, 6, input);
9ad3c628
AM		 4301 throw nvae;
4302 } finally {
4303 input.rewind(nvaeMark);
4304 }
4305 }
4306
4307 }
4308 break;
4309 case ALIGNTOK:
4310 case EVENTTOK:
4311 case STRING_LITERAL:
4312 {
7a91a2e4 4313 alt29=2;
9ad3c628
AM		 4314 }
4315 break;
4316 default:
4317 if (state.backtracking>0) {state.failed=true; return retval;}
4318 int nvaeMark = input.mark();
4319 try {
4320 input.consume();
4321 NoViableAltException nvae =
7a91a2e4 4322 new NoViableAltException("", 29, 1, input);
9ad3c628
AM		 4323 throw nvae;
4324 } finally {
4325 input.rewind(nvaeMark);
4326 }
4327 }
4328 }
7a91a2e4
MK		 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)) ) {
4330 alt29=2;
9ad3c628
AM		 4331 }
4332
4333 else {
4334 if (state.backtracking>0) {state.failed=true; return retval;}
4335 NoViableAltException nvae =
7a91a2e4 4336 new NoViableAltException("", 29, 0, input);
9ad3c628
AM		 4337 throw nvae;
4338 }
4339
7a91a2e4 4340 switch (alt29) {
9ad3c628 4341 case 1 :
73511e67 4342 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:412:13: variantBody
9ad3c628 4343 {
73511e67 4344 pushFollow(FOLLOW_variantBody_in_variantSpecifier2020);
7a91a2e4 4345 variantBody92=variantBody();
9ad3c628
AM		 4346 state._fsp--;
4347 if (state.failed) return retval;
7a91a2e4 4348 if ( state.backtracking==0 ) stream_variantBody.add(variantBody92.getTree());
9ad3c628
AM		 4349 }
4350 break;
4351 case 2 :
73511e67 4352 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:415:11:
9ad3c628
AM		 4353 {
4354 }
4355 break;
4356
4357 }
4358
4359 }
4360
4361 }
4362 break;
4363 case 2 :
73511e67 4364 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:418:9: variantBody
9ad3c628 4365 {
73511e67 4366 pushFollow(FOLLOW_variantBody_in_variantSpecifier2088);
7a91a2e4 4367 variantBody93=variantBody();
9ad3c628
AM		 4368 state._fsp--;
4369 if (state.failed) return retval;
7a91a2e4 4370 if ( state.backtracking==0 ) stream_variantBody.add(variantBody93.getTree());
9ad3c628
AM		 4371 }
4372 break;
4373
4374 }
4375
4376 }
4377
4378 }
4379 break;
4380 case 2 :
73511e67 4381 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:421:5: ( variantTag variantBody )
9ad3c628 4382 {
73511e67
AM		 4383 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:421:5: ( variantTag variantBody )
4384 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:421:6: variantTag variantBody
9ad3c628 4385 {
73511e67 4386 pushFollow(FOLLOW_variantTag_in_variantSpecifier2109);
7a91a2e4 4387 variantTag94=variantTag();
9ad3c628
AM		 4388 state._fsp--;
4389 if (state.failed) return retval;
7a91a2e4 4390 if ( state.backtracking==0 ) stream_variantTag.add(variantTag94.getTree());
73511e67 4391 pushFollow(FOLLOW_variantBody_in_variantSpecifier2111);
7a91a2e4 4392 variantBody95=variantBody();
9ad3c628
AM		 4393 state._fsp--;
4394 if (state.failed) return retval;
7a91a2e4 4395 if ( state.backtracking==0 ) stream_variantBody.add(variantBody95.getTree());
9ad3c628
AM		 4396 }
4397
4398 }
4399 break;
4400 case 3 :
73511e67 4401 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:422:5: variantBody
9ad3c628 4402 {
73511e67 4403 pushFollow(FOLLOW_variantBody_in_variantSpecifier2118);
7a91a2e4 4404 variantBody96=variantBody();
9ad3c628
AM		 4405 state._fsp--;
4406 if (state.failed) return retval;
7a91a2e4 4407 if ( state.backtracking==0 ) stream_variantBody.add(variantBody96.getTree());
9ad3c628
AM		 4408 }
4409 break;
4410
4411 }
4412
4413 // AST REWRITE
73511e67 4414 // elements: variantTag, variantBody, variantName
9ad3c628
AM		 4415 // token labels:
4416 // rule labels: retval
4417 // token list labels:
4418 // rule list labels:
4419 // wildcard 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);
4423
4424 root_0 = (CommonTree)adaptor.nil();
73511e67 4425 // 423:5: -> ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? )
9ad3c628 4426 {
73511e67 4427 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:423:8: ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? )
9ad3c628
AM		 4428 {
4429 CommonTree root_1 = (CommonTree)adaptor.nil();
4430 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIANT, "VARIANT"), root_1);
73511e67 4431 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:423:18: ( variantName )?
9ad3c628
AM		 4432 if ( stream_variantName.hasNext() ) {
4433 adaptor.addChild(root_1, stream_variantName.nextTree());
4434 }
4435 stream_variantName.reset();
4436
73511e67 4437 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:423:31: ( variantTag )?
9ad3c628
AM		 4438 if ( stream_variantTag.hasNext() ) {
4439 adaptor.addChild(root_1, stream_variantTag.nextTree());
4440 }
4441 stream_variantTag.reset();
4442
73511e67 4443 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:423:43: ( variantBody )?
9ad3c628
AM		 4444 if ( stream_variantBody.hasNext() ) {
4445 adaptor.addChild(root_1, stream_variantBody.nextTree());
4446 }
4447 stream_variantBody.reset();
4448
4449 adaptor.addChild(root_0, root_1);
4450 }
4451
4452 }
4453
4454
4455 retval.tree = root_0;
4456 }
4457
4458 }
4459
4460 retval.stop = input.LT(-1);
4461
4462 if ( state.backtracking==0 ) {
4463 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4464 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4465 }
4466 }
4467
4468 catch (RecognitionException e) {
4469 throw e;
4470 }
4471
4472 finally {
4473 // do for sure before leaving
4474 }
4475 return retval;
4476 }
4477 // $ANTLR end "variantSpecifier"
4478
4479
4480 public static class variantName_return extends ParserRuleReturnScope {
4481 CommonTree tree;
4482 @Override
4483 public CommonTree getTree() { return tree; }
4484 };
4485
4486
4487 // $ANTLR start "variantName"
73511e67 4488 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:426:1: variantName : IDENTIFIER -> ^( VARIANT_NAME IDENTIFIER ) ;
9ad3c628
AM		 4489 public final CTFParser.variantName_return variantName() throws RecognitionException {
4490 CTFParser.variantName_return retval = new CTFParser.variantName_return();
4491 retval.start = input.LT(1);
4492
4493 CommonTree root_0 = null;
4494
7a91a2e4 4495 Token IDENTIFIER97=null;
9ad3c628 4496
7a91a2e4 4497 CommonTree IDENTIFIER97_tree=null;
9ad3c628
AM		 4498 RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
4499
4500 try {
73511e67
AM		 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
9ad3c628 4503 {
73511e67 4504 IDENTIFIER97=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variantName2150); if (state.failed) return retval;
7a91a2e4 4505 if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER97);
9ad3c628
AM		 4506
4507 // AST REWRITE
4508 // elements: IDENTIFIER
4509 // token labels:
4510 // rule labels: retval
4511 // token list labels:
4512 // rule list labels:
4513 // wildcard 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);
4517
4518 root_0 = (CommonTree)adaptor.nil();
73511e67 4519 // 427:16: -> ^( VARIANT_NAME IDENTIFIER )
9ad3c628 4520 {
73511e67 4521 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:427:19: ^( VARIANT_NAME IDENTIFIER )
9ad3c628
AM		 4522 {
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);
4527 }
4528
4529 }
4530
4531
4532 retval.tree = root_0;
4533 }
4534
4535 }
4536
4537 retval.stop = input.LT(-1);
4538
4539 if ( state.backtracking==0 ) {
4540 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4541 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4542 }
4543 }
4544
4545 catch (RecognitionException e) {
4546 throw e;
4547 }
4548
4549 finally {
4550 // do for sure before leaving
4551 }
4552 return retval;
4553 }
4554 // $ANTLR end "variantName"
4555
4556
4557 public static class variantBody_return extends ParserRuleReturnScope {
4558 CommonTree tree;
4559 @Override
4560 public CommonTree getTree() { return tree; }
4561 };
4562
4563
4564 // $ANTLR start "variantBody"
73511e67 4565 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:430:1: variantBody : LCURL structOrVariantDeclarationList RCURL -> ^( VARIANT_BODY structOrVariantDeclarationList ) ;
9ad3c628
AM		 4566 public final CTFParser.variantBody_return variantBody() throws RecognitionException {
4567 Symbols_stack.push(new Symbols_scope());
4568
4569 CTFParser.variantBody_return retval = new CTFParser.variantBody_return();
4570 retval.start = input.LT(1);
4571
4572 CommonTree root_0 = null;
4573
7a91a2e4
MK		 4574 Token LCURL98=null;
4575 Token RCURL100=null;
4576 ParserRuleReturnScope structOrVariantDeclarationList99 =null;
9ad3c628 4577
7a91a2e4
MK		 4578 CommonTree LCURL98_tree=null;
4579 CommonTree RCURL100_tree=null;
9ad3c628
AM		 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");
4583
4584
4585 Symbols_stack.peek().types = new HashSet<String>();
4586
4587 try {
73511e67
AM		 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
9ad3c628 4590 {
73511e67 4591 LCURL98=(Token)match(input,LCURL,FOLLOW_LCURL_in_variantBody2181); if (state.failed) return retval;
7a91a2e4 4592 if ( state.backtracking==0 ) stream_LCURL.add(LCURL98);
9ad3c628 4593
73511e67 4594 pushFollow(FOLLOW_structOrVariantDeclarationList_in_variantBody2183);
7a91a2e4 4595 structOrVariantDeclarationList99=structOrVariantDeclarationList();
9ad3c628
AM		 4596 state._fsp--;
4597 if (state.failed) return retval;
7a91a2e4 4598 if ( state.backtracking==0 ) stream_structOrVariantDeclarationList.add(structOrVariantDeclarationList99.getTree());
73511e67 4599 RCURL100=(Token)match(input,RCURL,FOLLOW_RCURL_in_variantBody2185); if (state.failed) return retval;
7a91a2e4 4600 if ( state.backtracking==0 ) stream_RCURL.add(RCURL100);
9ad3c628
AM		 4601
4602 // AST REWRITE
4603 // elements: structOrVariantDeclarationList
4604 // token labels:
4605 // rule labels: retval
4606 // token list labels:
4607 // rule list labels:
4608 // wildcard 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);
4612
4613 root_0 = (CommonTree)adaptor.nil();
73511e67 4614 // 436:7: -> ^( VARIANT_BODY structOrVariantDeclarationList )
9ad3c628 4615 {
73511e67 4616 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:436:10: ^( VARIANT_BODY structOrVariantDeclarationList )
9ad3c628
AM		 4617 {
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);
4622 }
4623
4624 }
4625
4626
4627 retval.tree = root_0;
4628 }
4629
4630 }
4631
4632 retval.stop = input.LT(-1);
4633
4634 if ( state.backtracking==0 ) {
4635 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4636 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4637 }
4638 }
4639
4640 catch (RecognitionException e) {
4641 throw e;
4642 }
4643
4644 finally {
4645 // do for sure before leaving
4646 Symbols_stack.pop();
4647
4648 }
4649 return retval;
4650 }
4651 // $ANTLR end "variantBody"
4652
4653
4654 public static class variantTag_return extends ParserRuleReturnScope {
4655 CommonTree tree;
4656 @Override
4657 public CommonTree getTree() { return tree; }
4658 };
4659
4660
4661 // $ANTLR start "variantTag"
73511e67 4662 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:439:1: variantTag : LT IDENTIFIER GT -> ^( VARIANT_TAG IDENTIFIER ) ;
9ad3c628
AM		 4663 public final CTFParser.variantTag_return variantTag() throws RecognitionException {
4664 CTFParser.variantTag_return retval = new CTFParser.variantTag_return();
4665 retval.start = input.LT(1);
4666
4667 CommonTree root_0 = null;
4668
7a91a2e4
MK		 4669 Token LT101=null;
4670 Token IDENTIFIER102=null;
4671 Token GT103=null;
9ad3c628 4672
7a91a2e4
MK		 4673 CommonTree LT101_tree=null;
4674 CommonTree IDENTIFIER102_tree=null;
4675 CommonTree GT103_tree=null;
9ad3c628
AM		 4676 RewriteRuleTokenStream stream_LT=new RewriteRuleTokenStream(adaptor,"token LT");
4677 RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
73511e67 4678 RewriteRuleTokenStream stream_GT=new RewriteRuleTokenStream(adaptor,"token GT");
9ad3c628
AM		 4679
4680 try {
73511e67
AM		 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
9ad3c628 4683 {
73511e67 4684 LT101=(Token)match(input,LT,FOLLOW_LT_in_variantTag2212); if (state.failed) return retval;
7a91a2e4 4685 if ( state.backtracking==0 ) stream_LT.add(LT101);
9ad3c628 4686
73511e67 4687 IDENTIFIER102=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variantTag2214); if (state.failed) return retval;
7a91a2e4 4688 if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER102);
9ad3c628 4689
73511e67 4690 GT103=(Token)match(input,GT,FOLLOW_GT_in_variantTag2216); if (state.failed) return retval;
7a91a2e4 4691 if ( state.backtracking==0 ) stream_GT.add(GT103);
9ad3c628
AM		 4692
4693 // AST REWRITE
4694 // elements: IDENTIFIER
4695 // token labels:
4696 // rule labels: retval
4697 // token list labels:
4698 // rule list labels:
4699 // wildcard 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);
4703
4704 root_0 = (CommonTree)adaptor.nil();
73511e67 4705 // 440:22: -> ^( VARIANT_TAG IDENTIFIER )
9ad3c628 4706 {
73511e67 4707 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:440:25: ^( VARIANT_TAG IDENTIFIER )
9ad3c628
AM		 4708 {
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);
4713 }
4714
4715 }
4716
4717
4718 retval.tree = root_0;
4719 }
4720
4721 }
4722
4723 retval.stop = input.LT(-1);
4724
4725 if ( state.backtracking==0 ) {
4726 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
4727 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
4728 }
4729 }
4730
4731 catch (RecognitionException e) {
4732 throw e;
4733 }
4734
4735 finally {
4736 // do for sure before leaving
4737 }
4738 return retval;
4739 }
4740 // $ANTLR end "variantTag"
4741
4742
4743 public static class enumSpecifier_return extends ParserRuleReturnScope {
4744 CommonTree tree;
4745 @Override
4746 public CommonTree getTree() { return tree; }
4747 };
4748
4749
4750 // $ANTLR start "enumSpecifier"
73511e67 4751 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:443:1: enumSpecifier : ENUMTOK ( ( enumName ( enumContainerType enumBody | enumBody |) ) | ( enumContainerType enumBody | enumBody ) ) -> ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? ) ;
9ad3c628
AM		 4752 public final CTFParser.enumSpecifier_return enumSpecifier() throws RecognitionException {
4753 CTFParser.enumSpecifier_return retval = new CTFParser.enumSpecifier_return();
4754 retval.start = input.LT(1);
4755
4756 CommonTree root_0 = null;
4757
7a91a2e4
MK		 4758 Token ENUMTOK104=null;
4759 ParserRuleReturnScope enumName105 =null;
4760 ParserRuleReturnScope enumContainerType106 =null;
4761 ParserRuleReturnScope enumBody107 =null;
9ad3c628 4762 ParserRuleReturnScope enumBody108 =null;
7a91a2e4
MK		 4763 ParserRuleReturnScope enumContainerType109 =null;
4764 ParserRuleReturnScope enumBody110 =null;
4765 ParserRuleReturnScope enumBody111 =null;
9ad3c628 4766
7a91a2e4 4767 CommonTree ENUMTOK104_tree=null;
9ad3c628 4768 RewriteRuleTokenStream stream_ENUMTOK=new RewriteRuleTokenStream(adaptor,"token ENUMTOK");
73511e67 4769 RewriteRuleSubtreeStream stream_enumBody=new RewriteRuleSubtreeStream(adaptor,"rule enumBody");
9ad3c628
AM		 4770 RewriteRuleSubtreeStream stream_enumName=new RewriteRuleSubtreeStream(adaptor,"rule enumName");
4771 RewriteRuleSubtreeStream stream_enumContainerType=new RewriteRuleSubtreeStream(adaptor,"rule enumContainerType");
9ad3c628
AM		 4772
4773 try {
73511e67
AM		 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 ) )
9ad3c628 4776 {
73511e67 4777 ENUMTOK104=(Token)match(input,ENUMTOK,FOLLOW_ENUMTOK_in_enumSpecifier2237); if (state.failed) return retval;
7a91a2e4 4778 if ( state.backtracking==0 ) stream_ENUMTOK.add(ENUMTOK104);
9ad3c628 4779
73511e67 4780 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:445:5: ( ( enumName ( enumContainerType enumBody | enumBody |) ) | ( enumContainerType enumBody | enumBody ) )
7a91a2e4
MK		 4781 int alt34=2;
4782 int LA34_0 = input.LA(1);
4783 if ( (LA34_0==IDENTIFIER) ) {
4784 alt34=1;
9ad3c628 4785 }
7a91a2e4
MK		 4786 else if ( (LA34_0==COLON||LA34_0==LCURL) ) {
4787 alt34=2;
9ad3c628
AM		 4788 }
4789
4790 else {
4791 if (state.backtracking>0) {state.failed=true; return retval;}
4792 NoViableAltException nvae =
7a91a2e4 4793 new NoViableAltException("", 34, 0, input);
9ad3c628
AM		 4794 throw nvae;
4795 }
4796
7a91a2e4 4797 switch (alt34) {
9ad3c628 4798 case 1 :
73511e67 4799 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:447:9: ( enumName ( enumContainerType enumBody | enumBody |) )
9ad3c628 4800 {
73511e67
AM		 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 |)
9ad3c628 4803 {
73511e67 4804 pushFollow(FOLLOW_enumName_in_enumSpecifier2276);
7a91a2e4 4805 enumName105=enumName();
9ad3c628
AM		 4806 state._fsp--;
4807 if (state.failed) return retval;
7a91a2e4 4808 if ( state.backtracking==0 ) stream_enumName.add(enumName105.getTree());
73511e67 4809 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:449:13: ( enumContainerType enumBody | enumBody |)
7a91a2e4 4810 int alt32=3;
9ad3c628
AM		 4811 switch ( input.LA(1) ) {
4812 case COLON:
4813 {
7a91a2e4 4814 alt32=1;
9ad3c628
AM		 4815 }
4816 break;
4817 case LCURL:
4818 {
7a91a2e4 4819 alt32=2;
9ad3c628
AM		 4820 }
4821 break;
4822 case EOF:
4823 case BOOLTOK:
4824 case CHARTOK:
4825 case COMPLEXTOK:
4826 case CONSTTOK:
4827 case DOUBLETOK:
4828 case ENUMTOK:
4829 case FLOATINGPOINTTOK:
4830 case FLOATTOK:
4831 case IDENTIFIER:
4832 case IMAGINARYTOK:
4833 case INTEGERTOK:
4834 case INTTOK:
4835 case LONGTOK:
4836 case LPAREN:
4837 case POINTER:
4838 case SHORTTOK:
4839 case SIGNEDTOK:
4840 case STRINGTOK:
4841 case STRUCTTOK:
4842 case TERM:
4843 case TYPEDEFTOK:
4844 case TYPE_ASSIGNMENT:
4845 case UNSIGNEDTOK:
4846 case VARIANTTOK:
4847 case VOIDTOK:
4848 {
7a91a2e4 4849 alt32=3;
9ad3c628
AM		 4850 }
4851 break;
4852 default:
4853 if (state.backtracking>0) {state.failed=true; return retval;}
4854 NoViableAltException nvae =
7a91a2e4 4855 new NoViableAltException("", 32, 0, input);
9ad3c628
AM		 4856 throw nvae;
4857 }
7a91a2e4 4858 switch (alt32) {
9ad3c628 4859 case 1 :
73511e67 4860 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:450:17: enumContainerType enumBody
9ad3c628 4861 {
73511e67 4862 pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2308);
7a91a2e4 4863 enumContainerType106=enumContainerType();
9ad3c628
AM		 4864 state._fsp--;
4865 if (state.failed) return retval;
7a91a2e4 4866 if ( state.backtracking==0 ) stream_enumContainerType.add(enumContainerType106.getTree());
73511e67 4867 pushFollow(FOLLOW_enumBody_in_enumSpecifier2310);
7a91a2e4 4868 enumBody107=enumBody();
9ad3c628
AM		 4869 state._fsp--;
4870 if (state.failed) return retval;
7a91a2e4 4871 if ( state.backtracking==0 ) stream_enumBody.add(enumBody107.getTree());
9ad3c628
AM		 4872 }
4873 break;
4874 case 2 :
73511e67 4875 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:452:17: enumBody
9ad3c628 4876 {
73511e67 4877 pushFollow(FOLLOW_enumBody_in_enumSpecifier2340);
7a91a2e4 4878 enumBody108=enumBody();
9ad3c628
AM		 4879 state._fsp--;
4880 if (state.failed) return retval;
7a91a2e4 4881 if ( state.backtracking==0 ) stream_enumBody.add(enumBody108.getTree());
9ad3c628
AM		 4882 }
4883 break;
4884 case 3 :
73511e67 4885 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:455:13:
9ad3c628
AM		 4886 {
4887 }
4888 break;
4889
4890 }
4891
4892 }
4893
4894 }
4895 break;
4896 case 2 :
73511e67 4897 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:459:9: ( enumContainerType enumBody | enumBody )
9ad3c628 4898 {
73511e67 4899 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:459:9: ( enumContainerType enumBody | enumBody )
7a91a2e4
MK		 4900 int alt33=2;
4901 int LA33_0 = input.LA(1);
4902 if ( (LA33_0==COLON) ) {
4903 alt33=1;
9ad3c628 4904 }
7a91a2e4
MK		 4905 else if ( (LA33_0==LCURL) ) {
4906 alt33=2;
9ad3c628
AM		 4907 }
4908
4909 else {
4910 if (state.backtracking>0) {state.failed=true; return retval;}
4911 NoViableAltException nvae =
7a91a2e4 4912 new NoViableAltException("", 33, 0, input);
9ad3c628
AM		 4913 throw nvae;
4914 }
4915
7a91a2e4 4916 switch (alt33) {
9ad3c628 4917 case 1 :
73511e67 4918 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:460:13: enumContainerType enumBody
9ad3c628 4919 {
73511e67 4920 pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2432);
7a91a2e4 4921 enumContainerType109=enumContainerType();
9ad3c628
AM		 4922 state._fsp--;
4923 if (state.failed) return retval;
7a91a2e4 4924 if ( state.backtracking==0 ) stream_enumContainerType.add(enumContainerType109.getTree());
73511e67 4925 pushFollow(FOLLOW_enumBody_in_enumSpecifier2434);
7a91a2e4 4926 enumBody110=enumBody();
9ad3c628
AM		 4927 state._fsp--;
4928 if (state.failed) return retval;
7a91a2e4 4929 if ( state.backtracking==0 ) stream_enumBody.add(enumBody110.getTree());
9ad3c628
AM		 4930 }
4931 break;
4932 case 2 :
73511e67 4933 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:462:13: enumBody
9ad3c628 4934 {
73511e67 4935 pushFollow(FOLLOW_enumBody_in_enumSpecifier2458);
7a91a2e4 4936 enumBody111=enumBody();
9ad3c628
AM		 4937 state._fsp--;
4938 if (state.failed) return retval;
7a91a2e4 4939 if ( state.backtracking==0 ) stream_enumBody.add(enumBody111.getTree());
9ad3c628
AM		 4940 }
4941 break;
4942
4943 }
4944
4945 }
4946 break;
4947
4948 }
4949
4950 // AST REWRITE
73511e67 4951 // elements: enumName, enumBody, enumContainerType
9ad3c628
AM		 4952 // token labels:
4953 // rule labels: retval
4954 // token list labels:
4955 // rule list labels:
4956 // wildcard 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);
4960
4961 root_0 = (CommonTree)adaptor.nil();
73511e67 4962 // 464:7: -> ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? )
9ad3c628 4963 {
73511e67 4964 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:464:10: ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? )
9ad3c628
AM		 4965 {
4966 CommonTree root_1 = (CommonTree)adaptor.nil();
4967 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ENUM, "ENUM"), root_1);
73511e67 4968 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:464:17: ( enumName )?
9ad3c628
AM		 4969 if ( stream_enumName.hasNext() ) {
4970 adaptor.addChild(root_1, stream_enumName.nextTree());
4971 }
4972 stream_enumName.reset();
4973
73511e67 4974 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:464:27: ( enumContainerType )?
9ad3c628
AM		 4975 if ( stream_enumContainerType.hasNext() ) {
4976 adaptor.addChild(root_1, stream_enumContainerType.nextTree());
4977 }
4978 stream_enumContainerType.reset();
4979
73511e67 4980 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:464:46: ( enumBody )?
9ad3c628
AM		 4981 if ( stream_enumBody.hasNext() ) {
4982 adaptor.addChild(root_1, stream_enumBody.nextTree());
4983 }
4984 stream_enumBody.reset();
4985
4986 adaptor.addChild(root_0, root_1);
4987 }
4988
4989 }
4990
4991
4992 retval.tree = root_0;
4993 }
4994
4995 }
4996
4997 retval.stop = input.LT(-1);
4998
4999 if ( state.backtracking==0 ) {
5000 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5001 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5002 }
5003 }
5004
5005 catch (RecognitionException e) {
5006 throw e;
5007 }
5008
5009 finally {
5010 // do for sure before leaving
5011 }
5012 return retval;
5013 }
5014 // $ANTLR end "enumSpecifier"
5015
5016
5017 public static class enumName_return extends ParserRuleReturnScope {
5018 CommonTree tree;
5019 @Override
5020 public CommonTree getTree() { return tree; }
5021 };
5022
5023
5024 // $ANTLR start "enumName"
73511e67 5025 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:467:1: enumName : IDENTIFIER -> ^( ENUM_NAME IDENTIFIER ) ;
9ad3c628
AM		 5026 public final CTFParser.enumName_return enumName() throws RecognitionException {
5027 CTFParser.enumName_return retval = new CTFParser.enumName_return();
5028 retval.start = input.LT(1);
5029
5030 CommonTree root_0 = null;
5031
7a91a2e4 5032 Token IDENTIFIER112=null;
9ad3c628 5033
7a91a2e4 5034 CommonTree IDENTIFIER112_tree=null;
9ad3c628
AM		 5035 RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
5036
5037 try {
73511e67
AM		 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
9ad3c628 5040 {
73511e67 5041 IDENTIFIER112=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumName2502); if (state.failed) return retval;
7a91a2e4 5042 if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER112);
9ad3c628
AM		 5043
5044 // AST REWRITE
5045 // elements: IDENTIFIER
5046 // token labels:
5047 // rule labels: retval
5048 // token list labels:
5049 // rule list labels:
5050 // wildcard 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);
5054
5055 root_0 = (CommonTree)adaptor.nil();
73511e67 5056 // 468:16: -> ^( ENUM_NAME IDENTIFIER )
9ad3c628 5057 {
73511e67 5058 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:468:19: ^( ENUM_NAME IDENTIFIER )
9ad3c628
AM		 5059 {
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);
5064 }
5065
5066 }
5067
5068
5069 retval.tree = root_0;
5070 }
5071
5072 }
5073
5074 retval.stop = input.LT(-1);
5075
5076 if ( state.backtracking==0 ) {
5077 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5078 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5079 }
5080 }
5081
5082 catch (RecognitionException e) {
5083 throw e;
5084 }
5085
5086 finally {
5087 // do for sure before leaving
5088 }
5089 return retval;
5090 }
5091 // $ANTLR end "enumName"
5092
5093
5094 public static class enumBody_return extends ParserRuleReturnScope {
5095 CommonTree tree;
5096 @Override
5097 public CommonTree getTree() { return tree; }
5098 };
5099
5100
5101 // $ANTLR start "enumBody"
73511e67 5102 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:471:1: enumBody : LCURL enumeratorList ( SEPARATOR )? RCURL -> ^( ENUM_BODY enumeratorList ) ;
9ad3c628
AM		 5103 public final CTFParser.enumBody_return enumBody() throws RecognitionException {
5104 CTFParser.enumBody_return retval = new CTFParser.enumBody_return();
5105 retval.start = input.LT(1);
5106
5107 CommonTree root_0 = null;
5108
7a91a2e4
MK		 5109 Token LCURL113=null;
5110 Token SEPARATOR115=null;
5111 Token RCURL116=null;
5112 ParserRuleReturnScope enumeratorList114 =null;
9ad3c628 5113
7a91a2e4
MK		 5114 CommonTree LCURL113_tree=null;
5115 CommonTree SEPARATOR115_tree=null;
5116 CommonTree RCURL116_tree=null;
9ad3c628 5117 RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
73511e67 5118 RewriteRuleTokenStream stream_LCURL=new RewriteRuleTokenStream(adaptor,"token LCURL");
9ad3c628
AM		 5119 RewriteRuleTokenStream stream_RCURL=new RewriteRuleTokenStream(adaptor,"token RCURL");
5120 RewriteRuleSubtreeStream stream_enumeratorList=new RewriteRuleSubtreeStream(adaptor,"rule enumeratorList");
5121
5122 try {
73511e67
AM		 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
9ad3c628 5125 {
73511e67 5126 LCURL113=(Token)match(input,LCURL,FOLLOW_LCURL_in_enumBody2523); if (state.failed) return retval;
7a91a2e4 5127 if ( state.backtracking==0 ) stream_LCURL.add(LCURL113);
9ad3c628 5128
73511e67 5129 pushFollow(FOLLOW_enumeratorList_in_enumBody2525);
7a91a2e4 5130 enumeratorList114=enumeratorList();
9ad3c628
AM		 5131 state._fsp--;
5132 if (state.failed) return retval;
7a91a2e4 5133 if ( state.backtracking==0 ) stream_enumeratorList.add(enumeratorList114.getTree());
73511e67 5134 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:472:26: ( SEPARATOR )?
7a91a2e4
MK		 5135 int alt35=2;
5136 int LA35_0 = input.LA(1);
5137 if ( (LA35_0==SEPARATOR) ) {
5138 alt35=1;
5139 }
5140 switch (alt35) {
9ad3c628 5141 case 1 :
73511e67 5142 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:472:26: SEPARATOR
9ad3c628 5143 {
73511e67 5144 SEPARATOR115=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_enumBody2527); if (state.failed) return retval;
7a91a2e4 5145 if ( state.backtracking==0 ) stream_SEPARATOR.add(SEPARATOR115);
9ad3c628
AM		 5146
5147 }
5148 break;
5149
5150 }
5151
73511e67 5152 RCURL116=(Token)match(input,RCURL,FOLLOW_RCURL_in_enumBody2530); if (state.failed) return retval;
7a91a2e4 5153 if ( state.backtracking==0 ) stream_RCURL.add(RCURL116);
9ad3c628
AM		 5154
5155 // AST REWRITE
5156 // elements: enumeratorList
5157 // token labels:
5158 // rule labels: retval
5159 // token list labels:
5160 // rule list labels:
5161 // wildcard 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);
5165
5166 root_0 = (CommonTree)adaptor.nil();
73511e67 5167 // 472:43: -> ^( ENUM_BODY enumeratorList )
9ad3c628 5168 {
73511e67 5169 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:472:46: ^( ENUM_BODY enumeratorList )
9ad3c628
AM		 5170 {
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);
5175 }
5176
5177 }
5178
5179
5180 retval.tree = root_0;
5181 }
5182
5183 }
5184
5185 retval.stop = input.LT(-1);
5186
5187 if ( state.backtracking==0 ) {
5188 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5189 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5190 }
5191 }
5192
5193 catch (RecognitionException e) {
5194 throw e;
5195 }
5196
5197 finally {
5198 // do for sure before leaving
5199 }
5200 return retval;
5201 }
5202 // $ANTLR end "enumBody"
5203
5204
5205 public static class enumContainerType_return extends ParserRuleReturnScope {
5206 CommonTree tree;
5207 @Override
5208 public CommonTree getTree() { return tree; }
5209 };
5210
5211
5212 // $ANTLR start "enumContainerType"
73511e67 5213 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:475:1: enumContainerType : COLON declarationSpecifiers -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers ) ;
9ad3c628
AM		 5214 public final CTFParser.enumContainerType_return enumContainerType() throws RecognitionException {
5215 CTFParser.enumContainerType_return retval = new CTFParser.enumContainerType_return();
5216 retval.start = input.LT(1);
5217
5218 CommonTree root_0 = null;
5219
7a91a2e4
MK		 5220 Token COLON117=null;
5221 ParserRuleReturnScope declarationSpecifiers118 =null;
9ad3c628 5222
7a91a2e4 5223 CommonTree COLON117_tree=null;
9ad3c628
AM		 5224 RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
5225 RewriteRuleSubtreeStream stream_declarationSpecifiers=new RewriteRuleSubtreeStream(adaptor,"rule declarationSpecifiers");
5226
5227 try {
73511e67
AM		 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
9ad3c628 5230 {
73511e67 5231 COLON117=(Token)match(input,COLON,FOLLOW_COLON_in_enumContainerType2551); if (state.failed) return retval;
7a91a2e4 5232 if ( state.backtracking==0 ) stream_COLON.add(COLON117);
9ad3c628 5233
73511e67 5234 pushFollow(FOLLOW_declarationSpecifiers_in_enumContainerType2553);
7a91a2e4 5235 declarationSpecifiers118=declarationSpecifiers();
9ad3c628
AM		 5236 state._fsp--;
5237 if (state.failed) return retval;
7a91a2e4 5238 if ( state.backtracking==0 ) stream_declarationSpecifiers.add(declarationSpecifiers118.getTree());
9ad3c628
AM		 5239 // AST REWRITE
5240 // elements: declarationSpecifiers
5241 // token labels:
5242 // rule labels: retval
5243 // token list labels:
5244 // rule list labels:
5245 // wildcard 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);
5249
5250 root_0 = (CommonTree)adaptor.nil();
73511e67 5251 // 476:33: -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
9ad3c628 5252 {
73511e67 5253 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:476:36: ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
9ad3c628
AM		 5254 {
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);
5259 }
5260
5261 }
5262
5263
5264 retval.tree = root_0;
5265 }
5266
5267 }
5268
5269 retval.stop = input.LT(-1);
5270
5271 if ( state.backtracking==0 ) {
5272 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5273 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5274 }
5275 }
5276
5277 catch (RecognitionException e) {
5278 throw e;
5279 }
5280
5281 finally {
5282 // do for sure before leaving
5283 }
5284 return retval;
5285 }
5286 // $ANTLR end "enumContainerType"
5287
5288
5289 public static class enumeratorList_return extends ParserRuleReturnScope {
5290 CommonTree tree;
5291 @Override
5292 public CommonTree getTree() { return tree; }
5293 };
5294
5295
5296 // $ANTLR start "enumeratorList"
73511e67 5297 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:479:1: enumeratorList : enumerator ( SEPARATOR enumerator )* -> ( ^( ENUM_ENUMERATOR enumerator ) )+ ;
9ad3c628
AM		 5298 public final CTFParser.enumeratorList_return enumeratorList() throws RecognitionException {
5299 CTFParser.enumeratorList_return retval = new CTFParser.enumeratorList_return();
5300 retval.start = input.LT(1);
5301
5302 CommonTree root_0 = null;
5303
7a91a2e4 5304 Token SEPARATOR120=null;
9ad3c628 5305 ParserRuleReturnScope enumerator119 =null;
7a91a2e4 5306 ParserRuleReturnScope enumerator121 =null;
9ad3c628 5307
7a91a2e4 5308 CommonTree SEPARATOR120_tree=null;
9ad3c628
AM		 5309 RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
5310 RewriteRuleSubtreeStream stream_enumerator=new RewriteRuleSubtreeStream(adaptor,"rule enumerator");
5311
5312 try {
73511e67
AM		 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 )*
9ad3c628 5315 {
73511e67 5316 pushFollow(FOLLOW_enumerator_in_enumeratorList2574);
7a91a2e4 5317 enumerator119=enumerator();
9ad3c628
AM		 5318 state._fsp--;
5319 if (state.failed) return retval;
7a91a2e4 5320 if ( state.backtracking==0 ) stream_enumerator.add(enumerator119.getTree());
73511e67 5321 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:480:16: ( SEPARATOR enumerator )*
7a91a2e4 5322 loop36:
9ad3c628 5323 while (true) {
7a91a2e4
MK		 5324 int alt36=2;
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) ) {
5329 alt36=1;
9ad3c628
AM		 5330 }
5331
5332 }
5333
7a91a2e4 5334 switch (alt36) {
9ad3c628 5335 case 1 :
73511e67 5336 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:480:17: SEPARATOR enumerator
9ad3c628 5337 {
73511e67 5338 SEPARATOR120=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_enumeratorList2577); if (state.failed) return retval;
7a91a2e4 5339 if ( state.backtracking==0 ) stream_SEPARATOR.add(SEPARATOR120);
9ad3c628 5340
73511e67 5341 pushFollow(FOLLOW_enumerator_in_enumeratorList2579);
7a91a2e4 5342 enumerator121=enumerator();
9ad3c628
AM		 5343 state._fsp--;
5344 if (state.failed) return retval;
7a91a2e4 5345 if ( state.backtracking==0 ) stream_enumerator.add(enumerator121.getTree());
9ad3c628
AM		 5346 }
5347 break;
5348
5349 default :
7a91a2e4 5350 break loop36;
9ad3c628
AM		 5351 }
5352 }
5353
5354 // AST REWRITE
5355 // elements: enumerator
5356 // token labels:
5357 // rule labels: retval
5358 // token list labels:
5359 // rule list labels:
5360 // wildcard 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);
5364
5365 root_0 = (CommonTree)adaptor.nil();
73511e67 5366 // 480:40: -> ( ^( ENUM_ENUMERATOR enumerator ) )+
9ad3c628
AM		 5367 {
5368 if ( !(stream_enumerator.hasNext()) ) {
5369 throw new RewriteEarlyExitException();
5370 }
5371 while ( stream_enumerator.hasNext() ) {
73511e67 5372 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:480:44: ^( ENUM_ENUMERATOR enumerator )
9ad3c628
AM		 5373 {
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);
5378 }
5379
5380 }
5381 stream_enumerator.reset();
5382
5383 }
5384
5385
5386 retval.tree = root_0;
5387 }
5388
5389 }
5390
5391 retval.stop = input.LT(-1);
5392
5393 if ( state.backtracking==0 ) {
5394 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5395 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5396 }
5397 }
5398
5399 catch (RecognitionException e) {
5400 throw e;
5401 }
5402
5403 finally {
5404 // do for sure before leaving
5405 }
5406 return retval;
5407 }
5408 // $ANTLR end "enumeratorList"
5409
5410
5411 public static class enumerator_return extends ParserRuleReturnScope {
5412 CommonTree tree;
5413 @Override
5414 public CommonTree getTree() { return tree; }
5415 };
5416
5417
5418 // $ANTLR start "enumerator"
73511e67 5419 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:483:1: enumerator : enumConstant ( enumeratorValue )? ;
9ad3c628
AM		 5420 public final CTFParser.enumerator_return enumerator() throws RecognitionException {
5421 CTFParser.enumerator_return retval = new CTFParser.enumerator_return();
5422 retval.start = input.LT(1);
5423
5424 CommonTree root_0 = null;
5425
7a91a2e4
MK		 5426 ParserRuleReturnScope enumConstant122 =null;
5427 ParserRuleReturnScope enumeratorValue123 =null;
9ad3c628
AM		 5428
5429
5430 try {
73511e67
AM		 5431 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:484:3: ( enumConstant ( enumeratorValue )? )
5432 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:484:5: enumConstant ( enumeratorValue )?
9ad3c628
AM		 5433 {
5434 root_0 = (CommonTree)adaptor.nil();
5435
5436
73511e67 5437 pushFollow(FOLLOW_enumConstant_in_enumerator2605);
7a91a2e4 5438 enumConstant122=enumConstant();
9ad3c628
AM		 5439 state._fsp--;
5440 if (state.failed) return retval;
7a91a2e4 5441 if ( state.backtracking==0 ) adaptor.addChild(root_0, enumConstant122.getTree());
9ad3c628 5442
73511e67 5443 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:484:18: ( enumeratorValue )?
7a91a2e4
MK		 5444 int alt37=2;
5445 int LA37_0 = input.LA(1);
5446 if ( (LA37_0==ASSIGNMENT) ) {
5447 alt37=1;
9ad3c628 5448 }
7a91a2e4 5449 switch (alt37) {
9ad3c628 5450 case 1 :
73511e67 5451 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:484:18: enumeratorValue
9ad3c628 5452 {
73511e67 5453 pushFollow(FOLLOW_enumeratorValue_in_enumerator2607);
7a91a2e4 5454 enumeratorValue123=enumeratorValue();
9ad3c628
AM		 5455 state._fsp--;
5456 if (state.failed) return retval;
7a91a2e4 5457 if ( state.backtracking==0 ) adaptor.addChild(root_0, enumeratorValue123.getTree());
9ad3c628
AM		 5458
5459 }
5460 break;
5461
5462 }
5463
5464 }
5465
5466 retval.stop = input.LT(-1);
5467
5468 if ( state.backtracking==0 ) {
5469 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5470 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5471 }
5472 }
5473
5474 catch (RecognitionException e) {
5475 throw e;
5476 }
5477
5478 finally {
5479 // do for sure before leaving
5480 }
5481 return retval;
5482 }
5483 // $ANTLR end "enumerator"
5484
5485
5486 public static class enumeratorValue_return extends ParserRuleReturnScope {
5487 CommonTree tree;
5488 @Override
5489 public CommonTree getTree() { return tree; }
5490 };
5491
5492
5493 // $ANTLR start "enumeratorValue"
73511e67 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) ) ;
9ad3c628
AM		 5495 public final CTFParser.enumeratorValue_return enumeratorValue() throws RecognitionException {
5496 CTFParser.enumeratorValue_return retval = new CTFParser.enumeratorValue_return();
5497 retval.start = input.LT(1);
5498
5499 CommonTree root_0 = null;
5500
7a91a2e4
MK		 5501 Token ASSIGNMENT124=null;
5502 Token ELIPSES125=null;
9ad3c628
AM		 5503 ParserRuleReturnScope e1 =null;
5504 ParserRuleReturnScope e2 =null;
5505
7a91a2e4
MK		 5506 CommonTree ASSIGNMENT124_tree=null;
5507 CommonTree ELIPSES125_tree=null;
9ad3c628
AM		 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");
5511
5512 try {
73511e67
AM		 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) )
9ad3c628 5515 {
73511e67 5516 ASSIGNMENT124=(Token)match(input,ASSIGNMENT,FOLLOW_ASSIGNMENT_in_enumeratorValue2621); if (state.failed) return retval;
7a91a2e4 5517 if ( state.backtracking==0 ) stream_ASSIGNMENT.add(ASSIGNMENT124);
9ad3c628 5518
73511e67 5519 pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2625);
9ad3c628
AM		 5520 e1=unaryExpression();
5521 state._fsp--;
5522 if (state.failed) return retval;
5523 if ( state.backtracking==0 ) stream_unaryExpression.add(e1.getTree());
73511e67 5524 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:489:7: ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) )
7a91a2e4
MK		 5525 int alt38=2;
5526 int LA38_0 = input.LA(1);
5527 if ( (LA38_0==RCURL||LA38_0==SEPARATOR) ) {
5528 alt38=1;
9ad3c628 5529 }
7a91a2e4
MK		 5530 else if ( (LA38_0==ELIPSES) ) {
5531 alt38=2;
9ad3c628
AM		 5532 }
5533
5534 else {
5535 if (state.backtracking>0) {state.failed=true; return retval;}
5536 NoViableAltException nvae =
7a91a2e4 5537 new NoViableAltException("", 38, 0, input);
9ad3c628
AM		 5538 throw nvae;
5539 }
5540
7a91a2e4 5541 switch (alt38) {
9ad3c628 5542 case 1 :
73511e67 5543 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:490:11:
9ad3c628
AM		 5544 {
5545 // AST REWRITE
5546 // elements: e1
5547 // token labels:
73511e67 5548 // rule labels: e1, retval
9ad3c628
AM		 5549 // token list labels:
5550 // rule list labels:
5551 // wildcard labels:
5552 if ( state.backtracking==0 ) {
5553 retval.tree = root_0;
9ad3c628 5554 RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.getTree():null);
73511e67 5555 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
9ad3c628
AM		 5556
5557 root_0 = (CommonTree)adaptor.nil();
73511e67 5558 // 490:11: -> ^( ENUM_VALUE $e1)
9ad3c628 5559 {
73511e67 5560 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:490:14: ^( ENUM_VALUE $e1)
9ad3c628
AM		 5561 {
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);
5566 }
5567
5568 }
5569
5570
5571 retval.tree = root_0;
5572 }
5573
5574 }
5575 break;
5576 case 2 :
73511e67 5577 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:491:9: ELIPSES e2= unaryExpression
9ad3c628 5578 {
73511e67 5579 ELIPSES125=(Token)match(input,ELIPSES,FOLLOW_ELIPSES_in_enumeratorValue2664); if (state.failed) return retval;
7a91a2e4 5580 if ( state.backtracking==0 ) stream_ELIPSES.add(ELIPSES125);
9ad3c628 5581
73511e67 5582 pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2668);
9ad3c628
AM		 5583 e2=unaryExpression();
5584 state._fsp--;
5585 if (state.failed) return retval;
5586 if ( state.backtracking==0 ) stream_unaryExpression.add(e2.getTree());
5587 // AST REWRITE
73511e67 5588 // elements: e1, e2
9ad3c628 5589 // token labels:
73511e67 5590 // rule labels: e1, e2, retval
9ad3c628
AM		 5591 // token list labels:
5592 // rule list labels:
5593 // wildcard labels:
5594 if ( state.backtracking==0 ) {
5595 retval.tree = root_0;
9ad3c628
AM		 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);
73511e67 5598 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
9ad3c628
AM		 5599
5600 root_0 = (CommonTree)adaptor.nil();
73511e67 5601 // 492:11: -> ^( ENUM_VALUE_RANGE $e1 $e2)
9ad3c628 5602 {
73511e67 5603 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:492:14: ^( ENUM_VALUE_RANGE $e1 $e2)
9ad3c628
AM		 5604 {
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);
5610 }
5611
5612 }
5613
5614
5615 retval.tree = root_0;
5616 }
5617
5618 }
5619 break;
5620
5621 }
5622
5623 }
5624
5625 retval.stop = input.LT(-1);
5626
5627 if ( state.backtracking==0 ) {
5628 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5629 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5630 }
5631 }
5632
5633 catch (RecognitionException e) {
5634 throw e;
5635 }
5636
5637 finally {
5638 // do for sure before leaving
5639 }
5640 return retval;
5641 }
5642 // $ANTLR end "enumeratorValue"
5643
5644
5645 public static class declarator_return extends ParserRuleReturnScope {
5646 CommonTree tree;
5647 @Override
5648 public CommonTree getTree() { return tree; }
5649 };
5650
5651
5652 // $ANTLR start "declarator"
73511e67 5653 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:496:1: declarator : ( pointer )* directDeclarator -> ^( TYPE_DECLARATOR ( pointer )* directDeclarator ) ;
9ad3c628
AM		 5654 public final CTFParser.declarator_return declarator() throws RecognitionException {
5655 CTFParser.declarator_return retval = new CTFParser.declarator_return();
5656 retval.start = input.LT(1);
5657
5658 CommonTree root_0 = null;
5659
7a91a2e4
MK		 5660 ParserRuleReturnScope pointer126 =null;
5661 ParserRuleReturnScope directDeclarator127 =null;
9ad3c628 5662
9ad3c628 5663 RewriteRuleSubtreeStream stream_pointer=new RewriteRuleSubtreeStream(adaptor,"rule pointer");
73511e67 5664 RewriteRuleSubtreeStream stream_directDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule directDeclarator");
9ad3c628
AM		 5665
5666 try {
73511e67
AM		 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
9ad3c628 5669 {
73511e67 5670 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:497:5: ( pointer )*
7a91a2e4 5671 loop39:
9ad3c628 5672 while (true) {
7a91a2e4
MK		 5673 int alt39=2;
5674 int LA39_0 = input.LA(1);
5675 if ( (LA39_0==POINTER) ) {
5676 alt39=1;
9ad3c628
AM		 5677 }
5678
7a91a2e4 5679 switch (alt39) {
9ad3c628 5680 case 1 :
73511e67 5681 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:497:5: pointer
9ad3c628 5682 {
73511e67 5683 pushFollow(FOLLOW_pointer_in_declarator2711);
7a91a2e4 5684 pointer126=pointer();
9ad3c628
AM		 5685 state._fsp--;
5686 if (state.failed) return retval;
7a91a2e4 5687 if ( state.backtracking==0 ) stream_pointer.add(pointer126.getTree());
9ad3c628
AM		 5688 }
5689 break;
5690
5691 default :
7a91a2e4 5692 break loop39;
9ad3c628
AM		 5693 }
5694 }
5695
73511e67 5696 pushFollow(FOLLOW_directDeclarator_in_declarator2714);
7a91a2e4 5697 directDeclarator127=directDeclarator();
9ad3c628
AM		 5698 state._fsp--;
5699 if (state.failed) return retval;
7a91a2e4 5700 if ( state.backtracking==0 ) stream_directDeclarator.add(directDeclarator127.getTree());
9ad3c628 5701 // AST REWRITE
8460a46d 5702 // elements: directDeclarator, pointer
9ad3c628
AM		 5703 // token labels:
5704 // rule labels: retval
5705 // token list labels:
5706 // rule list labels:
5707 // wildcard 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);
5711
5712 root_0 = (CommonTree)adaptor.nil();
73511e67 5713 // 498:7: -> ^( TYPE_DECLARATOR ( pointer )* directDeclarator )
9ad3c628 5714 {
73511e67 5715 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:498:10: ^( TYPE_DECLARATOR ( pointer )* directDeclarator )
9ad3c628
AM		 5716 {
5717 CommonTree root_1 = (CommonTree)adaptor.nil();
5718 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_DECLARATOR, "TYPE_DECLARATOR"), root_1);
73511e67 5719 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:498:28: ( pointer )*
9ad3c628
AM		 5720 while ( stream_pointer.hasNext() ) {
5721 adaptor.addChild(root_1, stream_pointer.nextTree());
5722 }
5723 stream_pointer.reset();
5724
5725 adaptor.addChild(root_1, stream_directDeclarator.nextTree());
5726 adaptor.addChild(root_0, root_1);
5727 }
5728
5729 }
5730
5731
5732 retval.tree = root_0;
5733 }
5734
5735 }
5736
5737 retval.stop = input.LT(-1);
5738
5739 if ( state.backtracking==0 ) {
5740 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5741 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5742 }
5743 }
5744
5745 catch (RecognitionException e) {
5746 throw e;
5747 }
5748
5749 finally {
5750 // do for sure before leaving
5751 }
5752 return retval;
5753 }
5754 // $ANTLR end "declarator"
5755
5756
5757 public static class directDeclarator_return extends ParserRuleReturnScope {
5758 CommonTree tree;
5759 @Override
5760 public CommonTree getTree() { return tree; }
5761 };
5762
5763
5764 // $ANTLR start "directDeclarator"
73511e67 5765 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:501:1: directDeclarator : ( IDENTIFIER ) ( directDeclaratorSuffix )* ;
9ad3c628
AM		 5766 public final CTFParser.directDeclarator_return directDeclarator() throws RecognitionException {
5767 CTFParser.directDeclarator_return retval = new CTFParser.directDeclarator_return();
5768 retval.start = input.LT(1);
5769
5770 CommonTree root_0 = null;
5771
7a91a2e4
MK		 5772 Token IDENTIFIER128=null;
5773 ParserRuleReturnScope directDeclaratorSuffix129 =null;
9ad3c628 5774
7a91a2e4 5775 CommonTree IDENTIFIER128_tree=null;
9ad3c628
AM		 5776
5777 try {
73511e67
AM		 5778 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:502:3: ( ( IDENTIFIER ) ( directDeclaratorSuffix )* )
5779 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:502:5: ( IDENTIFIER ) ( directDeclaratorSuffix )*
9ad3c628
AM		 5780 {
5781 root_0 = (CommonTree)adaptor.nil();
5782
5783
73511e67
AM		 5784 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:502:5: ( IDENTIFIER )
5785 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:503:7: IDENTIFIER
9ad3c628 5786 {
73511e67 5787 IDENTIFIER128=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_directDeclarator2752); if (state.failed) return retval;
9ad3c628 5788 if ( state.backtracking==0 ) {
7a91a2e4
MK		 5789 IDENTIFIER128_tree = (CommonTree)adaptor.create(IDENTIFIER128);
5790 adaptor.addChild(root_0, IDENTIFIER128_tree);
9ad3c628
AM		 5791 }
5792
7a91a2e4
MK		 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)); }
9ad3c628
AM		 5795 }
5796
73511e67 5797 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:508:5: ( directDeclaratorSuffix )*
7a91a2e4 5798 loop40:
9ad3c628 5799 while (true) {
7a91a2e4
MK		 5800 int alt40=2;
5801 int LA40_0 = input.LA(1);
5802 if ( (LA40_0==OPENBRAC) ) {
5803 alt40=1;
9ad3c628
AM		 5804 }
5805
7a91a2e4 5806 switch (alt40) {
9ad3c628 5807 case 1 :
73511e67 5808 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:508:5: directDeclaratorSuffix
9ad3c628 5809 {
73511e67 5810 pushFollow(FOLLOW_directDeclaratorSuffix_in_directDeclarator2792);
7a91a2e4 5811 directDeclaratorSuffix129=directDeclaratorSuffix();
9ad3c628
AM		 5812 state._fsp--;
5813 if (state.failed) return retval;
7a91a2e4 5814 if ( state.backtracking==0 ) adaptor.addChild(root_0, directDeclaratorSuffix129.getTree());
9ad3c628
AM		 5815
5816 }
5817 break;
5818
5819 default :
7a91a2e4 5820 break loop40;
9ad3c628
AM		 5821 }
5822 }
5823
5824 }
5825
5826 retval.stop = input.LT(-1);
5827
5828 if ( state.backtracking==0 ) {
5829 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5830 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5831 }
5832 }
5833
5834 catch (RecognitionException e) {
5835 throw e;
5836 }
5837
5838 finally {
5839 // do for sure before leaving
5840 }
5841 return retval;
5842 }
5843 // $ANTLR end "directDeclarator"
5844
5845
5846 public static class directDeclaratorSuffix_return extends ParserRuleReturnScope {
5847 CommonTree tree;
5848 @Override
5849 public CommonTree getTree() { return tree; }
5850 };
5851
5852
5853 // $ANTLR start "directDeclaratorSuffix"
73511e67 5854 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:511:1: directDeclaratorSuffix : OPENBRAC directDeclaratorLength CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) ;
9ad3c628
AM		 5855 public final CTFParser.directDeclaratorSuffix_return directDeclaratorSuffix() throws RecognitionException {
5856 CTFParser.directDeclaratorSuffix_return retval = new CTFParser.directDeclaratorSuffix_return();
5857 retval.start = input.LT(1);
5858
5859 CommonTree root_0 = null;
5860
7a91a2e4
MK		 5861 Token OPENBRAC130=null;
5862 Token CLOSEBRAC132=null;
5863 ParserRuleReturnScope directDeclaratorLength131 =null;
9ad3c628 5864
7a91a2e4
MK		 5865 CommonTree OPENBRAC130_tree=null;
5866 CommonTree CLOSEBRAC132_tree=null;
9ad3c628
AM		 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");
5870
5871 try {
73511e67
AM		 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
9ad3c628 5874 {
73511e67 5875 OPENBRAC130=(Token)match(input,OPENBRAC,FOLLOW_OPENBRAC_in_directDeclaratorSuffix2806); if (state.failed) return retval;
7a91a2e4 5876 if ( state.backtracking==0 ) stream_OPENBRAC.add(OPENBRAC130);
9ad3c628 5877
73511e67 5878 pushFollow(FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2808);
7a91a2e4 5879 directDeclaratorLength131=directDeclaratorLength();
9ad3c628
AM		 5880 state._fsp--;
5881 if (state.failed) return retval;
7a91a2e4 5882 if ( state.backtracking==0 ) stream_directDeclaratorLength.add(directDeclaratorLength131.getTree());
73511e67 5883 CLOSEBRAC132=(Token)match(input,CLOSEBRAC,FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2810); if (state.failed) return retval;
7a91a2e4 5884 if ( state.backtracking==0 ) stream_CLOSEBRAC.add(CLOSEBRAC132);
9ad3c628
AM		 5885
5886 // AST REWRITE
5887 // elements: directDeclaratorLength
5888 // token labels:
5889 // rule labels: retval
5890 // token list labels:
5891 // rule list labels:
5892 // wildcard 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);
5896
5897 root_0 = (CommonTree)adaptor.nil();
73511e67 5898 // 513:7: -> ^( LENGTH directDeclaratorLength )
9ad3c628 5899 {
73511e67 5900 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:513:10: ^( LENGTH directDeclaratorLength )
9ad3c628
AM		 5901 {
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);
5906 }
5907
5908 }
5909
5910
5911 retval.tree = root_0;
5912 }
5913
5914 }
5915
5916 retval.stop = input.LT(-1);
5917
5918 if ( state.backtracking==0 ) {
5919 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5920 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5921 }
5922 }
5923
5924 catch (RecognitionException e) {
5925 throw e;
5926 }
5927
5928 finally {
5929 // do for sure before leaving
5930 }
5931 return retval;
5932 }
5933 // $ANTLR end "directDeclaratorSuffix"
5934
5935
5936 public static class directDeclaratorLength_return extends ParserRuleReturnScope {
5937 CommonTree tree;
5938 @Override
5939 public CommonTree getTree() { return tree; }
5940 };
5941
5942
5943 // $ANTLR start "directDeclaratorLength"
73511e67 5944 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:516:1: directDeclaratorLength : unaryExpression ;
9ad3c628
AM		 5945 public final CTFParser.directDeclaratorLength_return directDeclaratorLength() throws RecognitionException {
5946 CTFParser.directDeclaratorLength_return retval = new CTFParser.directDeclaratorLength_return();
5947 retval.start = input.LT(1);
5948
5949 CommonTree root_0 = null;
5950
7a91a2e4 5951 ParserRuleReturnScope unaryExpression133 =null;
9ad3c628
AM		 5952
5953
5954 try {
73511e67
AM		 5955 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:517:3: ( unaryExpression )
5956 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:517:5: unaryExpression
9ad3c628
AM		 5957 {
5958 root_0 = (CommonTree)adaptor.nil();
5959
5960
73511e67 5961 pushFollow(FOLLOW_unaryExpression_in_directDeclaratorLength2838);
7a91a2e4 5962 unaryExpression133=unaryExpression();
9ad3c628
AM		 5963 state._fsp--;
5964 if (state.failed) return retval;
7a91a2e4 5965 if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression133.getTree());
9ad3c628
AM		 5966
5967 }
5968
5969 retval.stop = input.LT(-1);
5970
5971 if ( state.backtracking==0 ) {
5972 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
5973 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
5974 }
5975 }
5976
5977 catch (RecognitionException e) {
5978 throw e;
5979 }
5980
5981 finally {
5982 // do for sure before leaving
5983 }
5984 return retval;
5985 }
5986 // $ANTLR end "directDeclaratorLength"
5987
5988
5989 public static class abstractDeclarator_return extends ParserRuleReturnScope {
5990 CommonTree tree;
5991 @Override
5992 public CommonTree getTree() { return tree; }
5993 };
5994
5995
5996 // $ANTLR start "abstractDeclarator"
73511e67 5997 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:520:1: abstractDeclarator : ( ( pointer )+ ( directAbstractDeclarator )? -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^( TYPE_DECLARATOR directAbstractDeclarator ) );
9ad3c628
AM		 5998 public final CTFParser.abstractDeclarator_return abstractDeclarator() throws RecognitionException {
5999 CTFParser.abstractDeclarator_return retval = new CTFParser.abstractDeclarator_return();
6000 retval.start = input.LT(1);
6001
6002 CommonTree root_0 = null;
6003
7a91a2e4
MK		 6004 ParserRuleReturnScope pointer134 =null;
6005 ParserRuleReturnScope directAbstractDeclarator135 =null;
6006 ParserRuleReturnScope directAbstractDeclarator136 =null;
9ad3c628
AM		 6007
6008 RewriteRuleSubtreeStream stream_pointer=new RewriteRuleSubtreeStream(adaptor,"rule pointer");
6009 RewriteRuleSubtreeStream stream_directAbstractDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule directAbstractDeclarator");
6010
6011 try {
73511e67 6012 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:3: ( ( pointer )+ ( directAbstractDeclarator )? -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^( TYPE_DECLARATOR directAbstractDeclarator ) )
7a91a2e4
MK		 6013 int alt43=2;
6014 int LA43_0 = input.LA(1);
6015 if ( (LA43_0==POINTER) ) {
6016 alt43=1;
9ad3c628 6017 }
7a91a2e4
MK		 6018 else if ( (LA43_0==IDENTIFIER||LA43_0==LPAREN) ) {
6019 alt43=2;
9ad3c628
AM		 6020 }
6021
6022 else {
6023 if (state.backtracking>0) {state.failed=true; return retval;}
6024 NoViableAltException nvae =
7a91a2e4 6025 new NoViableAltException("", 43, 0, input);
9ad3c628
AM		 6026 throw nvae;
6027 }
6028
7a91a2e4 6029 switch (alt43) {
9ad3c628 6030 case 1 :
73511e67 6031 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:5: ( pointer )+ ( directAbstractDeclarator )?
9ad3c628 6032 {
73511e67 6033 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:5: ( pointer )+
7a91a2e4
MK		 6034 int cnt41=0;
6035 loop41:
9ad3c628 6036 while (true) {
7a91a2e4
MK		 6037 int alt41=2;
6038 int LA41_0 = input.LA(1);
6039 if ( (LA41_0==POINTER) ) {
6040 alt41=1;
9ad3c628
AM		 6041 }
6042
7a91a2e4 6043 switch (alt41) {
9ad3c628 6044 case 1 :
73511e67 6045 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:5: pointer
9ad3c628 6046 {
73511e67 6047 pushFollow(FOLLOW_pointer_in_abstractDeclarator2851);
7a91a2e4 6048 pointer134=pointer();
9ad3c628
AM		 6049 state._fsp--;
6050 if (state.failed) return retval;
7a91a2e4 6051 if ( state.backtracking==0 ) stream_pointer.add(pointer134.getTree());
9ad3c628
AM		 6052 }
6053 break;
6054
6055 default :
7a91a2e4 6056 if ( cnt41 >= 1 ) break loop41;
9ad3c628 6057 if (state.backtracking>0) {state.failed=true; return retval;}
7a91a2e4 6058 EarlyExitException eee = new EarlyExitException(41, input);
9ad3c628
AM		 6059 throw eee;
6060 }
7a91a2e4 6061 cnt41++;
9ad3c628
AM		 6062 }
6063
73511e67 6064 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:14: ( directAbstractDeclarator )?
7a91a2e4
MK		 6065 int alt42=2;
6066 int LA42_0 = input.LA(1);
6067 if ( (LA42_0==IDENTIFIER||LA42_0==LPAREN) ) {
6068 alt42=1;
9ad3c628 6069 }
7a91a2e4 6070 switch (alt42) {
9ad3c628 6071 case 1 :
73511e67 6072 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:521:14: directAbstractDeclarator
9ad3c628 6073 {
73511e67 6074 pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2854);
7a91a2e4 6075 directAbstractDeclarator135=directAbstractDeclarator();
9ad3c628
AM		 6076 state._fsp--;
6077 if (state.failed) return retval;
7a91a2e4 6078 if ( state.backtracking==0 ) stream_directAbstractDeclarator.add(directAbstractDeclarator135.getTree());
9ad3c628
AM		 6079 }
6080 break;
6081
6082 }
6083
6084 // AST REWRITE
73511e67 6085 // elements: pointer, directAbstractDeclarator
9ad3c628
AM		 6086 // token labels:
6087 // rule labels: retval
6088 // token list labels:
6089 // rule list labels:
6090 // wildcard 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);
6094
6095 root_0 = (CommonTree)adaptor.nil();
73511e67 6096 // 522:7: -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? )
9ad3c628 6097 {
73511e67 6098 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:522:10: ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? )
9ad3c628
AM		 6099 {
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();
6104 }
6105 while ( stream_pointer.hasNext() ) {
6106 adaptor.addChild(root_1, stream_pointer.nextTree());
6107 }
6108 stream_pointer.reset();
6109
73511e67 6110 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:522:37: ( directAbstractDeclarator )?
9ad3c628
AM		 6111 if ( stream_directAbstractDeclarator.hasNext() ) {
6112 adaptor.addChild(root_1, stream_directAbstractDeclarator.nextTree());
6113 }
6114 stream_directAbstractDeclarator.reset();
6115
6116 adaptor.addChild(root_0, root_1);
6117 }
6118
6119 }
6120
6121
6122 retval.tree = root_0;
6123 }
6124
6125 }
6126 break;
6127 case 2 :
73511e67 6128 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:523:5: directAbstractDeclarator
9ad3c628 6129 {
73511e67 6130 pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2879);
7a91a2e4 6131 directAbstractDeclarator136=directAbstractDeclarator();
9ad3c628
AM		 6132 state._fsp--;
6133 if (state.failed) return retval;
7a91a2e4 6134 if ( state.backtracking==0 ) stream_directAbstractDeclarator.add(directAbstractDeclarator136.getTree());
9ad3c628
AM		 6135 // AST REWRITE
6136 // elements: directAbstractDeclarator
6137 // token labels:
6138 // rule labels: retval
6139 // token list labels:
6140 // rule list labels:
6141 // wildcard 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);
6145
6146 root_0 = (CommonTree)adaptor.nil();
73511e67 6147 // 524:7: -> ^( TYPE_DECLARATOR directAbstractDeclarator )
9ad3c628 6148 {
73511e67 6149 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:524:10: ^( TYPE_DECLARATOR directAbstractDeclarator )
9ad3c628
AM		 6150 {
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);
6155 }
6156
6157 }
6158
6159
6160 retval.tree = root_0;
6161 }
6162
6163 }
6164 break;
6165
6166 }
6167 retval.stop = input.LT(-1);
6168
6169 if ( state.backtracking==0 ) {
6170 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6171 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6172 }
6173 }
6174
6175 catch (RecognitionException e) {
6176 throw e;
6177 }
6178
6179 finally {
6180 // do for sure before leaving
6181 }
6182 return retval;
6183 }
6184 // $ANTLR end "abstractDeclarator"
6185
6186
6187 public static class directAbstractDeclarator_return extends ParserRuleReturnScope {
6188 CommonTree tree;
6189 @Override
6190 public CommonTree getTree() { return tree; }
6191 };
6192
6193
6194 // $ANTLR start "directAbstractDeclarator"
73511e67 6195 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:532:1: directAbstractDeclarator : ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )? CLOSEBRAC )? ;
9ad3c628
AM		 6196 public final CTFParser.directAbstractDeclarator_return directAbstractDeclarator() throws RecognitionException {
6197 CTFParser.directAbstractDeclarator_return retval = new CTFParser.directAbstractDeclarator_return();
6198 retval.start = input.LT(1);
6199
6200 CommonTree root_0 = null;
6201
7a91a2e4
MK		 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;
9ad3c628 6209
7a91a2e4
MK		 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;
9ad3c628
AM		 6215
6216 try {
73511e67
AM		 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 )?
9ad3c628
AM		 6219 {
6220 root_0 = (CommonTree)adaptor.nil();
6221
6222
73511e67 6223 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:533:5: ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) )
7a91a2e4
MK		 6224 int alt44=2;
6225 int LA44_0 = input.LA(1);
6226 if ( (LA44_0==IDENTIFIER) ) {
6227 alt44=1;
9ad3c628 6228 }
7a91a2e4
MK		 6229 else if ( (LA44_0==LPAREN) ) {
6230 alt44=2;
9ad3c628
AM		 6231 }
6232
6233 else {
6234 if (state.backtracking>0) {state.failed=true; return retval;}
6235 NoViableAltException nvae =
7a91a2e4 6236 new NoViableAltException("", 44, 0, input);
9ad3c628
AM		 6237 throw nvae;
6238 }
6239
7a91a2e4 6240 switch (alt44) {
9ad3c628 6241 case 1 :
73511e67 6242 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:534:7: IDENTIFIER
9ad3c628 6243 {
73511e67 6244 IDENTIFIER137=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_directAbstractDeclarator2916); if (state.failed) return retval;
9ad3c628 6245 if ( state.backtracking==0 ) {
7a91a2e4
MK		 6246 IDENTIFIER137_tree = (CommonTree)adaptor.create(IDENTIFIER137);
6247 adaptor.addChild(root_0, IDENTIFIER137_tree);
9ad3c628
AM		 6248 }
6249
6250 }
6251 break;
6252 case 2 :
73511e67 6253 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:535:9: ( LPAREN abstractDeclarator RPAREN )
9ad3c628 6254 {
73511e67
AM		 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
9ad3c628 6257 {
73511e67 6258 LPAREN138=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_directAbstractDeclarator2927); if (state.failed) return retval;
9ad3c628 6259 if ( state.backtracking==0 ) {
7a91a2e4
MK		 6260 LPAREN138_tree = (CommonTree)adaptor.create(LPAREN138);
6261 adaptor.addChild(root_0, LPAREN138_tree);
9ad3c628
AM		 6262 }
6263
73511e67 6264 pushFollow(FOLLOW_abstractDeclarator_in_directAbstractDeclarator2929);
7a91a2e4 6265 abstractDeclarator139=abstractDeclarator();
9ad3c628
AM		 6266 state._fsp--;
6267 if (state.failed) return retval;
7a91a2e4 6268 if ( state.backtracking==0 ) adaptor.addChild(root_0, abstractDeclarator139.getTree());
9ad3c628 6269
73511e67 6270 RPAREN140=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_directAbstractDeclarator2931); if (state.failed) return retval;
9ad3c628 6271 if ( state.backtracking==0 ) {
7a91a2e4
MK		 6272 RPAREN140_tree = (CommonTree)adaptor.create(RPAREN140);
6273 adaptor.addChild(root_0, RPAREN140_tree);
9ad3c628
AM		 6274 }
6275
6276 }
6277
6278 }
6279 break;
6280
6281 }
6282
73511e67 6283 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:536:5: ( OPENBRAC ( unaryExpression )? CLOSEBRAC )?
7a91a2e4
MK		 6284 int alt46=2;
6285 int LA46_0 = input.LA(1);
6286 if ( (LA46_0==OPENBRAC) ) {
6287 alt46=1;
9ad3c628 6288 }
7a91a2e4 6289 switch (alt46) {
9ad3c628 6290 case 1 :
73511e67 6291 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:537:7: OPENBRAC ( unaryExpression )? CLOSEBRAC
9ad3c628 6292 {
73511e67 6293 OPENBRAC141=(Token)match(input,OPENBRAC,FOLLOW_OPENBRAC_in_directAbstractDeclarator2946); if (state.failed) return retval;
9ad3c628 6294 if ( state.backtracking==0 ) {
7a91a2e4
MK		 6295 OPENBRAC141_tree = (CommonTree)adaptor.create(OPENBRAC141);
6296 adaptor.addChild(root_0, OPENBRAC141_tree);
9ad3c628
AM		 6297 }
6298
73511e67 6299 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:537:16: ( unaryExpression )?
7a91a2e4
MK		 6300 int alt45=2;
6301 int LA45_0 = input.LA(1);
73511e67 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) ) {
7a91a2e4 6303 alt45=1;
9ad3c628 6304 }
7a91a2e4 6305 switch (alt45) {
9ad3c628 6306 case 1 :
73511e67 6307 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:537:16: unaryExpression
9ad3c628 6308 {
73511e67 6309 pushFollow(FOLLOW_unaryExpression_in_directAbstractDeclarator2948);
7a91a2e4 6310 unaryExpression142=unaryExpression();
9ad3c628
AM		 6311 state._fsp--;
6312 if (state.failed) return retval;
7a91a2e4 6313 if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression142.getTree());
9ad3c628
AM		 6314
6315 }
6316 break;
6317
6318 }
6319
73511e67 6320 CLOSEBRAC143=(Token)match(input,CLOSEBRAC,FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2951); if (state.failed) return retval;
9ad3c628 6321 if ( state.backtracking==0 ) {
7a91a2e4
MK		 6322 CLOSEBRAC143_tree = (CommonTree)adaptor.create(CLOSEBRAC143);
6323 adaptor.addChild(root_0, CLOSEBRAC143_tree);
9ad3c628
AM		 6324 }
6325
6326 }
6327 break;
6328
6329 }
6330
6331 }
6332
6333 retval.stop = input.LT(-1);
6334
6335 if ( state.backtracking==0 ) {
6336 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6337 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6338 }
6339 }
6340
6341 catch (RecognitionException e) {
6342 throw e;
6343 }
6344
6345 finally {
6346 // do for sure before leaving
6347 }
6348 return retval;
6349 }
6350 // $ANTLR end "directAbstractDeclarator"
6351
6352
6353 public static class pointer_return extends ParserRuleReturnScope {
6354 CommonTree tree;
6355 @Override
6356 public CommonTree getTree() { return tree; }
6357 };
6358
6359
6360 // $ANTLR start "pointer"
73511e67 6361 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:541:1: pointer : POINTER ( typeQualifierList )? -> ^( POINTER ( typeQualifierList )? ) ;
9ad3c628
AM		 6362 public final CTFParser.pointer_return pointer() throws RecognitionException {
6363 CTFParser.pointer_return retval = new CTFParser.pointer_return();
6364 retval.start = input.LT(1);
6365
6366 CommonTree root_0 = null;
6367
7a91a2e4
MK		 6368 Token POINTER144=null;
6369 ParserRuleReturnScope typeQualifierList145 =null;
9ad3c628 6370
7a91a2e4 6371 CommonTree POINTER144_tree=null;
9ad3c628
AM		 6372 RewriteRuleTokenStream stream_POINTER=new RewriteRuleTokenStream(adaptor,"token POINTER");
6373 RewriteRuleSubtreeStream stream_typeQualifierList=new RewriteRuleSubtreeStream(adaptor,"rule typeQualifierList");
6374
6375 try {
73511e67
AM		 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 )?
9ad3c628 6378 {
73511e67 6379 POINTER144=(Token)match(input,POINTER,FOLLOW_POINTER_in_pointer2969); if (state.failed) return retval;
7a91a2e4 6380 if ( state.backtracking==0 ) stream_POINTER.add(POINTER144);
9ad3c628 6381
73511e67 6382 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:13: ( typeQualifierList )?
7a91a2e4
MK		 6383 int alt47=2;
6384 int LA47_0 = input.LA(1);
6385 if ( (LA47_0==CONSTTOK) ) {
6386 alt47=1;
9ad3c628 6387 }
7a91a2e4 6388 switch (alt47) {
9ad3c628 6389 case 1 :
73511e67 6390 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:13: typeQualifierList
9ad3c628 6391 {
73511e67 6392 pushFollow(FOLLOW_typeQualifierList_in_pointer2971);
7a91a2e4 6393 typeQualifierList145=typeQualifierList();
9ad3c628
AM		 6394 state._fsp--;
6395 if (state.failed) return retval;
7a91a2e4 6396 if ( state.backtracking==0 ) stream_typeQualifierList.add(typeQualifierList145.getTree());
9ad3c628
AM		 6397 }
6398 break;
6399
6400 }
6401
6402 // AST REWRITE
73511e67 6403 // elements: typeQualifierList, POINTER
9ad3c628
AM		 6404 // token labels:
6405 // rule labels: retval
6406 // token list labels:
6407 // rule list labels:
6408 // wildcard 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);
6412
6413 root_0 = (CommonTree)adaptor.nil();
73511e67 6414 // 542:32: -> ^( POINTER ( typeQualifierList )? )
9ad3c628 6415 {
73511e67 6416 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:35: ^( POINTER ( typeQualifierList )? )
9ad3c628
AM		 6417 {
6418 CommonTree root_1 = (CommonTree)adaptor.nil();
6419 root_1 = (CommonTree)adaptor.becomeRoot(stream_POINTER.nextNode(), root_1);
73511e67 6420 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:542:45: ( typeQualifierList )?
9ad3c628
AM		 6421 if ( stream_typeQualifierList.hasNext() ) {
6422 adaptor.addChild(root_1, stream_typeQualifierList.nextTree());
6423 }
6424 stream_typeQualifierList.reset();
6425
6426 adaptor.addChild(root_0, root_1);
6427 }
6428
6429 }
6430
6431
6432 retval.tree = root_0;
6433 }
6434
6435 }
6436
6437 retval.stop = input.LT(-1);
6438
6439 if ( state.backtracking==0 ) {
6440 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6441 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6442 }
6443 }
6444
6445 catch (RecognitionException e) {
6446 throw e;
6447 }
6448
6449 finally {
6450 // do for sure before leaving
6451 }
6452 return retval;
6453 }
6454 // $ANTLR end "pointer"
6455
6456
6457 public static class typeQualifierList_return extends ParserRuleReturnScope {
6458 CommonTree tree;
6459 @Override
6460 public CommonTree getTree() { return tree; }
6461 };
6462
6463
6464 // $ANTLR start "typeQualifierList"
73511e67 6465 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:545:1: typeQualifierList : ( typeQualifier )+ ;
9ad3c628
AM		 6466 public final CTFParser.typeQualifierList_return typeQualifierList() throws RecognitionException {
6467 CTFParser.typeQualifierList_return retval = new CTFParser.typeQualifierList_return();
6468 retval.start = input.LT(1);
6469
6470 CommonTree root_0 = null;
6471
7a91a2e4 6472 ParserRuleReturnScope typeQualifier146 =null;
9ad3c628
AM		 6473
6474
6475 try {
73511e67
AM		 6476 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:546:3: ( ( typeQualifier )+ )
6477 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:546:5: ( typeQualifier )+
9ad3c628
AM		 6478 {
6479 root_0 = (CommonTree)adaptor.nil();
6480
6481
73511e67 6482 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:546:5: ( typeQualifier )+
7a91a2e4
MK		 6483 int cnt48=0;
6484 loop48:
9ad3c628 6485 while (true) {
7a91a2e4
MK		 6486 int alt48=2;
6487 int LA48_0 = input.LA(1);
6488 if ( (LA48_0==CONSTTOK) ) {
6489 alt48=1;
9ad3c628
AM		 6490 }
6491
7a91a2e4 6492 switch (alt48) {
9ad3c628 6493 case 1 :
73511e67 6494 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:546:5: typeQualifier
9ad3c628 6495 {
73511e67 6496 pushFollow(FOLLOW_typeQualifier_in_typeQualifierList2994);
7a91a2e4 6497 typeQualifier146=typeQualifier();
9ad3c628
AM		 6498 state._fsp--;
6499 if (state.failed) return retval;
7a91a2e4 6500 if ( state.backtracking==0 ) adaptor.addChild(root_0, typeQualifier146.getTree());
9ad3c628
AM		 6501
6502 }
6503 break;
6504
6505 default :
7a91a2e4 6506 if ( cnt48 >= 1 ) break loop48;
9ad3c628 6507 if (state.backtracking>0) {state.failed=true; return retval;}
7a91a2e4 6508 EarlyExitException eee = new EarlyExitException(48, input);
9ad3c628
AM		 6509 throw eee;
6510 }
7a91a2e4 6511 cnt48++;
9ad3c628
AM		 6512 }
6513
6514 }
6515
6516 retval.stop = input.LT(-1);
6517
6518 if ( state.backtracking==0 ) {
6519 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6520 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6521 }
6522 }
6523
6524 catch (RecognitionException e) {
6525 throw e;
6526 }
6527
6528 finally {
6529 // do for sure before leaving
6530 }
6531 return retval;
6532 }
6533 // $ANTLR end "typeQualifierList"
6534
6535
6536 public static class typedefName_return extends ParserRuleReturnScope {
6537 CommonTree tree;
6538 @Override
6539 public CommonTree getTree() { return tree; }
6540 };
6541
6542
6543 // $ANTLR start "typedefName"
73511e67 6544 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:549:1: typedefName :{...}? IDENTIFIER ;
9ad3c628
AM		 6545 public final CTFParser.typedefName_return typedefName() throws RecognitionException {
6546 CTFParser.typedefName_return retval = new CTFParser.typedefName_return();
6547 retval.start = input.LT(1);
6548
6549 CommonTree root_0 = null;
6550
7a91a2e4 6551 Token IDENTIFIER147=null;
9ad3c628 6552
7a91a2e4 6553 CommonTree IDENTIFIER147_tree=null;
9ad3c628
AM		 6554
6555 try {
73511e67
AM		 6556 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:550:3: ({...}? IDENTIFIER )
6557 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:550:5: {...}? IDENTIFIER
9ad3c628
AM		 6558 {
6559 root_0 = (CommonTree)adaptor.nil();
6560
6561
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())");
6565 }
73511e67 6566 IDENTIFIER147=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typedefName3010); if (state.failed) return retval;
9ad3c628 6567 if ( state.backtracking==0 ) {
7a91a2e4
MK		 6568 IDENTIFIER147_tree = (CommonTree)adaptor.create(IDENTIFIER147);
6569 adaptor.addChild(root_0, IDENTIFIER147_tree);
9ad3c628
AM		 6570 }
6571
7a91a2e4 6572 if ( state.backtracking==0 ) { if ((inTypedef() || inTypealiasAlias()) && !isTypeName((IDENTIFIER147!=null?IDENTIFIER147.getText():null))) { addTypeName((IDENTIFIER147!=null?IDENTIFIER147.getText():null)); } }
9ad3c628
AM		 6573 }
6574
6575 retval.stop = input.LT(-1);
6576
6577 if ( state.backtracking==0 ) {
6578 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6579 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6580 }
6581 }
6582
6583 catch (RecognitionException e) {
6584 throw e;
6585 }
6586
6587 finally {
6588 // do for sure before leaving
6589 }
6590 return retval;
6591 }
6592 // $ANTLR end "typedefName"
6593
6594
6595 public static class typealiasTarget_return extends ParserRuleReturnScope {
6596 CommonTree tree;
6597 @Override
6598 public CommonTree getTree() { return tree; }
6599 };
6600
6601
6602 // $ANTLR start "typealiasTarget"
73511e67 6603 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:559:1: typealiasTarget : declarationSpecifiers ( abstractDeclaratorList )? ;
9ad3c628
AM		 6604 public final CTFParser.typealiasTarget_return typealiasTarget() throws RecognitionException {
6605 CTFParser.typealiasTarget_return retval = new CTFParser.typealiasTarget_return();
6606 retval.start = input.LT(1);
6607
6608 CommonTree root_0 = null;
6609
7a91a2e4
MK		 6610 ParserRuleReturnScope declarationSpecifiers148 =null;
6611 ParserRuleReturnScope abstractDeclaratorList149 =null;
9ad3c628
AM		 6612
6613
6614 try {
73511e67
AM		 6615 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:560:3: ( declarationSpecifiers ( abstractDeclaratorList )? )
6616 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:560:5: declarationSpecifiers ( abstractDeclaratorList )?
9ad3c628
AM		 6617 {
6618 root_0 = (CommonTree)adaptor.nil();
6619
6620
73511e67 6621 pushFollow(FOLLOW_declarationSpecifiers_in_typealiasTarget3027);
7a91a2e4 6622 declarationSpecifiers148=declarationSpecifiers();
9ad3c628
AM		 6623 state._fsp--;
6624 if (state.failed) return retval;
7a91a2e4 6625 if ( state.backtracking==0 ) adaptor.addChild(root_0, declarationSpecifiers148.getTree());
9ad3c628 6626
73511e67 6627 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:560:27: ( abstractDeclaratorList )?
7a91a2e4
MK		 6628 int alt49=2;
6629 int LA49_0 = input.LA(1);
6630 if ( (LA49_0==IDENTIFIER||LA49_0==LPAREN||LA49_0==POINTER) ) {
6631 alt49=1;
9ad3c628 6632 }
7a91a2e4 6633 switch (alt49) {
9ad3c628 6634 case 1 :
73511e67 6635 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:560:27: abstractDeclaratorList
9ad3c628 6636 {
73511e67 6637 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasTarget3029);
7a91a2e4 6638 abstractDeclaratorList149=abstractDeclaratorList();
9ad3c628
AM		 6639 state._fsp--;
6640 if (state.failed) return retval;
7a91a2e4 6641 if ( state.backtracking==0 ) adaptor.addChild(root_0, abstractDeclaratorList149.getTree());
9ad3c628
AM		 6642
6643 }
6644 break;
6645
6646 }
6647
6648 }
6649
6650 retval.stop = input.LT(-1);
6651
6652 if ( state.backtracking==0 ) {
6653 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6654 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6655 }
6656 }
6657
6658 catch (RecognitionException e) {
6659 throw e;
6660 }
6661
6662 finally {
6663 // do for sure before leaving
6664 }
6665 return retval;
6666 }
6667 // $ANTLR end "typealiasTarget"
6668
6669
6670 public static class typealiasAlias_return extends ParserRuleReturnScope {
6671 CommonTree tree;
6672 @Override
6673 public CommonTree getTree() { return tree; }
6674 };
6675
6676
6677 // $ANTLR start "typealiasAlias"
73511e67 6678 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:569:1: typealiasAlias : ( abstractDeclaratorList | declarationSpecifiers ( abstractDeclaratorList )? );
9ad3c628
AM		 6679 public final CTFParser.typealiasAlias_return typealiasAlias() throws RecognitionException {
6680 CTFParser.typealiasAlias_return retval = new CTFParser.typealiasAlias_return();
6681 retval.start = input.LT(1);
6682
6683 CommonTree root_0 = null;
6684
9ad3c628 6685 ParserRuleReturnScope abstractDeclaratorList150 =null;
7a91a2e4
MK		 6686 ParserRuleReturnScope declarationSpecifiers151 =null;
6687 ParserRuleReturnScope abstractDeclaratorList152 =null;
9ad3c628
AM		 6688
6689
6690
6691 typealiasAliasOn();
6692
6693 try {
73511e67 6694 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:576:3: ( abstractDeclaratorList | declarationSpecifiers ( abstractDeclaratorList )? )
7a91a2e4 6695 int alt51=2;
9ad3c628
AM		 6696 switch ( input.LA(1) ) {
6697 case LPAREN:
6698 case POINTER:
6699 {
7a91a2e4 6700 alt51=1;
9ad3c628
AM		 6701 }
6702 break;
6703 case IDENTIFIER:
6704 {
7a91a2e4 6705 int LA51_2 = input.LA(2);
9ad3c628 6706 if ( (!(((( inTypealiasAlias() || isTypeName(input.LT(1).getText()) )&&(inTypealiasAlias() || isTypeName(input.LT(1).getText())))))) ) {
7a91a2e4 6707 alt51=1;
9ad3c628
AM		 6708 }
6709 else if ( ((( inTypealiasAlias() || isTypeName(input.LT(1).getText()) )&&(inTypealiasAlias() || isTypeName(input.LT(1).getText())))) ) {
7a91a2e4 6710 alt51=2;
9ad3c628
AM		 6711 }
6712
6713 else {
6714 if (state.backtracking>0) {state.failed=true; return retval;}
6715 int nvaeMark = input.mark();
6716 try {
6717 input.consume();
6718 NoViableAltException nvae =
7a91a2e4 6719 new NoViableAltException("", 51, 2, input);
9ad3c628
AM		 6720 throw nvae;
6721 } finally {
6722 input.rewind(nvaeMark);
6723 }
6724 }
6725
6726 }
6727 break;
6728 case BOOLTOK:
6729 case CHARTOK:
6730 case COMPLEXTOK:
6731 case CONSTTOK:
6732 case DOUBLETOK:
6733 case ENUMTOK:
6734 case FLOATINGPOINTTOK:
6735 case FLOATTOK:
6736 case IMAGINARYTOK:
6737 case INTEGERTOK:
6738 case INTTOK:
6739 case LONGTOK:
6740 case SHORTTOK:
6741 case SIGNEDTOK:
6742 case STRINGTOK:
6743 case STRUCTTOK:
6744 case TYPEDEFTOK:
6745 case UNSIGNEDTOK:
6746 case VARIANTTOK:
6747 case VOIDTOK:
6748 {
7a91a2e4 6749 alt51=2;
9ad3c628
AM		 6750 }
6751 break;
6752 default:
6753 if (state.backtracking>0) {state.failed=true; return retval;}
6754 NoViableAltException nvae =
7a91a2e4 6755 new NoViableAltException("", 51, 0, input);
9ad3c628
AM		 6756 throw nvae;
6757 }
7a91a2e4 6758 switch (alt51) {
9ad3c628 6759 case 1 :
73511e67 6760 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:576:5: abstractDeclaratorList
9ad3c628
AM		 6761 {
6762 root_0 = (CommonTree)adaptor.nil();
6763
6764
73511e67 6765 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias3055);
7a91a2e4 6766 abstractDeclaratorList150=abstractDeclaratorList();
9ad3c628
AM		 6767 state._fsp--;
6768 if (state.failed) return retval;
7a91a2e4 6769 if ( state.backtracking==0 ) adaptor.addChild(root_0, abstractDeclaratorList150.getTree());
9ad3c628
AM		 6770
6771 }
6772 break;
6773 case 2 :
73511e67 6774 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:577:5: declarationSpecifiers ( abstractDeclaratorList )?
9ad3c628
AM		 6775 {
6776 root_0 = (CommonTree)adaptor.nil();
6777
6778
73511e67 6779 pushFollow(FOLLOW_declarationSpecifiers_in_typealiasAlias3061);
7a91a2e4 6780 declarationSpecifiers151=declarationSpecifiers();
9ad3c628
AM		 6781 state._fsp--;
6782 if (state.failed) return retval;
7a91a2e4 6783 if ( state.backtracking==0 ) adaptor.addChild(root_0, declarationSpecifiers151.getTree());
9ad3c628 6784
73511e67 6785 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:577:27: ( abstractDeclaratorList )?
7a91a2e4
MK		 6786 int alt50=2;
6787 int LA50_0 = input.LA(1);
6788 if ( (LA50_0==IDENTIFIER||LA50_0==LPAREN||LA50_0==POINTER) ) {
6789 alt50=1;
9ad3c628 6790 }
7a91a2e4 6791 switch (alt50) {
9ad3c628 6792 case 1 :
73511e67 6793 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:577:27: abstractDeclaratorList
9ad3c628 6794 {
73511e67 6795 pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias3063);
7a91a2e4 6796 abstractDeclaratorList152=abstractDeclaratorList();
9ad3c628
AM		 6797 state._fsp--;
6798 if (state.failed) return retval;
7a91a2e4 6799 if ( state.backtracking==0 ) adaptor.addChild(root_0, abstractDeclaratorList152.getTree());
9ad3c628
AM		 6800
6801 }
6802 break;
6803
6804 }
6805
6806 }
6807 break;
6808
6809 }
6810 retval.stop = input.LT(-1);
6811
6812 if ( state.backtracking==0 ) {
6813 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6814 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6815 }
6816 if ( state.backtracking==0 ) {
6817 typealiasAliasOff();
6818 }
6819 }
6820
6821 catch (RecognitionException e) {
6822 throw e;
6823 }
6824
6825 finally {
6826 // do for sure before leaving
6827 }
6828 return retval;
6829 }
6830 // $ANTLR end "typealiasAlias"
6831
6832
6833 public static class typealiasDecl_return extends ParserRuleReturnScope {
6834 CommonTree tree;
6835 @Override
6836 public CommonTree getTree() { return tree; }
6837 };
6838
6839
6840 // $ANTLR start "typealiasDecl"
73511e67 6841 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:580:1: typealiasDecl : TYPEALIASTOK typealiasTarget TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) ) ;
9ad3c628
AM		 6842 public final CTFParser.typealiasDecl_return typealiasDecl() throws RecognitionException {
6843 CTFParser.typealiasDecl_return retval = new CTFParser.typealiasDecl_return();
6844 retval.start = input.LT(1);
6845
6846 CommonTree root_0 = null;
6847
7a91a2e4
MK		 6848 Token TYPEALIASTOK153=null;
6849 Token TYPE_ASSIGNMENT155=null;
6850 ParserRuleReturnScope typealiasTarget154 =null;
6851 ParserRuleReturnScope typealiasAlias156 =null;
9ad3c628 6852
7a91a2e4
MK		 6853 CommonTree TYPEALIASTOK153_tree=null;
6854 CommonTree TYPE_ASSIGNMENT155_tree=null;
9ad3c628
AM		 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");
6859
6860 try {
73511e67
AM		 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
9ad3c628 6863 {
73511e67 6864 TYPEALIASTOK153=(Token)match(input,TYPEALIASTOK,FOLLOW_TYPEALIASTOK_in_typealiasDecl3077); if (state.failed) return retval;
7a91a2e4 6865 if ( state.backtracking==0 ) stream_TYPEALIASTOK.add(TYPEALIASTOK153);
9ad3c628 6866
73511e67 6867 pushFollow(FOLLOW_typealiasTarget_in_typealiasDecl3079);
7a91a2e4 6868 typealiasTarget154=typealiasTarget();
9ad3c628
AM		 6869 state._fsp--;
6870 if (state.failed) return retval;
7a91a2e4 6871 if ( state.backtracking==0 ) stream_typealiasTarget.add(typealiasTarget154.getTree());
73511e67 6872 TYPE_ASSIGNMENT155=(Token)match(input,TYPE_ASSIGNMENT,FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3081); if (state.failed) return retval;
7a91a2e4 6873 if ( state.backtracking==0 ) stream_TYPE_ASSIGNMENT.add(TYPE_ASSIGNMENT155);
9ad3c628 6874
73511e67 6875 pushFollow(FOLLOW_typealiasAlias_in_typealiasDecl3083);
7a91a2e4 6876 typealiasAlias156=typealiasAlias();
9ad3c628
AM		 6877 state._fsp--;
6878 if (state.failed) return retval;
7a91a2e4 6879 if ( state.backtracking==0 ) stream_typealiasAlias.add(typealiasAlias156.getTree());
9ad3c628 6880 // AST REWRITE
1c98290b 6881 // elements: typealiasTarget, typealiasAlias
9ad3c628
AM		 6882 // token labels:
6883 // rule labels: retval
6884 // token list labels:
6885 // rule list labels:
6886 // wildcard 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);
6890
6891 root_0 = (CommonTree)adaptor.nil();
73511e67 6892 // 582:7: -> ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
9ad3c628 6893 {
73511e67 6894 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:582:10: ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
9ad3c628
AM		 6895 {
6896 CommonTree root_1 = (CommonTree)adaptor.nil();
6897 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPEALIAS, "TYPEALIAS"), root_1);
73511e67 6898 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:583:14: ^( TYPEALIAS_TARGET typealiasTarget )
9ad3c628
AM		 6899 {
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);
6904 }
6905
73511e67 6906 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:584:14: ^( TYPEALIAS_ALIAS typealiasAlias )
9ad3c628
AM		 6907 {
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);
6912 }
6913
6914 adaptor.addChild(root_0, root_1);
6915 }
6916
6917 }
6918
6919
6920 retval.tree = root_0;
6921 }
6922
6923 }
6924
6925 retval.stop = input.LT(-1);
6926
6927 if ( state.backtracking==0 ) {
6928 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6929 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6930 }
6931 }
6932
6933 catch (RecognitionException e) {
6934 throw e;
6935 }
6936
6937 finally {
6938 // do for sure before leaving
6939 }
6940 return retval;
6941 }
6942 // $ANTLR end "typealiasDecl"
6943
6944
6945 public static class ctfKeyword_return extends ParserRuleReturnScope {
6946 CommonTree tree;
6947 @Override
6948 public CommonTree getTree() { return tree; }
6949 };
6950
6951
6952 // $ANTLR start "ctfKeyword"
73511e67 6953 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:590:1: ctfKeyword : ( ALIGNTOK | EVENTTOK | SIGNEDTOK | STRINGTOK );
9ad3c628
AM		 6954 public final CTFParser.ctfKeyword_return ctfKeyword() throws RecognitionException {
6955 CTFParser.ctfKeyword_return retval = new CTFParser.ctfKeyword_return();
6956 retval.start = input.LT(1);
6957
6958 CommonTree root_0 = null;
6959
7a91a2e4 6960 Token set157=null;
9ad3c628 6961
7a91a2e4 6962 CommonTree set157_tree=null;
9ad3c628
AM		 6963
6964 try {
73511e67 6965 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:591:3: ( ALIGNTOK | EVENTTOK | SIGNEDTOK | STRINGTOK )
9ad3c628
AM		 6966 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:
6967 {
6968 root_0 = (CommonTree)adaptor.nil();
6969
6970
7a91a2e4 6971 set157=input.LT(1);
9ad3c628
AM		 6972 if ( input.LA(1)==ALIGNTOK||input.LA(1)==EVENTTOK||input.LA(1)==SIGNEDTOK||input.LA(1)==STRINGTOK ) {
6973 input.consume();
7a91a2e4 6974 if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set157));
9ad3c628
AM		 6975 state.errorRecovery=false;
6976 state.failed=false;
6977 }
6978 else {
6979 if (state.backtracking>0) {state.failed=true; return retval;}
6980 MismatchedSetException mse = new MismatchedSetException(null,input);
6981 throw mse;
6982 }
6983 }
6984
6985 retval.stop = input.LT(-1);
6986
6987 if ( state.backtracking==0 ) {
6988 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
6989 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
6990 }
6991 }
6992
6993 catch (RecognitionException e) {
6994 throw e;
6995 }
6996
6997 finally {
6998 // do for sure before leaving
6999 }
7000 return retval;
7001 }
7002 // $ANTLR end "ctfKeyword"
7003
7004
7005 public static class ctfSpecifier_return extends ParserRuleReturnScope {
7006 CommonTree tree;
7007 @Override
7008 public CommonTree getTree() { return tree; }
7009 };
7010
7011
7012 // $ANTLR start "ctfSpecifier"
73511e67 7013 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:597:1: ctfSpecifier : ( ctfSpecifierHead ctfBody -> ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION typealiasDecl ) );
9ad3c628
AM		 7014 public final CTFParser.ctfSpecifier_return ctfSpecifier() throws RecognitionException {
7015 CTFParser.ctfSpecifier_return retval = new CTFParser.ctfSpecifier_return();
7016 retval.start = input.LT(1);
7017
7018 CommonTree root_0 = null;
7019
7a91a2e4
MK		 7020 ParserRuleReturnScope ctfSpecifierHead158 =null;
7021 ParserRuleReturnScope ctfBody159 =null;
7022 ParserRuleReturnScope typealiasDecl160 =null;
9ad3c628 7023
9ad3c628 7024 RewriteRuleSubtreeStream stream_typealiasDecl=new RewriteRuleSubtreeStream(adaptor,"rule typealiasDecl");
73511e67 7025 RewriteRuleSubtreeStream stream_ctfSpecifierHead=new RewriteRuleSubtreeStream(adaptor,"rule ctfSpecifierHead");
9ad3c628
AM		 7026 RewriteRuleSubtreeStream stream_ctfBody=new RewriteRuleSubtreeStream(adaptor,"rule ctfBody");
7027
7028 try {
73511e67 7029 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:599:3: ( ctfSpecifierHead ctfBody -> ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION typealiasDecl ) )
7a91a2e4
MK		 7030 int alt52=2;
7031 int LA52_0 = input.LA(1);
73511e67 7032 if ( (LA52_0==CLOCKTOK||LA52_0==ENVTOK||LA52_0==EVENTTOK||LA52_0==STREAMTOK||LA52_0==TRACETOK) ) {
7a91a2e4 7033 alt52=1;
9ad3c628 7034 }
7a91a2e4
MK		 7035 else if ( (LA52_0==TYPEALIASTOK) ) {
7036 alt52=2;
9ad3c628
AM		 7037 }
7038
7039 else {
7040 if (state.backtracking>0) {state.failed=true; return retval;}
7041 NoViableAltException nvae =
7a91a2e4 7042 new NoViableAltException("", 52, 0, input);
9ad3c628
AM		 7043 throw nvae;
7044 }
7045
7a91a2e4 7046 switch (alt52) {
9ad3c628 7047 case 1 :
73511e67 7048 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:599:5: ctfSpecifierHead ctfBody
9ad3c628 7049 {
73511e67 7050 pushFollow(FOLLOW_ctfSpecifierHead_in_ctfSpecifier3183);
7a91a2e4 7051 ctfSpecifierHead158=ctfSpecifierHead();
9ad3c628
AM		 7052 state._fsp--;
7053 if (state.failed) return retval;
7a91a2e4 7054 if ( state.backtracking==0 ) stream_ctfSpecifierHead.add(ctfSpecifierHead158.getTree());
73511e67 7055 pushFollow(FOLLOW_ctfBody_in_ctfSpecifier3185);
7a91a2e4 7056 ctfBody159=ctfBody();
9ad3c628
AM		 7057 state._fsp--;
7058 if (state.failed) return retval;
7a91a2e4 7059 if ( state.backtracking==0 ) stream_ctfBody.add(ctfBody159.getTree());
9ad3c628 7060 // AST REWRITE
73511e67 7061 // elements: ctfSpecifierHead, ctfBody
9ad3c628
AM		 7062 // token labels:
7063 // rule labels: retval
7064 // token list labels:
7065 // rule list labels:
7066 // wildcard 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);
7070
7071 root_0 = (CommonTree)adaptor.nil();
73511e67 7072 // 599:30: -> ^( ctfSpecifierHead ctfBody )
9ad3c628 7073 {
73511e67 7074 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:599:33: ^( ctfSpecifierHead ctfBody )
9ad3c628
AM		 7075 {
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);
7080 }
7081
7082 }
7083
7084
7085 retval.tree = root_0;
7086 }
7087
7088 }
7089 break;
7090 case 2 :
73511e67 7091 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:601:5: typealiasDecl
9ad3c628 7092 {
73511e67 7093 pushFollow(FOLLOW_typealiasDecl_in_ctfSpecifier3202);
7a91a2e4 7094 typealiasDecl160=typealiasDecl();
9ad3c628
AM		 7095 state._fsp--;
7096 if (state.failed) return retval;
7a91a2e4 7097 if ( state.backtracking==0 ) stream_typealiasDecl.add(typealiasDecl160.getTree());
9ad3c628
AM		 7098 // AST REWRITE
7099 // elements: typealiasDecl
7100 // token labels:
7101 // rule labels: retval
7102 // token list labels:
7103 // rule list labels:
7104 // wildcard 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);
7108
7109 root_0 = (CommonTree)adaptor.nil();
73511e67 7110 // 601:19: -> ^( DECLARATION typealiasDecl )
9ad3c628 7111 {
73511e67 7112 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:601:22: ^( DECLARATION typealiasDecl )
9ad3c628
AM		 7113 {
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);
7118 }
7119
7120 }
7121
7122
7123 retval.tree = root_0;
7124 }
7125
7126 }
7127 break;
7128
7129 }
7130 retval.stop = input.LT(-1);
7131
7132 if ( state.backtracking==0 ) {
7133 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
7134 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
7135 }
7136 }
7137
7138 catch (RecognitionException e) {
7139 throw e;
7140 }
7141
7142 finally {
7143 // do for sure before leaving
7144 }
7145 return retval;
7146 }
7147 // $ANTLR end "ctfSpecifier"
7148
7149
7150 public static class ctfSpecifierHead_return extends ParserRuleReturnScope {
7151 CommonTree tree;
7152 @Override
7153 public CommonTree getTree() { return tree; }
7154 };
7155
7156
7157 // $ANTLR start "ctfSpecifierHead"
73511e67 7158 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:604:1: ctfSpecifierHead : ( EVENTTOK -> EVENT | STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK );
9ad3c628
AM		 7159 public final CTFParser.ctfSpecifierHead_return ctfSpecifierHead() throws RecognitionException {
7160 CTFParser.ctfSpecifierHead_return retval = new CTFParser.ctfSpecifierHead_return();
7161 retval.start = input.LT(1);
7162
7163 CommonTree root_0 = null;
7164
7a91a2e4
MK		 7165 Token EVENTTOK161=null;
7166 Token STREAMTOK162=null;
7167 Token TRACETOK163=null;
7168 Token ENVTOK164=null;
7169 Token CLOCKTOK165=null;
7a91a2e4
MK		 7170
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;
9ad3c628 7176 RewriteRuleTokenStream stream_ENVTOK=new RewriteRuleTokenStream(adaptor,"token ENVTOK");
9ad3c628 7177 RewriteRuleTokenStream stream_TRACETOK=new RewriteRuleTokenStream(adaptor,"token TRACETOK");
73511e67
AM		 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");
9ad3c628
AM		 7181
7182 try {
73511e67
AM		 7183 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:605:3: ( EVENTTOK -> EVENT | STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK )
7184 int alt53=5;
9ad3c628
AM		 7185 switch ( input.LA(1) ) {
7186 case EVENTTOK:
7187 {
7a91a2e4 7188 alt53=1;
9ad3c628
AM		 7189 }
7190 break;
7191 case STREAMTOK:
7192 {
7a91a2e4 7193 alt53=2;
9ad3c628
AM		 7194 }
7195 break;
7196 case TRACETOK:
7197 {
7a91a2e4 7198 alt53=3;
9ad3c628
AM		 7199 }
7200 break;
7201 case ENVTOK:
7202 {
7a91a2e4 7203 alt53=4;
9ad3c628
AM		 7204 }
7205 break;
7206 case CLOCKTOK:
7207 {
7a91a2e4 7208 alt53=5;
9ad3c628
AM		 7209 }
7210 break;
9ad3c628
AM		 7211 default:
7212 if (state.backtracking>0) {state.failed=true; return retval;}
7213 NoViableAltException nvae =
7a91a2e4 7214 new NoViableAltException("", 53, 0, input);
9ad3c628
AM		 7215 throw nvae;
7216 }
7a91a2e4 7217 switch (alt53) {
9ad3c628 7218 case 1 :
73511e67 7219 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:605:5: EVENTTOK
9ad3c628 7220 {
73511e67 7221 EVENTTOK161=(Token)match(input,EVENTTOK,FOLLOW_EVENTTOK_in_ctfSpecifierHead3223); if (state.failed) return retval;
7a91a2e4 7222 if ( state.backtracking==0 ) stream_EVENTTOK.add(EVENTTOK161);
9ad3c628
AM		 7223
7224 // AST REWRITE
7225 // elements:
7226 // token labels:
7227 // rule labels: retval
7228 // token list labels:
7229 // rule list labels:
7230 // wildcard 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);
7234
7235 root_0 = (CommonTree)adaptor.nil();
73511e67 7236 // 605:14: -> EVENT
9ad3c628
AM		 7237 {
7238 adaptor.addChild(root_0, (CommonTree)adaptor.create(EVENT, "EVENT"));
7239 }
7240
7241
7242 retval.tree = root_0;
7243 }
7244
7245 }
7246 break;
7247 case 2 :
73511e67 7248 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:606:5: STREAMTOK
9ad3c628 7249 {
73511e67 7250 STREAMTOK162=(Token)match(input,STREAMTOK,FOLLOW_STREAMTOK_in_ctfSpecifierHead3233); if (state.failed) return retval;
7a91a2e4 7251 if ( state.backtracking==0 ) stream_STREAMTOK.add(STREAMTOK162);
9ad3c628
AM		 7252
7253 // AST REWRITE
7254 // elements:
7255 // token labels:
7256 // rule labels: retval
7257 // token list labels:
7258 // rule list labels:
7259 // wildcard 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);
7263
7264 root_0 = (CommonTree)adaptor.nil();
73511e67 7265 // 606:15: -> STREAM
9ad3c628
AM		 7266 {
7267 adaptor.addChild(root_0, (CommonTree)adaptor.create(STREAM, "STREAM"));
7268 }
7269
7270
7271 retval.tree = root_0;
7272 }
7273
7274 }
7275 break;
7276 case 3 :
73511e67 7277 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:607:5: TRACETOK
9ad3c628 7278 {
73511e67 7279 TRACETOK163=(Token)match(input,TRACETOK,FOLLOW_TRACETOK_in_ctfSpecifierHead3243); if (state.failed) return retval;
7a91a2e4 7280 if ( state.backtracking==0 ) stream_TRACETOK.add(TRACETOK163);
9ad3c628
AM		 7281
7282 // AST REWRITE
7283 // elements:
7284 // token labels:
7285 // rule labels: retval
7286 // token list labels:
7287 // rule list labels:
7288 // wildcard 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);
7292
7293 root_0 = (CommonTree)adaptor.nil();
73511e67 7294 // 607:14: -> TRACE
9ad3c628
AM		 7295 {
7296 adaptor.addChild(root_0, (CommonTree)adaptor.create(TRACE, "TRACE"));
7297 }
7298
7299
7300 retval.tree = root_0;
7301 }
7302
7303 }
7304 break;
7305 case 4 :
73511e67 7306 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:608:5: ENVTOK
9ad3c628 7307 {
73511e67 7308 ENVTOK164=(Token)match(input,ENVTOK,FOLLOW_ENVTOK_in_ctfSpecifierHead3253); if (state.failed) return retval;
7a91a2e4 7309 if ( state.backtracking==0 ) stream_ENVTOK.add(ENVTOK164);
9ad3c628
AM		 7310
7311 // AST REWRITE
7312 // elements:
7313 // token labels:
7314 // rule labels: retval
7315 // token list labels:
7316 // rule list labels:
7317 // wildcard 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);
7321
7322 root_0 = (CommonTree)adaptor.nil();
73511e67 7323 // 608:12: -> ENV
9ad3c628
AM		 7324 {
7325 adaptor.addChild(root_0, (CommonTree)adaptor.create(ENV, "ENV"));
7326 }
7327
7328
7329 retval.tree = root_0;
7330 }
7331
7332 }
7333 break;
7334 case 5 :
73511e67 7335 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:609:5: CLOCKTOK
9ad3c628 7336 {
73511e67 7337 CLOCKTOK165=(Token)match(input,CLOCKTOK,FOLLOW_CLOCKTOK_in_ctfSpecifierHead3263); if (state.failed) return retval;
7a91a2e4 7338 if ( state.backtracking==0 ) stream_CLOCKTOK.add(CLOCKTOK165);
9ad3c628
AM		 7339
7340 // AST REWRITE
7341 // elements:
7342 // token labels:
7343 // rule labels: retval
7344 // token list labels:
7345 // rule list labels:
7346 // wildcard 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);
7350
7351 root_0 = (CommonTree)adaptor.nil();
73511e67 7352 // 609:14: -> CLOCK
9ad3c628
AM		 7353 {
7354 adaptor.addChild(root_0, (CommonTree)adaptor.create(CLOCK, "CLOCK"));
7355 }
7356
7357
9ad3c628
AM		 7358 retval.tree = root_0;
7359 }
7360
7361 }
7362 break;
7363
7364 }
7365 retval.stop = input.LT(-1);
7366
7367 if ( state.backtracking==0 ) {
7368 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
7369 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
7370 }
7371 }
7372
7373 catch (RecognitionException e) {
7374 throw e;
7375 }
7376
7377 finally {
7378 // do for sure before leaving
7379 }
7380 return retval;
7381 }
7382 // $ANTLR end "ctfSpecifierHead"
7383
7384
7385 public static class ctfTypeSpecifier_return extends ParserRuleReturnScope {
7386 CommonTree tree;
7387 @Override
7388 public CommonTree getTree() { return tree; }
7389 };
7390
7391
7392 // $ANTLR start "ctfTypeSpecifier"
73511e67 7393 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:612:1: ctfTypeSpecifier : ( FLOATINGPOINTTOK ctfBody -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) );
9ad3c628
AM		 7394 public final CTFParser.ctfTypeSpecifier_return ctfTypeSpecifier() throws RecognitionException {
7395 CTFParser.ctfTypeSpecifier_return retval = new CTFParser.ctfTypeSpecifier_return();
7396 retval.start = input.LT(1);
7397
7398 CommonTree root_0 = null;
7399
73511e67
AM		 7400 Token FLOATINGPOINTTOK166=null;
7401 Token INTEGERTOK168=null;
7402 Token STRINGTOK170=null;
7403 ParserRuleReturnScope ctfBody167 =null;
7404 ParserRuleReturnScope ctfBody169 =null;
7405 ParserRuleReturnScope ctfBody171 =null;
9ad3c628 7406
73511e67
AM		 7407 CommonTree FLOATINGPOINTTOK166_tree=null;
7408 CommonTree INTEGERTOK168_tree=null;
7409 CommonTree STRINGTOK170_tree=null;
9ad3c628 7410 RewriteRuleTokenStream stream_FLOATINGPOINTTOK=new RewriteRuleTokenStream(adaptor,"token FLOATINGPOINTTOK");
9ad3c628 7411 RewriteRuleTokenStream stream_INTEGERTOK=new RewriteRuleTokenStream(adaptor,"token INTEGERTOK");
73511e67 7412 RewriteRuleTokenStream stream_STRINGTOK=new RewriteRuleTokenStream(adaptor,"token STRINGTOK");
9ad3c628
AM		 7413 RewriteRuleSubtreeStream stream_ctfBody=new RewriteRuleSubtreeStream(adaptor,"rule ctfBody");
7414
7415 try {
73511e67 7416 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:614:3: ( FLOATINGPOINTTOK ctfBody -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) )
7a91a2e4 7417 int alt55=3;
9ad3c628
AM		 7418 switch ( input.LA(1) ) {
7419 case FLOATINGPOINTTOK:
7420 {
7a91a2e4 7421 alt55=1;
9ad3c628
AM		 7422 }
7423 break;
7424 case INTEGERTOK:
7425 {
7a91a2e4 7426 alt55=2;
9ad3c628
AM		 7427 }
7428 break;
7429 case STRINGTOK:
7430 {
7a91a2e4 7431 alt55=3;
9ad3c628
AM		 7432 }
7433 break;
7434 default:
7435 if (state.backtracking>0) {state.failed=true; return retval;}
7436 NoViableAltException nvae =
7a91a2e4 7437 new NoViableAltException("", 55, 0, input);
9ad3c628
AM		 7438 throw nvae;
7439 }
7a91a2e4 7440 switch (alt55) {
9ad3c628 7441 case 1 :
73511e67 7442 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:614:5: FLOATINGPOINTTOK ctfBody
9ad3c628 7443 {
73511e67
AM		 7444 FLOATINGPOINTTOK166=(Token)match(input,FLOATINGPOINTTOK,FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3286); if (state.failed) return retval;
7445 if ( state.backtracking==0 ) stream_FLOATINGPOINTTOK.add(FLOATINGPOINTTOK166);
9ad3c628 7446
73511e67
AM		 7447 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3288);
7448 ctfBody167=ctfBody();
9ad3c628
AM		 7449 state._fsp--;
7450 if (state.failed) return retval;
73511e67 7451 if ( state.backtracking==0 ) stream_ctfBody.add(ctfBody167.getTree());
9ad3c628
AM		 7452 // AST REWRITE
7453 // elements: ctfBody
7454 // token labels:
7455 // rule labels: retval
7456 // token list labels:
7457 // rule list labels:
7458 // wildcard 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);
7462
7463 root_0 = (CommonTree)adaptor.nil();
73511e67 7464 // 614:30: -> ^( FLOATING_POINT ( ctfBody )? )
9ad3c628 7465 {
73511e67 7466 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:614:33: ^( FLOATING_POINT ( ctfBody )? )
9ad3c628
AM		 7467 {
7468 CommonTree root_1 = (CommonTree)adaptor.nil();
7469 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(FLOATING_POINT, "FLOATING_POINT"), root_1);
73511e67 7470 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:614:50: ( ctfBody )?
9ad3c628
AM		 7471 if ( stream_ctfBody.hasNext() ) {
7472 adaptor.addChild(root_1, stream_ctfBody.nextTree());
7473 }
7474 stream_ctfBody.reset();
7475
7476 adaptor.addChild(root_0, root_1);
7477 }
7478
7479 }
7480
7481
7482 retval.tree = root_0;
7483 }
7484
7485 }
7486 break;
7487 case 2 :
73511e67 7488 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:615:5: INTEGERTOK ctfBody
9ad3c628 7489 {
73511e67
AM		 7490 INTEGERTOK168=(Token)match(input,INTEGERTOK,FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3303); if (state.failed) return retval;
7491 if ( state.backtracking==0 ) stream_INTEGERTOK.add(INTEGERTOK168);
9ad3c628 7492
73511e67
AM		 7493 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3305);
7494 ctfBody169=ctfBody();
9ad3c628
AM		 7495 state._fsp--;
7496 if (state.failed) return retval;
73511e67 7497 if ( state.backtracking==0 ) stream_ctfBody.add(ctfBody169.getTree());
9ad3c628
AM		 7498 // AST REWRITE
7499 // elements: ctfBody
7500 // token labels:
7501 // rule labels: retval
7502 // token list labels:
7503 // rule list labels:
7504 // wildcard 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);
7508
7509 root_0 = (CommonTree)adaptor.nil();
73511e67 7510 // 615:24: -> ^( INTEGER ( ctfBody )? )
9ad3c628 7511 {
73511e67 7512 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:615:27: ^( INTEGER ( ctfBody )? )
9ad3c628
AM		 7513 {
7514 CommonTree root_1 = (CommonTree)adaptor.nil();
7515 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(INTEGER, "INTEGER"), root_1);
73511e67 7516 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:615:37: ( ctfBody )?
9ad3c628
AM		 7517 if ( stream_ctfBody.hasNext() ) {
7518 adaptor.addChild(root_1, stream_ctfBody.nextTree());
7519 }
7520 stream_ctfBody.reset();
7521
7522 adaptor.addChild(root_0, root_1);
7523 }
7524
7525 }
7526
7527
7528 retval.tree = root_0;
7529 }
7530
7531 }
7532 break;
7533 case 3 :
73511e67 7534 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:5: STRINGTOK ( ctfBody )?
9ad3c628 7535 {
73511e67
AM		 7536 STRINGTOK170=(Token)match(input,STRINGTOK,FOLLOW_STRINGTOK_in_ctfTypeSpecifier3320); if (state.failed) return retval;
7537 if ( state.backtracking==0 ) stream_STRINGTOK.add(STRINGTOK170);
9ad3c628 7538
73511e67 7539 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:15: ( ctfBody )?
7a91a2e4
MK		 7540 int alt54=2;
7541 int LA54_0 = input.LA(1);
7542 if ( (LA54_0==LCURL) ) {
7543 alt54=1;
9ad3c628 7544 }
7a91a2e4 7545 switch (alt54) {
9ad3c628 7546 case 1 :
73511e67 7547 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:15: ctfBody
9ad3c628 7548 {
73511e67
AM		 7549 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3322);
7550 ctfBody171=ctfBody();
9ad3c628
AM		 7551 state._fsp--;
7552 if (state.failed) return retval;
73511e67 7553 if ( state.backtracking==0 ) stream_ctfBody.add(ctfBody171.getTree());
9ad3c628
AM		 7554 }
7555 break;
7556
7557 }
7558
7559 // AST REWRITE
7560 // elements: ctfBody
7561 // token labels:
7562 // rule labels: retval
7563 // token list labels:
7564 // rule list labels:
7565 // wildcard 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);
7569
7570 root_0 = (CommonTree)adaptor.nil();
73511e67 7571 // 616:24: -> ^( STRING ( ctfBody )? )
9ad3c628 7572 {
73511e67 7573 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:27: ^( STRING ( ctfBody )? )
9ad3c628
AM		 7574 {
7575 CommonTree root_1 = (CommonTree)adaptor.nil();
7576 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(STRING, "STRING"), root_1);
73511e67 7577 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:616:36: ( ctfBody )?
9ad3c628
AM		 7578 if ( stream_ctfBody.hasNext() ) {
7579 adaptor.addChild(root_1, stream_ctfBody.nextTree());
7580 }
7581 stream_ctfBody.reset();
7582
7583 adaptor.addChild(root_0, root_1);
7584 }
7585
7586 }
7587
7588
7589 retval.tree = root_0;
7590 }
7591
7592 }
7593 break;
7594
7595 }
7596 retval.stop = input.LT(-1);
7597
7598 if ( state.backtracking==0 ) {
7599 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
7600 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
7601 }
7602 }
7603
7604 catch (RecognitionException e) {
7605 throw e;
7606 }
7607
7608 finally {
7609 // do for sure before leaving
7610 }
7611 return retval;
7612 }
7613 // $ANTLR end "ctfTypeSpecifier"
7614
7615
7616 public static class ctfBody_return extends ParserRuleReturnScope {
7617 CommonTree tree;
7618 @Override
7619 public CommonTree getTree() { return tree; }
7620 };
7621
7622
7623 // $ANTLR start "ctfBody"
73511e67 7624 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:619:1: ctfBody : LCURL ( ctfAssignmentExpressionList )? RCURL -> ( ctfAssignmentExpressionList )? ;
9ad3c628
AM		 7625 public final CTFParser.ctfBody_return ctfBody() throws RecognitionException {
7626 Symbols_stack.push(new Symbols_scope());
7627
7628 CTFParser.ctfBody_return retval = new CTFParser.ctfBody_return();
7629 retval.start = input.LT(1);
7630
7631 CommonTree root_0 = null;
7632
73511e67
AM		 7633 Token LCURL172=null;
7634 Token RCURL174=null;
7635 ParserRuleReturnScope ctfAssignmentExpressionList173 =null;
9ad3c628 7636
73511e67
AM		 7637 CommonTree LCURL172_tree=null;
7638 CommonTree RCURL174_tree=null;
9ad3c628
AM		 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");
7642
7643
7644 Symbols_stack.peek().types = new HashSet<String>();
7645
7646 try {
73511e67
AM		 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
9ad3c628 7649 {
73511e67
AM		 7650 LCURL172=(Token)match(input,LCURL,FOLLOW_LCURL_in_ctfBody3355); if (state.failed) return retval;
7651 if ( state.backtracking==0 ) stream_LCURL.add(LCURL172);
9ad3c628 7652
73511e67 7653 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:624:11: ( ctfAssignmentExpressionList )?
7a91a2e4
MK		 7654 int alt56=2;
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)) ) {
7657 alt56=1;
9ad3c628 7658 }
7a91a2e4 7659 switch (alt56) {
9ad3c628 7660 case 1 :
73511e67 7661 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:624:11: ctfAssignmentExpressionList
9ad3c628 7662 {
73511e67
AM		 7663 pushFollow(FOLLOW_ctfAssignmentExpressionList_in_ctfBody3357);
7664 ctfAssignmentExpressionList173=ctfAssignmentExpressionList();
9ad3c628
AM		 7665 state._fsp--;
7666 if (state.failed) return retval;
73511e67 7667 if ( state.backtracking==0 ) stream_ctfAssignmentExpressionList.add(ctfAssignmentExpressionList173.getTree());
9ad3c628
AM		 7668 }
7669 break;
7670
7671 }
7672
73511e67
AM		 7673 RCURL174=(Token)match(input,RCURL,FOLLOW_RCURL_in_ctfBody3360); if (state.failed) return retval;
7674 if ( state.backtracking==0 ) stream_RCURL.add(RCURL174);
9ad3c628
AM		 7675
7676 // AST REWRITE
7677 // elements: ctfAssignmentExpressionList
7678 // token labels:
7679 // rule labels: retval
7680 // token list labels:
7681 // rule list labels:
7682 // wildcard 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);
7686
7687 root_0 = (CommonTree)adaptor.nil();
73511e67 7688 // 624:46: -> ( ctfAssignmentExpressionList )?
9ad3c628 7689 {
73511e67 7690 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:624:49: ( ctfAssignmentExpressionList )?
9ad3c628
AM		 7691 if ( stream_ctfAssignmentExpressionList.hasNext() ) {
7692 adaptor.addChild(root_0, stream_ctfAssignmentExpressionList.nextTree());
7693 }
7694 stream_ctfAssignmentExpressionList.reset();
7695
7696 }
7697
7698
7699 retval.tree = root_0;
7700 }
7701
7702 }
7703
7704 retval.stop = input.LT(-1);
7705
7706 if ( state.backtracking==0 ) {
7707 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
7708 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
7709 }
7710 }
7711
7712 catch (RecognitionException e) {
7713 throw e;
7714 }
7715
7716 finally {
7717 // do for sure before leaving
7718 Symbols_stack.pop();
7719
7720 }
7721 return retval;
7722 }
7723 // $ANTLR end "ctfBody"
7724
7725
7726 public static class ctfAssignmentExpressionList_return extends ParserRuleReturnScope {
7727 CommonTree tree;
7728 @Override
7729 public CommonTree getTree() { return tree; }
7730 };
7731
7732
7733 // $ANTLR start "ctfAssignmentExpressionList"
73511e67 7734 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:627:1: ctfAssignmentExpressionList : ( ctfAssignmentExpression TERM !)+ ;
9ad3c628
AM		 7735 public final CTFParser.ctfAssignmentExpressionList_return ctfAssignmentExpressionList() throws RecognitionException {
7736 CTFParser.ctfAssignmentExpressionList_return retval = new CTFParser.ctfAssignmentExpressionList_return();
7737 retval.start = input.LT(1);
7738
7739 CommonTree root_0 = null;
7740
73511e67
AM		 7741 Token TERM176=null;
7742 ParserRuleReturnScope ctfAssignmentExpression175 =null;
9ad3c628 7743
73511e67 7744 CommonTree TERM176_tree=null;
9ad3c628
AM		 7745
7746 try {
73511e67
AM		 7747 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:628:3: ( ( ctfAssignmentExpression TERM !)+ )
7748 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:628:5: ( ctfAssignmentExpression TERM !)+
9ad3c628
AM		 7749 {
7750 root_0 = (CommonTree)adaptor.nil();
7751
7752
73511e67 7753 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:628:5: ( ctfAssignmentExpression TERM !)+
7a91a2e4
MK		 7754 int cnt57=0;
7755 loop57:
9ad3c628 7756 while (true) {
7a91a2e4
MK		 7757 int alt57=2;
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)) ) {
7760 alt57=1;
9ad3c628
AM		 7761 }
7762
7a91a2e4 7763 switch (alt57) {
9ad3c628 7764 case 1 :
73511e67 7765 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:628:6: ctfAssignmentExpression TERM !
9ad3c628 7766 {
73511e67
AM		 7767 pushFollow(FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3379);
7768 ctfAssignmentExpression175=ctfAssignmentExpression();
9ad3c628
AM		 7769 state._fsp--;
7770 if (state.failed) return retval;
73511e67 7771 if ( state.backtracking==0 ) adaptor.addChild(root_0, ctfAssignmentExpression175.getTree());
9ad3c628 7772
73511e67 7773 TERM176=(Token)match(input,TERM,FOLLOW_TERM_in_ctfAssignmentExpressionList3381); if (state.failed) return retval;
9ad3c628
AM		 7774 }
7775 break;
7776
7777 default :
7a91a2e4 7778 if ( cnt57 >= 1 ) break loop57;
9ad3c628 7779 if (state.backtracking>0) {state.failed=true; return retval;}
7a91a2e4 7780 EarlyExitException eee = new EarlyExitException(57, input);
9ad3c628
AM		 7781 throw eee;
7782 }
7a91a2e4 7783 cnt57++;
9ad3c628
AM		 7784 }
7785
7786 }
7787
7788 retval.stop = input.LT(-1);
7789
7790 if ( state.backtracking==0 ) {
7791 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
7792 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
7793 }
7794 }
7795
7796 catch (RecognitionException e) {
7797 throw e;
7798 }
7799
7800 finally {
7801 // do for sure before leaving
7802 }
7803 return retval;
7804 }
7805 // $ANTLR end "ctfAssignmentExpressionList"
7806
7807
7808 public static class ctfAssignmentExpression_return extends ParserRuleReturnScope {
7809 CommonTree tree;
7810 @Override
7811 public CommonTree getTree() { return tree; }
7812 };
7813
7814
7815 // $ANTLR start "ctfAssignmentExpression"
73511e67 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 );
9ad3c628
AM		 7817 public final CTFParser.ctfAssignmentExpression_return ctfAssignmentExpression() throws RecognitionException {
7818 CTFParser.ctfAssignmentExpression_return retval = new CTFParser.ctfAssignmentExpression_return();
7819 retval.start = input.LT(1);
7820
7821 CommonTree root_0 = null;
7822
7823 Token assignment=null;
7824 Token type_assignment=null;
7825 ParserRuleReturnScope left =null;
7826 ParserRuleReturnScope right1 =null;
7827 ParserRuleReturnScope right2 =null;
73511e67
AM		 7828 ParserRuleReturnScope declarationSpecifiers177 =null;
7829 ParserRuleReturnScope declaratorList178 =null;
7830 ParserRuleReturnScope typealiasDecl179 =null;
9ad3c628
AM		 7831
7832 CommonTree assignment_tree=null;
7833 CommonTree type_assignment_tree=null;
9ad3c628 7834 RewriteRuleTokenStream stream_TYPE_ASSIGNMENT=new RewriteRuleTokenStream(adaptor,"token TYPE_ASSIGNMENT");
73511e67 7835 RewriteRuleTokenStream stream_ASSIGNMENT=new RewriteRuleTokenStream(adaptor,"token ASSIGNMENT");
9ad3c628 7836 RewriteRuleSubtreeStream stream_declaratorList=new RewriteRuleSubtreeStream(adaptor,"rule declaratorList");
73511e67 7837 RewriteRuleSubtreeStream stream_typeSpecifier=new RewriteRuleSubtreeStream(adaptor,"rule typeSpecifier");
9ad3c628
AM		 7838 RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
7839 RewriteRuleSubtreeStream stream_declarationSpecifiers=new RewriteRuleSubtreeStream(adaptor,"rule declarationSpecifiers");
9ad3c628
AM		 7840
7841 try {
73511e67 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 )
7a91a2e4 7843 int alt59=3;
9ad3c628
AM		 7844 switch ( input.LA(1) ) {
7845 case IDENTIFIER:
7846 {
7a91a2e4
MK		 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) ) {
7849 alt59=1;
9ad3c628 7850 }
7a91a2e4
MK		 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()) ))) {
7852 alt59=2;
9ad3c628
AM		 7853 }
7854
7855 }
7856 break;
7857 case ALIGNTOK:
9ad3c628
AM		 7858 case CHARACTER_LITERAL:
7859 case CLOCKTOK:
7860 case DECIMAL_LITERAL:
7861 case ENVTOK:
7862 case EVENTTOK:
7863 case HEX_LITERAL:
7864 case OCTAL_LITERAL:
7865 case SIGN:
7866 case STREAMTOK:
7867 case STRING_LITERAL:
7868 case TRACETOK:
7869 {
7a91a2e4 7870 alt59=1;
9ad3c628
AM		 7871 }
7872 break;
7873 case SIGNEDTOK:
7874 {
7875 switch ( input.LA(2) ) {
7876 case ARROW:
7877 case ASSIGNMENT:
7878 case DOT:
7879 case OPENBRAC:
7880 case TYPE_ASSIGNMENT:
7881 {
7a91a2e4 7882 alt59=1;
9ad3c628
AM		 7883 }
7884 break;
7885 case BOOLTOK:
7886 case CHARTOK:
7887 case COMPLEXTOK:
7888 case CONSTTOK:
7889 case DOUBLETOK:
7890 case ENUMTOK:
7891 case FLOATINGPOINTTOK:
7892 case FLOATTOK:
7893 case IDENTIFIER:
7894 case IMAGINARYTOK:
7895 case INTEGERTOK:
7896 case INTTOK:
7897 case LONGTOK:
7898 case POINTER:
7899 case SHORTTOK:
7900 case SIGNEDTOK:
7901 case STRINGTOK:
7902 case STRUCTTOK:
7903 case UNSIGNEDTOK:
7904 case VARIANTTOK:
7905 case VOIDTOK:
7906 {
7a91a2e4 7907 alt59=2;
9ad3c628
AM		 7908 }
7909 break;
7910 case TYPEDEFTOK:
7911 {
7a91a2e4 7912 alt59=2;
9ad3c628
AM		 7913 }
7914 break;
7915 default:
7916 if (state.backtracking>0) {state.failed=true; return retval;}
7917 int nvaeMark = input.mark();
7918 try {
7919 input.consume();
7920 NoViableAltException nvae =
7a91a2e4 7921 new NoViableAltException("", 59, 3, input);
9ad3c628
AM		 7922 throw nvae;
7923 } finally {
7924 input.rewind(nvaeMark);
7925 }
7926 }
7927 }
7928 break;
7929 case BOOLTOK:
7930 case CHARTOK:
7931 case COMPLEXTOK:
7932 case CONSTTOK:
7933 case DOUBLETOK:
7934 case ENUMTOK:
7935 case FLOATINGPOINTTOK:
7936 case FLOATTOK:
7937 case IMAGINARYTOK:
7938 case INTEGERTOK:
7939 case INTTOK:
7940 case LONGTOK:
7941 case SHORTTOK:
7942 case STRUCTTOK:
7943 case TYPEDEFTOK:
7944 case UNSIGNEDTOK:
7945 case VARIANTTOK:
7946 case VOIDTOK:
7947 {
7a91a2e4 7948 alt59=2;
9ad3c628
AM		 7949 }
7950 break;
7951 case STRINGTOK:
7952 {
7953 switch ( input.LA(2) ) {
7954 case ARROW:
7955 case ASSIGNMENT:
7956 case DOT:
7957 case OPENBRAC:
7958 case TYPE_ASSIGNMENT:
7959 {
7a91a2e4 7960 alt59=1;
9ad3c628
AM		 7961 }
7962 break;
7963 case BOOLTOK:
7964 case CHARTOK:
7965 case COMPLEXTOK:
7966 case CONSTTOK:
7967 case DOUBLETOK:
7968 case ENUMTOK:
7969 case FLOATINGPOINTTOK:
7970 case FLOATTOK:
7971 case IDENTIFIER:
7972 case IMAGINARYTOK:
7973 case INTEGERTOK:
7974 case INTTOK:
7975 case LCURL:
7976 case LONGTOK:
7977 case POINTER:
7978 case SHORTTOK:
7979 case SIGNEDTOK:
7980 case STRINGTOK:
7981 case STRUCTTOK:
7982 case UNSIGNEDTOK:
7983 case VARIANTTOK:
7984 case VOIDTOK:
7985 {
7a91a2e4 7986 alt59=2;
9ad3c628
AM		 7987 }
7988 break;
7989 case TYPEDEFTOK:
7990 {
7a91a2e4 7991 alt59=2;
9ad3c628
AM		 7992 }
7993 break;
7994 default:
7995 if (state.backtracking>0) {state.failed=true; return retval;}
7996 int nvaeMark = input.mark();
7997 try {
7998 input.consume();
7999 NoViableAltException nvae =
7a91a2e4 8000 new NoViableAltException("", 59, 5, input);
9ad3c628
AM		 8001 throw nvae;
8002 } finally {
8003 input.rewind(nvaeMark);
8004 }
8005 }
8006 }
8007 break;
8008 case TYPEALIASTOK:
8009 {
7a91a2e4 8010 alt59=3;
9ad3c628
AM		 8011 }
8012 break;
8013 default:
8014 if (state.backtracking>0) {state.failed=true; return retval;}
8015 NoViableAltException nvae =
7a91a2e4 8016 new NoViableAltException("", 59, 0, input);
9ad3c628
AM		 8017 throw nvae;
8018 }
7a91a2e4 8019 switch (alt59) {
9ad3c628 8020 case 1 :
73511e67 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) ) ) )
9ad3c628 8022 {
73511e67 8023 pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3404);
9ad3c628
AM		 8024 left=unaryExpression();
8025 state._fsp--;
8026 if (state.failed) return retval;
8027 if ( state.backtracking==0 ) stream_unaryExpression.add(left.getTree());
73511e67 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) ) ) )
7a91a2e4
MK		 8029 int alt58=2;
8030 int LA58_0 = input.LA(1);
8031 if ( (LA58_0==ASSIGNMENT) ) {
8032 alt58=1;
9ad3c628 8033 }
7a91a2e4
MK		 8034 else if ( (LA58_0==TYPE_ASSIGNMENT) ) {
8035 alt58=2;
9ad3c628
AM		 8036 }
8037
8038 else {
8039 if (state.backtracking>0) {state.failed=true; return retval;}
8040 NoViableAltException nvae =
7a91a2e4 8041 new NoViableAltException("", 58, 0, input);
9ad3c628
AM		 8042 throw nvae;
8043 }
8044
7a91a2e4 8045 switch (alt58) {
9ad3c628 8046 case 1 :
73511e67 8047 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:638:9: assignment= ASSIGNMENT right1= unaryExpression
9ad3c628 8048 {
73511e67 8049 assignment=(Token)match(input,ASSIGNMENT,FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3416); if (state.failed) return retval;
9ad3c628
AM		 8050 if ( state.backtracking==0 ) stream_ASSIGNMENT.add(assignment);
8051
73511e67 8052 pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3420);
9ad3c628
AM		 8053 right1=unaryExpression();
8054 state._fsp--;
8055 if (state.failed) return retval;
8056 if ( state.backtracking==0 ) stream_unaryExpression.add(right1.getTree());
8057 // AST REWRITE
73511e67 8058 // elements: right1, left
9ad3c628 8059 // token labels:
73511e67 8060 // rule labels: right1, left, retval
9ad3c628
AM		 8061 // token list labels:
8062 // rule list labels:
8063 // wildcard labels:
8064 if ( state.backtracking==0 ) {
8065 retval.tree = root_0;
9ad3c628 8066 RewriteRuleSubtreeStream stream_right1=new RewriteRuleSubtreeStream(adaptor,"rule right1",right1!=null?right1.getTree():null);
73511e67
AM		 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);
9ad3c628
AM		 8069
8070 root_0 = (CommonTree)adaptor.nil();
73511e67 8071 // 639:11: -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
9ad3c628 8072 {
73511e67 8073 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:639:14: ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
9ad3c628
AM		 8074 {
8075 CommonTree root_1 = (CommonTree)adaptor.nil();
8076 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_EXPRESSION_VAL, "CTF_EXPRESSION_VAL"), root_1);
73511e67 8077 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:640:18: ^( CTF_LEFT $left)
9ad3c628
AM		 8078 {
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);
8083 }
8084
73511e67 8085 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:641:18: ^( CTF_RIGHT $right1)
9ad3c628
AM		 8086 {
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);
8091 }
8092
8093 adaptor.addChild(root_0, root_1);
8094 }
8095
8096 }
8097
8098
8099 retval.tree = root_0;
8100 }
8101
8102 }
8103 break;
8104 case 2 :
73511e67 8105 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:642:9: type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier
9ad3c628 8106 {
73511e67 8107 type_assignment=(Token)match(input,TYPE_ASSIGNMENT,FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3496); if (state.failed) return retval;
9ad3c628
AM		 8108 if ( state.backtracking==0 ) stream_TYPE_ASSIGNMENT.add(type_assignment);
8109
73511e67 8110 pushFollow(FOLLOW_typeSpecifier_in_ctfAssignmentExpression3500);
9ad3c628
AM		 8111 right2=typeSpecifier();
8112 state._fsp--;
8113 if (state.failed) return retval;
8114 if ( state.backtracking==0 ) stream_typeSpecifier.add(right2.getTree());
8115 // AST REWRITE
73511e67 8116 // elements: left, right2
9ad3c628 8117 // token labels:
73511e67 8118 // rule labels: left, right2, retval
9ad3c628
AM		 8119 // token list labels:
8120 // rule list labels:
8121 // wildcard labels:
8122 if ( state.backtracking==0 ) {
8123 retval.tree = root_0;
9ad3c628
AM		 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);
73511e67 8126 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
9ad3c628
AM		 8127
8128 root_0 = (CommonTree)adaptor.nil();
73511e67 8129 // 643:11: -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
9ad3c628 8130 {
73511e67 8131 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:643:14: ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
9ad3c628
AM		 8132 {
8133 CommonTree root_1 = (CommonTree)adaptor.nil();
8134 root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_EXPRESSION_TYPE, "CTF_EXPRESSION_TYPE"), root_1);
73511e67 8135 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:644:18: ^( CTF_LEFT $left)
9ad3c628
AM		 8136 {
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);
8141 }
8142
73511e67 8143 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:645:18: ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) )
9ad3c628
AM		 8144 {
8145 CommonTree root_2 = (CommonTree)adaptor.nil();
8146 root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_RIGHT, "CTF_RIGHT"), root_2);
73511e67 8147 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:645:30: ^( TYPE_SPECIFIER_LIST $right2)
9ad3c628
AM		 8148 {
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);
8153 }
8154
8155 adaptor.addChild(root_1, root_2);
8156 }
8157
8158 adaptor.addChild(root_0, root_1);
8159 }
8160
8161 }
8162
8163
8164 retval.tree = root_0;
8165 }
8166
8167 }
8168 break;
8169
8170 }
8171
8172 }
8173 break;
8174 case 2 :
73511e67 8175 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:647:5: ( declarationSpecifiers {...}? declaratorList )
9ad3c628 8176 {
73511e67
AM		 8177 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:647:5: ( declarationSpecifiers {...}? declaratorList )
8178 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:647:6: declarationSpecifiers {...}? declaratorList
9ad3c628 8179 {
73511e67
AM		 8180 pushFollow(FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3583);
8181 declarationSpecifiers177=declarationSpecifiers();
9ad3c628
AM		 8182 state._fsp--;
8183 if (state.failed) return retval;
73511e67 8184 if ( state.backtracking==0 ) stream_declarationSpecifiers.add(declarationSpecifiers177.getTree());
9ad3c628
AM		 8185 if ( !((inTypedef())) ) {
8186 if (state.backtracking>0) {state.failed=true; return retval;}
8187 throw new FailedPredicateException(input, "ctfAssignmentExpression", "inTypedef()");
8188 }
73511e67
AM		 8189 pushFollow(FOLLOW_declaratorList_in_ctfAssignmentExpression3587);
8190 declaratorList178=declaratorList();
9ad3c628
AM		 8191 state._fsp--;
8192 if (state.failed) return retval;
73511e67 8193 if ( state.backtracking==0 ) stream_declaratorList.add(declaratorList178.getTree());
9ad3c628
AM		 8194 }
8195
8196 // AST REWRITE
8197 // elements: declarationSpecifiers, declaratorList
8198 // token labels:
8199 // rule labels: retval
8200 // token list labels:
8201 // rule list labels:
8202 // wildcard 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);
8206
8207 root_0 = (CommonTree)adaptor.nil();
73511e67 8208 // 648:7: -> ^( TYPEDEF declaratorList declarationSpecifiers )
9ad3c628 8209 {
73511e67 8210 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:648:10: ^( TYPEDEF declaratorList declarationSpecifiers )
9ad3c628
AM		 8211 {
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);
8217 }
8218
8219 }
8220
8221
8222 retval.tree = root_0;
8223 }
8224
8225 }
8226 break;
8227 case 3 :
73511e67 8228 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:649:5: typealiasDecl
9ad3c628
AM		 8229 {
8230 root_0 = (CommonTree)adaptor.nil();
8231
8232
73511e67
AM		 8233 pushFollow(FOLLOW_typealiasDecl_in_ctfAssignmentExpression3610);
8234 typealiasDecl179=typealiasDecl();
9ad3c628
AM		 8235 state._fsp--;
8236 if (state.failed) return retval;
73511e67 8237 if ( state.backtracking==0 ) adaptor.addChild(root_0, typealiasDecl179.getTree());
9ad3c628
AM		 8238
8239 }
8240 break;
8241
8242 }
8243 retval.stop = input.LT(-1);
8244
8245 if ( state.backtracking==0 ) {
8246 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
8247 adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
8248 }
8249 if ( state.backtracking==0 ) {
8250 if (inTypedef()) {
8251 typedefOff();
8252 }
8253 }
8254 }
8255
8256 catch (RecognitionException e) {
8257 throw e;
8258 }
8259
8260 finally {
8261 // do for sure before leaving
8262 }
8263 return retval;
8264 }
8265 // $ANTLR end "ctfAssignmentExpression"
8266
8267 // $ANTLR start synpred1_CTFParser
8268 public final void synpred1_CTFParser_fragment() throws RecognitionException {
73511e67
AM		 8269 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:206:5: ( IDENTIFIER )
8270 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:206:6: IDENTIFIER
9ad3c628 8271 {
73511e67 8272 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred1_CTFParser553); if (state.failed) return;
9ad3c628
AM		 8273
8274 }
8275
8276 }
8277 // $ANTLR end synpred1_CTFParser
8278
8279 // $ANTLR start synpred2_CTFParser
8280 public final void synpred2_CTFParser_fragment() throws RecognitionException {
73511e67
AM		 8281 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:208:5: ( ctfKeyword )
8282 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:208:6: ctfKeyword
9ad3c628 8283 {
73511e67 8284 pushFollow(FOLLOW_ctfKeyword_in_synpred2_CTFParser579);
9ad3c628
AM		 8285 ctfKeyword();
8286 state._fsp--;
8287 if (state.failed) return;
8288
8289 }
8290
8291 }
8292 // $ANTLR end synpred2_CTFParser
8293
8294 // $ANTLR start synpred3_CTFParser
8295 public final void synpred3_CTFParser_fragment() throws RecognitionException {
73511e67
AM		 8296 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:209:5: ( STRING_LITERAL )
8297 // org/eclipse/tracecompass/ctf/parser/CTFParser.g:209:6: STRING_LITERAL
9ad3c628 8298 {
73511e67 8299 match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_synpred3_CTFParser599); if (state.failed) return;
9ad3c628
AM		 8300
8301 }
8302
8303 }
8304 // $ANTLR end synpred3_CTFParser
8305
8306 // Delegated rules
8307
73511e67 8308 public final boolean synpred1_CTFParser() {
9ad3c628
AM		 8309 state.backtracking++;
8310 int start = input.mark();
8311 try {
73511e67 8312 synpred1_CTFParser_fragment(); // can never throw exception
9ad3c628
AM		 8313 } catch (RecognitionException re) {
8314 System.err.println("impossible: "+re);
8315 }
8316 boolean success = !state.failed;
8317 input.rewind(start);
8318 state.backtracking--;
8319 state.failed=false;
8320 return success;
8321 }
73511e67 8322 public final boolean synpred3_CTFParser() {
9ad3c628
AM		 8323 state.backtracking++;
8324 int start = input.mark();
8325 try {
73511e67 8326 synpred3_CTFParser_fragment(); // can never throw exception
9ad3c628
AM		 8327 } catch (RecognitionException re) {
8328 System.err.println("impossible: "+re);
8329 }
8330 boolean success = !state.failed;
8331 input.rewind(start);
8332 state.backtracking--;
8333 state.failed=false;
8334 return success;
8335 }
73511e67 8336 public final boolean synpred2_CTFParser() {
9ad3c628
AM		 8337 state.backtracking++;
8338 int start = input.mark();
8339 try {
73511e67 8340 synpred2_CTFParser_fragment(); // can never throw exception
9ad3c628
AM		 8341 } catch (RecognitionException re) {
8342 System.err.println("impossible: "+re);
8343 }
8344 boolean success = !state.failed;
8345 input.rewind(start);
8346 state.backtracking--;
8347 state.failed=false;
8348 return success;
8349 }
8350
8351
7a91a2e4
MK		 8352 protected DFA24 dfa24 = new DFA24(this);
8353 static final String DFA24_eotS =
9ad3c628 8354 "\10\uffff";
7a91a2e4 8355 static final String DFA24_eofS =
9ad3c628 8356 "\10\uffff";
7a91a2e4 8357 static final String DFA24_minS =
73511e67 8358 "\1\45\1\23\1\0\1\23\1\0\2\uffff\1\0";
7a91a2e4 8359 static final String DFA24_maxS =
73511e67 8360 "\2\71\1\0\1\71\1\0\2\uffff\1\0";
7a91a2e4 8361 static final String DFA24_acceptS =
9ad3c628 8362 "\5\uffff\1\1\1\2\1\uffff";
7a91a2e4 8363 static final String DFA24_specialS =
73511e67 8364 "\2\uffff\1\0\1\uffff\1\1\2\uffff\1\2}>";
7a91a2e4 8365 static final String[] DFA24_transitionS = {
9ad3c628
AM		 8366 "\1\2\23\uffff\1\1",
8367 "\1\3\21\uffff\1\4\23\uffff\1\1",
8368 "\1\uffff",
8369 "\1\3\21\uffff\1\7\23\uffff\1\1",
8370 "\1\uffff",
8371 "",
8372 "",
8373 "\1\uffff"
8374 };
8375
7a91a2e4
MK		 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;
9ad3c628
AM		 8383
8384 static {
7a91a2e4
MK		 8385 int numStates = DFA24_transitionS.length;
8386 DFA24_transition = new short[numStates][];
9ad3c628 8387 for (int i=0; i<numStates; i++) {
7a91a2e4 8388 DFA24_transition[i] = DFA.unpackEncodedString(DFA24_transitionS[i]);
9ad3c628
AM		 8389 }
8390 }
8391
7a91a2e4 8392 protected class DFA24 extends DFA {
9ad3c628 8393
7a91a2e4 8394 public DFA24(BaseRecognizer recognizer) {
9ad3c628 8395 this.recognizer = recognizer;
7a91a2e4
MK		 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;
9ad3c628
AM		 8404 }
8405 @Override
8406 public String getDescription() {
73511e67 8407 return "371:10: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )";
9ad3c628
AM		 8408 }
8409 @Override
8410 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
8411 TokenStream input = (TokenStream)_input;
8412 int _s = s;
8413 switch ( s ) {
8414 case 0 :
73511e67 8415 int LA24_2 = input.LA(1);
9ad3c628 8416
73511e67 8417 int index24_2 = input.index();
9ad3c628
AM		 8418 input.rewind();
8419 s = -1;
8420 if ( ((inTypedef())) ) {s = 5;}
8421 else if ( (true) ) {s = 6;}
8422
73511e67 8423 input.seek(index24_2);
9ad3c628
AM		 8424 if ( s>=0 ) return s;
8425 break;
8426
8427 case 1 :
7a91a2e4 8428 int LA24_4 = input.LA(1);
9ad3c628 8429
7a91a2e4 8430 int index24_4 = input.index();
9ad3c628
AM		 8431 input.rewind();
8432 s = -1;
8433 if ( ((inTypedef())) ) {s = 5;}
8434 else if ( (true) ) {s = 6;}
8435
7a91a2e4 8436 input.seek(index24_4);
9ad3c628
AM		 8437 if ( s>=0 ) return s;
8438 break;
8439
8440 case 2 :
73511e67 8441 int LA24_7 = input.LA(1);
9ad3c628 8442
73511e67 8443 int index24_7 = input.index();
9ad3c628
AM		 8444 input.rewind();
8445 s = -1;
8446 if ( ((inTypedef())) ) {s = 5;}
8447 else if ( (true) ) {s = 6;}
8448
73511e67 8449 input.seek(index24_7);
9ad3c628
AM		 8450 if ( s>=0 ) return s;
8451 break;
8452 }
8453 if (state.backtracking>0) {state.failed=true; return -1;}
8454 NoViableAltException nvae =
7a91a2e4 8455 new NoViableAltException(getDescription(), 24, _s, input);
9ad3c628
AM		 8456 error(nvae);
8457 throw nvae;
8458 }
8459 }
8460
73511e67
AM		 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});
8460a46d 8559 public static final BitSet FOLLOW_variantBody_in_variantSpecifier2118 = new BitSet(new long[]{0x0000000000000002L});
73511e67
AM		 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});
8460a46d 8633 public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3305 = new BitSet(new long[]{0x0000000000000002L});
73511e67 8634 public static final BitSet FOLLOW_STRINGTOK_in_ctfTypeSpecifier3320 = new BitSet(new long[]{0x0000080000000002L});
8460a46d 8635 public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3322 = new BitSet(new long[]{0x0000000000000002L});
73511e67
AM		 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});
9ad3c628 8652}
Tracecompass - Deliverables
This page took 0.468403 seconds and 5 git commands to generate.