projects / deliverable / tracecompass.git / blob
? search:


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