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


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