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