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