org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFParser.java

   1 // $ANTLR !Unknown version! Grammar/CTFParser.g 2012-03-09 14:59:18
   2
   3 package org.eclipse.linuxtools.ctf.parser;
   4
   5 import java.util.HashSet;
   6 import java.util.Set;
   7 import java.util.Stack;
   8
   9 import org.antlr.runtime.BaseRecognizer;
  10 import org.antlr.runtime.BitSet;
  11 import org.antlr.runtime.DFA;
  12 import org.antlr.runtime.EarlyExitException;
  13 import org.antlr.runtime.FailedPredicateException;
  14 import org.antlr.runtime.IntStream;
  15 import org.antlr.runtime.MismatchedSetException;
  16 import org.antlr.runtime.MismatchedTokenException;
  17 import org.antlr.runtime.NoViableAltException;
  18 import org.antlr.runtime.Parser;
  19 import org.antlr.runtime.ParserRuleReturnScope;
  20 import org.antlr.runtime.RecognitionException;
  21 import org.antlr.runtime.RecognizerSharedState;
  22 import org.antlr.runtime.Token;
  23 import org.antlr.runtime.TokenStream;
  24 import org.antlr.runtime.tree.CommonTree;
  25 import org.antlr.runtime.tree.CommonTreeAdaptor;
  26 import org.antlr.runtime.tree.RewriteEarlyExitException;
  27 import org.antlr.runtime.tree.RewriteRuleSubtreeStream;
  28 import org.antlr.runtime.tree.RewriteRuleTokenStream;
  29 import org.antlr.runtime.tree.TreeAdaptor;
  30
  31 /**
  32  * TSDL parser. For internal use only.
  33  *
  34  * @author Matthew Khouzam and Antlr
  35  *
  36  */
  37 @SuppressWarnings({ "nls", "unused", "unchecked", "rawtypes", "javadoc",
  38         "null", "incomplete-switch" })
  39 public class CTFParser extends Parser {
  40     public static final String[] tokenNames = new String[] { "<invalid>",
  41             "<EOR>", "<DOWN>", "<UP>", "ALIGNTOK", "CONSTTOK", "CHARTOK",
  42             "DOUBLETOK", "ENUMTOK", "EVENTTOK", "FLOATINGPOINTTOK", "FLOATTOK",
  43             "INTEGERTOK", "INTTOK", "LONGTOK", "SHORTTOK", "SIGNEDTOK",
  44             "STREAMTOK", "STRINGTOK", "STRUCTTOK", "TRACETOK", "TYPEALIASTOK",
  45             "TYPEDEFTOK", "UNSIGNEDTOK", "VARIANTTOK", "VOIDTOK", "BOOLTOK",
  46             "COMPLEXTOK", "IMAGINARYTOK", "ENVTOK", "CLOCKTOK", "NANNUMBERTOK",
  47             "INFINITYTOK", "NINFINITYTOK", "SEPARATOR", "COLON", "ELIPSES",
  48             "ASSIGNMENT", "TYPE_ASSIGNMENT", "LT", "GT", "OPENBRAC",
  49             "CLOSEBRAC", "LPAREN", "RPAREN", "LCURL", "RCURL", "TERM",
  50             "POINTER", "SIGN", "ARROW", "DOT", "BACKSLASH",
  51             "INTEGER_TYPES_SUFFIX", "OCTAL_LITERAL", "DIGIT",
  52             "DECIMAL_LITERAL", "HEX_PREFIX", "HEX_DIGIT", "HEX_LITERAL",
  53             "NONZERO_DIGIT", "OCTAL_ESCAPE", "UNICODE_ESCAPE",
  54             "HEXADECIMAL_ESCAPE", "ESCAPE_SEQUENCE", "STRINGPREFIX",
  55             "SINGLEQUOTE", "CHAR_CONTENT", "CHARACTER_LITERAL", "DOUBLEQUOTE",
  56             "STRING_CONTENT", "STRING_LITERAL", "WS", "COMMENT_OPEN",
  57             "COMMENT_CLOSE", "COMMENT", "LINE_COMMENT", "NONDIGIT",
  58             "IDENTIFIER", "ROOT", "EVENT", "STREAM", "TRACE", "ENV", "CLOCK",
  59             "DECLARATION", "SV_DECLARATION", "TYPE_SPECIFIER_LIST",
  60             "TYPE_DECLARATOR_LIST", "TYPE_DECLARATOR", "STRUCT", "STRUCT_NAME",
  61             "STRUCT_BODY", "ALIGN", "CTF_EXPRESSION_TYPE",
  62             "CTF_EXPRESSION_VAL", "CTF_LEFT", "CTF_RIGHT",
  63             "UNARY_EXPRESSION_STRING", "UNARY_EXPRESSION_STRING_QUOTES",
  64             "UNARY_EXPRESSION_DEC", "UNARY_EXPRESSION_HEX",
  65             "UNARY_EXPRESSION_OCT", "LENGTH", "TYPEDEF", "TYPEALIAS",
  66             "TYPEALIAS_TARGET", "TYPEALIAS_ALIAS", "INTEGER", "STRING",
  67             "FLOATING_POINT", "ENUM", "ENUM_CONTAINER_TYPE", "ENUM_ENUMERATOR",
  68             "ENUM_NAME", "ENUM_VALUE", "ENUM_VALUE_RANGE", "ENUM_BODY",
  69             "VARIANT", "VARIANT_NAME", "VARIANT_TAG", "VARIANT_BODY",
  70             "DECLARATOR" };
  71     public static final int SIGN = 49;
  72     public static final int LT = 39;
  73     public static final int TYPEDEFTOK = 22;
  74     public static final int VARIANT_NAME = 119;
  75     public static final int ENV = 83;
  76     public static final int INTEGER_TYPES_SUFFIX = 53;
  77     public static final int POINTER = 48;
  78     public static final int TRACE = 82;
  79     public static final int HEX_PREFIX = 57;
  80     public static final int INTTOK = 13;
  81     public static final int SEPARATOR = 34;
  82     public static final int ENUMTOK = 8;
  83     public static final int COMPLEXTOK = 27;
  84     public static final int IMAGINARYTOK = 28;
  85     public static final int STREAMTOK = 17;
  86     public static final int EOF = -1;
  87     public static final int UNARY_EXPRESSION_OCT = 102;
  88     public static final int ENUM_VALUE = 115;
  89     public static final int UNSIGNEDTOK = 23;
  90     public static final int ENUM_NAME = 114;
  91     public static final int RPAREN = 44;
  92     public static final int CHAR_CONTENT = 67;
  93     public static final int STRING_LITERAL = 71;
  94     public static final int UNARY_EXPRESSION_STRING_QUOTES = 99;
  95     public static final int ALIGNTOK = 4;
  96     public static final int FLOATTOK = 11;
  97     public static final int STRUCT_BODY = 92;
  98     public static final int ENUM_BODY = 117;
  99     public static final int COMMENT_CLOSE = 74;
 100     public static final int STRINGTOK = 18;
 101     public static final int COMMENT = 75;
 102     public static final int STREAM = 81;
 103     public static final int UNARY_EXPRESSION_HEX = 101;
 104     public static final int UNARY_EXPRESSION_DEC = 100;
 105     public static final int FLOATINGPOINTTOK = 10;
 106     public static final int LINE_COMMENT = 76;
 107     public static final int CTF_EXPRESSION_TYPE = 94;
 108     public static final int DOUBLETOK = 7;
 109     public static final int TYPE_DECLARATOR = 89;
 110     public static final int CHARACTER_LITERAL = 68;
 111     public static final int OCTAL_ESCAPE = 61;
 112     public static final int STRUCT_NAME = 91;
 113     public static final int VARIANT = 118;
 114     public static final int NANNUMBERTOK = 31;
 115     public static final int ENUM_ENUMERATOR = 113;
 116     public static final int FLOATING_POINT = 110;
 117     public static final int DECLARATOR = 122;
 118     public static final int SIGNEDTOK = 16;
 119     public static final int CHARTOK = 6;
 120     public static final int WS = 72;
 121     public static final int INTEGERTOK = 12;
 122     public static final int VARIANT_BODY = 121;
 123     public static final int NONDIGIT = 77;
 124     public static final int GT = 40;
 125     public static final int TYPEALIAS_TARGET = 106;
 126     public static final int DECIMAL_LITERAL = 56;
 127     public static final int BACKSLASH = 52;
 128     public static final int CLOSEBRAC = 42;
 129     public static final int TERM = 47;
 130     public static final int BOOLTOK = 26;
 131     public static final int CTF_RIGHT = 97;
 132     public static final int TYPE_DECLARATOR_LIST = 88;
 133     public static final int STRING_CONTENT = 70;
 134     public static final int TYPE_ASSIGNMENT = 38;
 135     public static final int ENUM_CONTAINER_TYPE = 112;
 136     public static final int DOUBLEQUOTE = 69;
 137     public static final int ENUM_VALUE_RANGE = 116;
 138     public static final int DECLARATION = 85;
 139     public static final int LENGTH = 103;
 140     public static final int LPAREN = 43;
 141     public static final int INFINITYTOK = 32;
 142     public static final int STRINGPREFIX = 65;
 143     public static final int CTF_EXPRESSION_VAL = 95;
 144     public static final int ESCAPE_SEQUENCE = 64;
 145     public static final int UNICODE_ESCAPE = 62;
 146     public static final int SINGLEQUOTE = 66;
 147     public static final int IDENTIFIER = 78;
 148     public static final int HEX_LITERAL = 59;
 149     public static final int ALIGN = 93;
 150     public static final int DIGIT = 55;
 151     public static final int DOT = 51;
 152     public static final int ENVTOK = 29;
 153     public static final int STRUCTTOK = 19;
 154     public static final int OPENBRAC = 41;
 155     public static final int TYPEALIASTOK = 21;
 156     public static final int CLOCK = 84;
 157     public static final int INTEGER = 108;
 158     public static final int TYPEALIAS = 105;
 159     public static final int EVENTTOK = 9;
 160     public static final int NINFINITYTOK = 33;
 161     public static final int TYPEDEF = 104;
 162     public static final int VOIDTOK = 25;
 163     public static final int TYPE_SPECIFIER_LIST = 87;
 164     public static final int OCTAL_LITERAL = 54;
 165     public static final int COMMENT_OPEN = 73;
 166     public static final int HEX_DIGIT = 58;
 167     public static final int STRUCT = 90;
 168     public static final int EVENT = 80;
 169     public static final int LONGTOK = 14;
 170     public static final int ROOT = 79;
 171     public static final int CTF_LEFT = 96;
 172     public static final int CLOCKTOK = 30;
 173     public static final int TRACETOK = 20;
 174     public static final int COLON = 35;
 175     public static final int HEXADECIMAL_ESCAPE = 63;
 176     public static final int LCURL = 45;
 177     public static final int VARIANTTOK = 24;
 178     public static final int VARIANT_TAG = 120;
 179     public static final int ENUM = 111;
 180     public static final int ELIPSES = 36;
 181     public static final int RCURL = 46;
 182     public static final int TYPEALIAS_ALIAS = 107;
 183     public static final int UNARY_EXPRESSION_STRING = 98;
 184     public static final int ARROW = 50;
 185     public static final int ASSIGNMENT = 37;
 186     public static final int SHORTTOK = 15;
 187     public static final int SV_DECLARATION = 86;
 188     public static final int NONZERO_DIGIT = 60;
 189     public static final int CONSTTOK = 5;
 190     public static final int STRING = 109;
 191
 192     // delegates
 193     // delegators
 194
 195     protected static class Symbols_scope {
 196         Set<String> types;
 197     }
 198
 199     protected Stack Symbols_stack = new Stack();
 200
 201     public CTFParser(TokenStream input) {
 202         this(input, new RecognizerSharedState());
 203     }
 204
 205     public CTFParser(TokenStream input, RecognizerSharedState state) {
 206         super(input, state);
 207
 208     }
 209
 210     protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 211
 212     public void setTreeAdaptor(TreeAdaptor adaptor) {
 213         this.adaptor = adaptor;
 214     }
 215
 216     public TreeAdaptor getTreeAdaptor() {
 217         return adaptor;
 218     }
 219
 220     @Override
 221     public String[] getTokenNames() {
 222         return CTFParser.tokenNames;
 223     }
 224
 225     @Override
 226     public String getGrammarFileName() {
 227         return "Grammar/CTFParser.g";
 228     }
 229
 230     public CTFParser(TokenStream input, boolean verbose) {
 231         this(input);
 232         this.verbose = verbose;
 233     }
 234
 235     /*
 236      * To disable automatic error recovery. When we have a mismatched token,
 237      * simply throw an exception.
 238      */
 239     @Override
 240     protected Object recoverFromMismatchedToken(IntStream input, int ttype,
 241             BitSet follow) throws RecognitionException {
 242         throw new MismatchedTokenException(ttype, input);
 243     }
 244
 245     /**
 246      * Checks if a given name has been defined has a type. From:
 247      * http://www.antlr.org/grammar/1153358328744/C.g
 248      *
 249      * @param name
 250      *            The name to check.
 251      * @return True if is is a type, false otherwise.
 252      */
 253     boolean isTypeName(String name) {
 254         for (int i = Symbols_stack.size() - 1; i >= 0; i--) {
 255             Symbols_scope scope = (Symbols_scope) Symbols_stack.get(i);
 256             if (scope.types.contains(name)) {
 257                 return true;
 258             }
 259         }
 260         return false;
 261     }
 262
 263     void addTypeName(String name) {
 264         ((Symbols_scope) Symbols_stack.peek()).types.add(name);
 265         if (verbose) {
 266             debug_print("New type: " + name);
 267         }
 268     }
 269
 270     boolean _inTypedef = false;
 271
 272     void typedefOn() {
 273         debug_print("typedefOn");
 274         _inTypedef = true;
 275     }
 276
 277     void typedefOff() {
 278         debug_print("typedefOff");
 279         _inTypedef = false;
 280     }
 281
 282     boolean inTypedef() {
 283         return _inTypedef;
 284     }
 285
 286     boolean _inTypealiasAlias = false;
 287
 288     void typealiasAliasOn() {
 289         debug_print("typealiasAliasOn");
 290         _inTypealiasAlias = true;
 291     }
 292
 293     void typealiasAliasOff() {
 294         debug_print("typealiasAliasOff");
 295         _inTypealiasAlias = false;
 296     }
 297
 298     boolean inTypealiasAlias() {
 299         return _inTypealiasAlias;
 300     }
 301
 302     static void print_tabs(int n) {
 303         for (int i = 0; i < n; i++) {
 304             if(System.out != null) {//findbugs
 305                 System.out.print("  ");
 306             }
 307         }
 308     }
 309
 310     void enter(String name) {
 311         if (verbose) {
 312             if (state.backtracking == 0) {
 313                 print_tabs(depth);
 314                 debug_print("+ " + name);
 315                 depth++;
 316             }
 317         }
 318     }
 319
 320     void exit(String name) {
 321         if (verbose) {
 322             depth--;
 323             print_tabs(depth);
 324             debug_print("- " + name);
 325         }
 326     }
 327
 328     void debug_print(String str) {
 329         if (verbose) {
 330             if(System.out != null) {//findbugs
 331                 System.out.println(str);
 332             }
 333         }
 334     }
 335
 336     int depth = 0;
 337
 338     /* Prints rule entry and exit while parsing */
 339     boolean verbose = false;
 340
 341     public static class parse_return extends ParserRuleReturnScope {
 342         CommonTree tree;
 343
 344         @Override
 345         public Object getTree() {
 346             return tree;
 347         }
 348     }
 349
 350     // $ANTLR start "parse"
 351     // Grammar/CTFParser.g:198:1: parse : ( declaration )+ EOF -> ^( ROOT (
 352     // declaration )+ ) ;
 353     public final CTFParser.parse_return parse() throws RecognitionException {
 354         Symbols_stack.push(new Symbols_scope());
 355
 356         CTFParser.parse_return retval = new CTFParser.parse_return();
 357         retval.start = input.LT(1);
 358
 359         CommonTree root_0 = null;
 360
 361         Token EOF2 = null;
 362         CTFParser.declaration_return declaration1 = null;
 363
 364         CommonTree EOF2_tree = null;
 365         RewriteRuleTokenStream stream_EOF = new RewriteRuleTokenStream(adaptor,
 366                 "token EOF");
 367         RewriteRuleSubtreeStream stream_declaration = new RewriteRuleSubtreeStream(
 368                 adaptor, "rule declaration");
 369
 370         enter("parse");
 371         debug_print("Scope push " + Symbols_stack.size());
 372         ((Symbols_scope) Symbols_stack.peek()).types = new HashSet<String>();
 373
 374         try {
 375             // Grammar/CTFParser.g:211:1: ( ( declaration )+ EOF -> ^( ROOT (
 376             // declaration )+ ) )
 377             // Grammar/CTFParser.g:212:3: ( declaration )+ EOF
 378             {
 379                 // Grammar/CTFParser.g:212:3: ( declaration )+
 380                 int cnt1 = 0;
 381                 loop1: do {
 382                     int alt1 = 2;
 383                     int LA1_0 = input.LA(1);
 384
 385                     if ((((LA1_0 >= CONSTTOK) && (LA1_0 <= ENUMTOK))
 386                             || ((LA1_0 >= FLOATINGPOINTTOK) && (LA1_0 <= SIGNEDTOK))
 387                             || ((LA1_0 >= STRINGTOK) && (LA1_0 <= STRUCTTOK)) || ((LA1_0 >= TYPEDEFTOK) && (LA1_0 <= IMAGINARYTOK)))) {
 388                         alt1 = 1;
 389                     } else if ((LA1_0 == IDENTIFIER)
 390                             && ((inTypealiasAlias() || isTypeName(input.LT(1)
 391                                     .getText())))) {
 392                         alt1 = 1;
 393                     } else if (((LA1_0 == EVENTTOK) || (LA1_0 == STREAMTOK)
 394                             || ((LA1_0 >= TRACETOK) && (LA1_0 <= TYPEALIASTOK)) || ((LA1_0 >= ENVTOK) && (LA1_0 <= CLOCKTOK)))) {
 395                         alt1 = 1;
 396                     }
 397
 398                     switch (alt1) {
 399                     case 1:
 400                     // Grammar/CTFParser.g:212:3: declaration
 401                     {
 402                         pushFollow(FOLLOW_declaration_in_parse321);
 403                         declaration1 = declaration();
 404
 405                         state._fsp--;
 406                         if (state.failed) {
 407                             return retval;
 408                         }
 409                         if (state.backtracking == 0) {
 410                             stream_declaration.add(declaration1.getTree());
 411                         }
 412
 413                     }
 414                         break;
 415
 416                     default:
 417                         if (cnt1 >= 1) {
 418                             break loop1;
 419                         }
 420                         if (state.backtracking > 0) {
 421                             state.failed = true;
 422                             return retval;
 423                         }
 424                         EarlyExitException eee = new EarlyExitException(1,
 425                                 input);
 426                         throw eee;
 427                     }
 428                     cnt1++;
 429                 } while (true);
 430
 431                 EOF2 = (Token) match(input, EOF, FOLLOW_EOF_in_parse324);
 432                 if (state.failed) {
 433                     return retval;
 434                 }
 435                 if (state.backtracking == 0) {
 436                     stream_EOF.add(EOF2);
 437                 }
 438
 439                 // AST REWRITE
 440                 // elements: declaration
 441                 // token labels:
 442                 // rule labels: retval
 443                 // token list labels:
 444                 // rule list labels:
 445                 // wildcard labels:
 446                 if (state.backtracking == 0) {
 447                     retval.tree = root_0;
 448 //                    RewriteRuleSubtreeStream stream_retval =
 449                             new RewriteRuleSubtreeStream(
 450                             adaptor, "rule retval",
 451                             retval != null ? retval.tree : null);
 452
 453                     root_0 = (CommonTree) adaptor.nil();
 454                     // 212:20: -> ^( ROOT ( declaration )+ )
 455                     {
 456                         // Grammar/CTFParser.g:212:23: ^( ROOT ( declaration )+
 457                         // )
 458                         {
 459                             CommonTree root_1 = (CommonTree) adaptor.nil();
 460                             root_1 = (CommonTree) adaptor.becomeRoot(
 461                                     adaptor.create(ROOT, "ROOT"), root_1);
 462
 463                             if (!(stream_declaration.hasNext())) {
 464                                 throw new RewriteEarlyExitException();
 465                             }
 466                             while (stream_declaration.hasNext()) {
 467                                 adaptor.addChild(root_1,
 468                                         stream_declaration.nextTree());
 469
 470                             }
 471                             stream_declaration.reset();
 472
 473                             adaptor.addChild(root_0, root_1);
 474                         }
 475
 476                     }
 477
 478                     retval.tree = root_0;
 479                 }
 480             }
 481
 482             retval.stop = input.LT(-1);
 483
 484             if (state.backtracking == 0) {
 485
 486                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
 487                 adaptor.setTokenBoundaries(retval.tree, retval.start,
 488                         retval.stop);
 489             }
 490             if (state.backtracking == 0) {
 491
 492                 debug_print("Scope pop " + Symbols_stack.size());
 493                 exit("parse");
 494
 495                 debug_print("Final depth, should be 0: " + depth);
 496
 497             }
 498         }
 499
 500         catch (RecognitionException e) {
 501             throw e;
 502         } finally {
 503             Symbols_stack.pop();
 504
 505         }
 506         return retval;
 507     }
 508
 509     // $ANTLR end "parse"
 510
 511     public static class numberLiteral_return extends ParserRuleReturnScope {
 512         CommonTree tree;
 513
 514         @Override
 515         public Object getTree() {
 516             return tree;
 517         }
 518     }
 519
 520     // $ANTLR start "numberLiteral"
 521     // Grammar/CTFParser.g:215:1: numberLiteral : ( SIGN )* ( HEX_LITERAL -> ^(
 522     // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^(
 523     // UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^(
 524     // UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) ) ;
 525     public final CTFParser.numberLiteral_return numberLiteral()
 526             throws RecognitionException {
 527         CTFParser.numberLiteral_return retval = new CTFParser.numberLiteral_return();
 528         retval.start = input.LT(1);
 529
 530         CommonTree root_0 = null;
 531
 532         Token SIGN3 = null;
 533         Token HEX_LITERAL4 = null;
 534         Token DECIMAL_LITERAL5 = null;
 535         Token OCTAL_LITERAL6 = null;
 536
 537         CommonTree SIGN3_tree = null;
 538         CommonTree HEX_LITERAL4_tree = null;
 539         CommonTree DECIMAL_LITERAL5_tree = null;
 540         CommonTree OCTAL_LITERAL6_tree = null;
 541         RewriteRuleTokenStream stream_SIGN = new RewriteRuleTokenStream(
 542                 adaptor, "token SIGN");
 543         RewriteRuleTokenStream stream_OCTAL_LITERAL = new RewriteRuleTokenStream(
 544                 adaptor, "token OCTAL_LITERAL");
 545         RewriteRuleTokenStream stream_HEX_LITERAL = new RewriteRuleTokenStream(
 546                 adaptor, "token HEX_LITERAL");
 547         RewriteRuleTokenStream stream_DECIMAL_LITERAL = new RewriteRuleTokenStream(
 548                 adaptor, "token DECIMAL_LITERAL");
 549
 550         enter("numberLiteral");
 551
 552         try {
 553             // Grammar/CTFParser.g:223:1: ( ( SIGN )* ( HEX_LITERAL -> ^(
 554             // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL ->
 555             // ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) |
 556             // OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )*
 557             // ) ) )
 558             // Grammar/CTFParser.g:224:3: ( SIGN )* ( HEX_LITERAL -> ^(
 559             // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL ->
 560             // ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) |
 561             // OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )*
 562             // ) )
 563             {
 564                 // Grammar/CTFParser.g:224:3: ( SIGN )*
 565                 loop2: do {
 566                     int alt2 = 2;
 567                     int LA2_0 = input.LA(1);
 568
 569                     if ((LA2_0 == SIGN)) {
 570                         alt2 = 1;
 571                     }
 572
 573                     switch (alt2) {
 574                     case 1:
 575                     // Grammar/CTFParser.g:224:3: SIGN
 576                     {
 577                         SIGN3 = (Token) match(input, SIGN,
 578                                 FOLLOW_SIGN_in_numberLiteral357);
 579                         if (state.failed) {
 580                             return retval;
 581                         }
 582                         if (state.backtracking == 0) {
 583                             stream_SIGN.add(SIGN3);
 584                         }
 585
 586                     }
 587                         break;
 588
 589                     default:
 590                         break loop2;
 591                     }
 592                 } while (true);
 593
 594                 // Grammar/CTFParser.g:224:10: ( HEX_LITERAL -> ^(
 595                 // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) |
 596                 // DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL (
 597                 // SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT
 598                 // OCTAL_LITERAL ( SIGN )* ) )
 599                 int alt3 = 3;
 600                 switch (input.LA(1)) {
 601                 case HEX_LITERAL: {
 602                     alt3 = 1;
 603                 }
 604                     break;
 605                 case DECIMAL_LITERAL: {
 606                     alt3 = 2;
 607                 }
 608                     break;
 609                 case OCTAL_LITERAL: {
 610                     alt3 = 3;
 611                 }
 612                     break;
 613                 default:
 614                     if (state.backtracking > 0) {
 615                         state.failed = true;
 616                         return retval;
 617                     }
 618                     NoViableAltException nvae = new NoViableAltException("", 3,
 619                             0, input);
 620
 621                     throw nvae;
 622                 }
 623
 624                 switch (alt3) {
 625                 case 1:
 626                 // Grammar/CTFParser.g:224:11: HEX_LITERAL
 627                 {
 628                     HEX_LITERAL4 = (Token) match(input, HEX_LITERAL,
 629                             FOLLOW_HEX_LITERAL_in_numberLiteral362);
 630                     if (state.failed) {
 631                         return retval;
 632                     }
 633                     if (state.backtracking == 0) {
 634                         stream_HEX_LITERAL.add(HEX_LITERAL4);
 635                     }
 636
 637                     // AST REWRITE
 638                     // elements: SIGN, HEX_LITERAL
 639                     // token labels:
 640                     // rule labels: retval
 641                     // token list labels:
 642                     // rule list labels:
 643                     // wildcard labels:
 644                     if (state.backtracking == 0) {
 645                         retval.tree = root_0;
 646 //                        RewriteRuleSubtreeStream stream_retval =
 647                                 new RewriteRuleSubtreeStream(
 648                                 adaptor, "rule retval",
 649                                 retval != null ? retval.tree : null);
 650
 651                         root_0 = (CommonTree) adaptor.nil();
 652                         // 224:23: -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN
 653                         // )* )
 654                         {
 655                             // Grammar/CTFParser.g:224:26: ^(
 656                             // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
 657                             {
 658                                 CommonTree root_1 = (CommonTree) adaptor.nil();
 659                                 root_1 = (CommonTree) adaptor
 660                                         .becomeRoot(adaptor.create(
 661                                                 UNARY_EXPRESSION_HEX,
 662                                                 "UNARY_EXPRESSION_HEX"), root_1);
 663
 664                                 adaptor.addChild(root_1,
 665                                         stream_HEX_LITERAL.nextNode());
 666                                 // Grammar/CTFParser.g:224:61: ( SIGN )*
 667                                 while (stream_SIGN.hasNext()) {
 668                                     adaptor.addChild(root_1,
 669                                             stream_SIGN.nextNode());
 670
 671                                 }
 672                                 stream_SIGN.reset();
 673
 674                                 adaptor.addChild(root_0, root_1);
 675                             }
 676
 677                         }
 678
 679                         retval.tree = root_0;
 680                     }
 681                 }
 682                     break;
 683                 case 2:
 684                 // Grammar/CTFParser.g:225:5: DECIMAL_LITERAL
 685                 {
 686                     DECIMAL_LITERAL5 = (Token) match(input, DECIMAL_LITERAL,
 687                             FOLLOW_DECIMAL_LITERAL_in_numberLiteral379);
 688                     if (state.failed) {
 689                         return retval;
 690                     }
 691                     if (state.backtracking == 0) {
 692                         stream_DECIMAL_LITERAL.add(DECIMAL_LITERAL5);
 693                     }
 694
 695                     // AST REWRITE
 696                     // elements: DECIMAL_LITERAL, SIGN
 697                     // token labels:
 698                     // rule labels: retval
 699                     // token list labels:
 700                     // rule list labels:
 701                     // wildcard labels:
 702                     if (state.backtracking == 0) {
 703                         retval.tree = root_0;
 704 //                        RewriteRuleSubtreeStream stream_retval =
 705                                 new RewriteRuleSubtreeStream(
 706                                 adaptor, "rule retval",
 707                                 retval != null ? retval.tree : null);
 708
 709                         root_0 = (CommonTree) adaptor.nil();
 710                         // 225:21: -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL (
 711                         // SIGN )* )
 712                         {
 713                             // Grammar/CTFParser.g:225:24: ^(
 714                             // UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
 715                             {
 716                                 CommonTree root_1 = (CommonTree) adaptor.nil();
 717                                 root_1 = (CommonTree) adaptor
 718                                         .becomeRoot(adaptor.create(
 719                                                 UNARY_EXPRESSION_DEC,
 720                                                 "UNARY_EXPRESSION_DEC"), root_1);
 721
 722                                 adaptor.addChild(root_1,
 723                                         stream_DECIMAL_LITERAL.nextNode());
 724                                 // Grammar/CTFParser.g:225:63: ( SIGN )*
 725                                 while (stream_SIGN.hasNext()) {
 726                                     adaptor.addChild(root_1,
 727                                             stream_SIGN.nextNode());
 728
 729                                 }
 730                                 stream_SIGN.reset();
 731
 732                                 adaptor.addChild(root_0, root_1);
 733                             }
 734
 735                         }
 736
 737                         retval.tree = root_0;
 738                     }
 739                 }
 740                     break;
 741                 case 3:
 742                 // Grammar/CTFParser.g:226:5: OCTAL_LITERAL
 743                 {
 744                     OCTAL_LITERAL6 = (Token) match(input, OCTAL_LITERAL,
 745                             FOLLOW_OCTAL_LITERAL_in_numberLiteral396);
 746                     if (state.failed) {
 747                         return retval;
 748                     }
 749                     if (state.backtracking == 0) {
 750                         stream_OCTAL_LITERAL.add(OCTAL_LITERAL6);
 751                     }
 752
 753                     // AST REWRITE
 754                     // elements: SIGN, OCTAL_LITERAL
 755                     // token labels:
 756                     // rule labels: retval
 757                     // token list labels:
 758                     // rule list labels:
 759                     // wildcard labels:
 760                     if (state.backtracking == 0) {
 761                         retval.tree = root_0;
 762 //                        RewriteRuleSubtreeStream stream_retval =
 763                                 new RewriteRuleSubtreeStream(
 764                                 adaptor, "rule retval",
 765                                 retval != null ? retval.tree : null);
 766
 767                         root_0 = (CommonTree) adaptor.nil();
 768                         // 226:19: -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL (
 769                         // SIGN )* )
 770                         {
 771                             // Grammar/CTFParser.g:226:22: ^(
 772                             // UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
 773                             {
 774                                 CommonTree root_1 = (CommonTree) adaptor.nil();
 775                                 root_1 = (CommonTree) adaptor
 776                                         .becomeRoot(adaptor.create(
 777                                                 UNARY_EXPRESSION_OCT,
 778                                                 "UNARY_EXPRESSION_OCT"), root_1);
 779
 780                                 adaptor.addChild(root_1,
 781                                         stream_OCTAL_LITERAL.nextNode());
 782                                 // Grammar/CTFParser.g:226:59: ( SIGN )*
 783                                 while (stream_SIGN.hasNext()) {
 784                                     adaptor.addChild(root_1,
 785                                             stream_SIGN.nextNode());
 786
 787                                 }
 788                                 stream_SIGN.reset();
 789
 790                                 adaptor.addChild(root_0, root_1);
 791                             }
 792
 793                         }
 794
 795                         retval.tree = root_0;
 796                     }
 797                 }
 798                     break;
 799
 800                 }
 801
 802             }
 803
 804             retval.stop = input.LT(-1);
 805
 806             if (state.backtracking == 0) {
 807
 808                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
 809                 adaptor.setTokenBoundaries(retval.tree, retval.start,
 810                         retval.stop);
 811             }
 812             if (state.backtracking == 0) {
 813
 814                 debug_print(input.toString(retval.start, input.LT(-1)));
 815                 exit("numberLiteral");
 816
 817             }
 818         }
 819
 820         catch (RecognitionException e) {
 821             throw e;
 822
 823         }
 824         return retval;
 825     }
 826
 827     // $ANTLR end "numberLiteral"
 828
 829     public static class constant_return extends ParserRuleReturnScope {
 830         CommonTree tree;
 831
 832         @Override
 833         public Object getTree() {
 834             return tree;
 835         }
 836     }
 837
 838     // $ANTLR start "constant"
 839     // Grammar/CTFParser.g:229:1: constant : ( numberLiteral | enumConstant |
 840     // CHARACTER_LITERAL );
 841     public final CTFParser.constant_return constant()
 842             throws RecognitionException {
 843         CTFParser.constant_return retval = new CTFParser.constant_return();
 844         retval.start = input.LT(1);
 845
 846         CommonTree root_0 = null;
 847
 848         Token CHARACTER_LITERAL9 = null;
 849         CTFParser.numberLiteral_return numberLiteral7 = null;
 850
 851         CTFParser.enumConstant_return enumConstant8 = null;
 852
 853         CommonTree CHARACTER_LITERAL9_tree = null;
 854
 855         enter("constant");
 856
 857         try {
 858             // Grammar/CTFParser.g:236:1: ( numberLiteral | enumConstant |
 859             // CHARACTER_LITERAL )
 860             int alt4 = 3;
 861             switch (input.LA(1)) {
 862             case SIGN:
 863             case OCTAL_LITERAL:
 864             case DECIMAL_LITERAL:
 865             case HEX_LITERAL: {
 866                 alt4 = 1;
 867             }
 868                 break;
 869             case ALIGNTOK:
 870             case EVENTTOK:
 871             case SIGNEDTOK:
 872             case STRINGTOK:
 873             case STRING_LITERAL:
 874             case IDENTIFIER: {
 875                 alt4 = 2;
 876             }
 877                 break;
 878             case CHARACTER_LITERAL: {
 879                 alt4 = 3;
 880             }
 881                 break;
 882             default:
 883                 if (state.backtracking > 0) {
 884                     state.failed = true;
 885                     return retval;
 886                 }
 887                 NoViableAltException nvae = new NoViableAltException("", 4, 0,
 888                         input);
 889
 890                 throw nvae;
 891             }
 892
 893             switch (alt4) {
 894             case 1:
 895             // Grammar/CTFParser.g:237:4: numberLiteral
 896             {
 897                 root_0 = (CommonTree) adaptor.nil();
 898
 899                 pushFollow(FOLLOW_numberLiteral_in_constant432);
 900                 numberLiteral7 = numberLiteral();
 901
 902                 state._fsp--;
 903                 if (state.failed) {
 904                     return retval;
 905                 }
 906                 if (state.backtracking == 0) {
 907                     adaptor.addChild(root_0, numberLiteral7.getTree());
 908                 }
 909
 910             }
 911                 break;
 912             case 2:
 913             // Grammar/CTFParser.g:238:5: enumConstant
 914             {
 915                 root_0 = (CommonTree) adaptor.nil();
 916
 917                 pushFollow(FOLLOW_enumConstant_in_constant438);
 918                 enumConstant8 = enumConstant();
 919
 920                 state._fsp--;
 921                 if (state.failed) {
 922                     return retval;
 923                 }
 924                 if (state.backtracking == 0) {
 925                     adaptor.addChild(root_0, enumConstant8.getTree());
 926                 }
 927
 928             }
 929                 break;
 930             case 3:
 931             // Grammar/CTFParser.g:239:5: CHARACTER_LITERAL
 932             {
 933                 root_0 = (CommonTree) adaptor.nil();
 934
 935                 CHARACTER_LITERAL9 = (Token) match(input, CHARACTER_LITERAL,
 936                         FOLLOW_CHARACTER_LITERAL_in_constant444);
 937                 if (state.failed) {
 938                     return retval;
 939                 }
 940                 if (state.backtracking == 0) {
 941                     CHARACTER_LITERAL9_tree = (CommonTree) adaptor
 942                             .create(CHARACTER_LITERAL9);
 943                     adaptor.addChild(root_0, CHARACTER_LITERAL9_tree);
 944                 }
 945
 946             }
 947                 break;
 948
 949             }
 950             retval.stop = input.LT(-1);
 951
 952             if (state.backtracking == 0) {
 953
 954                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
 955                 adaptor.setTokenBoundaries(retval.tree, retval.start,
 956                         retval.stop);
 957             }
 958             if (state.backtracking == 0) {
 959
 960                 exit("constant");
 961
 962             }
 963         }
 964
 965         catch (RecognitionException e) {
 966             throw e;
 967
 968         }
 969         return retval;
 970     }
 971
 972     // $ANTLR end "constant"
 973
 974     public static class primaryExpression_return extends ParserRuleReturnScope {
 975         CommonTree tree;
 976
 977         @Override
 978         public Object getTree() {
 979             return tree;
 980         }
 981     }
 982
 983     // $ANTLR start "primaryExpression"
 984     // Grammar/CTFParser.g:242:1: primaryExpression : ( ( IDENTIFIER )=>
 985     // IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=>
 986     // ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | ( STRING_LITERAL
 987     // )=> STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
 988     // | constant );
 989     public final CTFParser.primaryExpression_return primaryExpression()
 990             throws RecognitionException {
 991         CTFParser.primaryExpression_return retval = new CTFParser.primaryExpression_return();
 992         retval.start = input.LT(1);
 993
 994         CommonTree root_0 = null;
 995
 996         Token IDENTIFIER10 = null;
 997         Token STRING_LITERAL12 = null;
 998         CTFParser.ctfKeyword_return ctfKeyword11 = null;
 999
1000         CTFParser.constant_return constant13 = null;
1001
1002         CommonTree IDENTIFIER10_tree = null;
1003         CommonTree STRING_LITERAL12_tree = null;
1004         RewriteRuleTokenStream stream_STRING_LITERAL = new RewriteRuleTokenStream(
1005                 adaptor, "token STRING_LITERAL");
1006         RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
1007                 adaptor, "token IDENTIFIER");
1008         RewriteRuleSubtreeStream stream_ctfKeyword = new RewriteRuleSubtreeStream(
1009                 adaptor, "rule ctfKeyword");
1010
1011         enter("primaryExpression");
1012
1013         try {
1014             // Grammar/CTFParser.g:249:1: ( ( IDENTIFIER )=> IDENTIFIER -> ^(
1015             // UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=>
1016             // ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | (
1017             // STRING_LITERAL )=> STRING_LITERAL -> ^(
1018             // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | constant )
1019             int alt5 = 4;
1020             switch (input.LA(1)) {
1021             case IDENTIFIER: {
1022                 int LA5_1 = input.LA(2);
1023
1024                 if ((synpred1_CTFParser())) {
1025                     alt5 = 1;
1026                 } else if ((true)) {
1027                     alt5 = 4;
1028                 } else {
1029                     if (state.backtracking > 0) {
1030                         state.failed = true;
1031                         return retval;
1032                     }
1033                     NoViableAltException nvae = new NoViableAltException("", 5,
1034                             1, input);
1035
1036                     throw nvae;
1037                 }
1038             }
1039                 break;
1040             case ALIGNTOK:
1041             case EVENTTOK:
1042             case SIGNEDTOK:
1043             case STRINGTOK: {
1044                 int LA5_2 = input.LA(2);
1045
1046                 if ((synpred2_CTFParser())) {
1047                     alt5 = 2;
1048                 } else if ((true)) {
1049                     alt5 = 4;
1050                 } else {
1051                     if (state.backtracking > 0) {
1052                         state.failed = true;
1053                         return retval;
1054                     }
1055                     NoViableAltException nvae = new NoViableAltException("", 5,
1056                             2, input);
1057
1058                     throw nvae;
1059                 }
1060             }
1061                 break;
1062             case STRING_LITERAL: {
1063                 int LA5_3 = input.LA(2);
1064
1065                 if ((synpred3_CTFParser())) {
1066                     alt5 = 3;
1067                 } else if ((true)) {
1068                     alt5 = 4;
1069                 } else {
1070                     if (state.backtracking > 0) {
1071                         state.failed = true;
1072                         return retval;
1073                     }
1074                     NoViableAltException nvae = new NoViableAltException("", 5,
1075                             3, input);
1076
1077                     throw nvae;
1078                 }
1079             }
1080                 break;
1081             case SIGN:
1082             case OCTAL_LITERAL:
1083             case DECIMAL_LITERAL:
1084             case HEX_LITERAL:
1085             case CHARACTER_LITERAL: {
1086                 alt5 = 4;
1087             }
1088                 break;
1089             default:
1090                 if (state.backtracking > 0) {
1091                     state.failed = true;
1092                     return retval;
1093                 }
1094                 NoViableAltException nvae = new NoViableAltException("", 5, 0,
1095                         input);
1096
1097                 throw nvae;
1098             }
1099
1100             switch (alt5) {
1101             case 1:
1102             // Grammar/CTFParser.g:250:5: ( IDENTIFIER )=> IDENTIFIER
1103             {
1104                 IDENTIFIER10 = (Token) match(input, IDENTIFIER,
1105                         FOLLOW_IDENTIFIER_in_primaryExpression475);
1106                 if (state.failed) {
1107                     return retval;
1108                 }
1109                 if (state.backtracking == 0) {
1110                     stream_IDENTIFIER.add(IDENTIFIER10);
1111                 }
1112
1113                 if (state.backtracking == 0) {
1114                     debug_print("IDENTIFIER: "
1115                             + (IDENTIFIER10 != null ? IDENTIFIER10.getText()
1116                                     : null));
1117                 }
1118
1119                 // AST REWRITE
1120                 // elements: IDENTIFIER
1121                 // token labels:
1122                 // rule labels: retval
1123                 // token list labels:
1124                 // rule list labels:
1125                 // wildcard labels:
1126                 if (state.backtracking == 0) {
1127                     retval.tree = root_0;
1128 //                    RewriteRuleSubtreeStream stream_retval =
1129                             new RewriteRuleSubtreeStream(
1130                             adaptor, "rule retval",
1131                             retval != null ? retval.tree : null);
1132
1133                     root_0 = (CommonTree) adaptor.nil();
1134                     // 250:83: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
1135                     {
1136                         // Grammar/CTFParser.g:250:86: ^(
1137                         // UNARY_EXPRESSION_STRING IDENTIFIER )
1138                         {
1139                             CommonTree root_1 = (CommonTree) adaptor.nil();
1140                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
1141                                     .create(UNARY_EXPRESSION_STRING,
1142                                             "UNARY_EXPRESSION_STRING"), root_1);
1143
1144                             adaptor.addChild(root_1,
1145                                     stream_IDENTIFIER.nextNode());
1146
1147                             adaptor.addChild(root_0, root_1);
1148                         }
1149
1150                     }
1151
1152                     retval.tree = root_0;
1153                 }
1154             }
1155                 break;
1156             case 2:
1157             // Grammar/CTFParser.g:251:5: ( ctfKeyword )=> ctfKeyword
1158             {
1159                 pushFollow(FOLLOW_ctfKeyword_in_primaryExpression497);
1160                 ctfKeyword11 = ctfKeyword();
1161
1162                 state._fsp--;
1163                 if (state.failed) {
1164                     return retval;
1165                 }
1166                 if (state.backtracking == 0) {
1167                     stream_ctfKeyword.add(ctfKeyword11.getTree());
1168                 }
1169
1170                 // AST REWRITE
1171                 // elements: ctfKeyword
1172                 // token labels:
1173                 // rule labels: retval
1174                 // token list labels:
1175                 // rule list labels:
1176                 // wildcard labels:
1177                 if (state.backtracking == 0) {
1178                     retval.tree = root_0;
1179 //                    RewriteRuleSubtreeStream stream_retval =
1180                             new RewriteRuleSubtreeStream(
1181                             adaptor, "rule retval",
1182                             retval != null ? retval.tree : null);
1183
1184                     root_0 = (CommonTree) adaptor.nil();
1185                     // 251:32: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
1186                     {
1187                         // Grammar/CTFParser.g:251:35: ^(
1188                         // UNARY_EXPRESSION_STRING ctfKeyword )
1189                         {
1190                             CommonTree root_1 = (CommonTree) adaptor.nil();
1191                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
1192                                     .create(UNARY_EXPRESSION_STRING,
1193                                             "UNARY_EXPRESSION_STRING"), root_1);
1194
1195                             adaptor.addChild(root_1,
1196                                     stream_ctfKeyword.nextTree());
1197
1198                             adaptor.addChild(root_0, root_1);
1199                         }
1200
1201                     }
1202
1203                     retval.tree = root_0;
1204                 }
1205             }
1206                 break;
1207             case 3:
1208             // Grammar/CTFParser.g:252:5: ( STRING_LITERAL )=> STRING_LITERAL
1209             {
1210                 STRING_LITERAL12 = (Token) match(input, STRING_LITERAL,
1211                         FOLLOW_STRING_LITERAL_in_primaryExpression517);
1212                 if (state.failed) {
1213                     return retval;
1214                 }
1215                 if (state.backtracking == 0) {
1216                     stream_STRING_LITERAL.add(STRING_LITERAL12);
1217                 }
1218
1219                 if (state.backtracking == 0) {
1220                     debug_print("STRING_LITERAL: "
1221                             + (STRING_LITERAL12 != null ? STRING_LITERAL12
1222                                     .getText() : null));
1223                 }
1224
1225                 // AST REWRITE
1226                 // elements: STRING_LITERAL
1227                 // token labels:
1228                 // rule labels: retval
1229                 // token list labels:
1230                 // rule list labels:
1231                 // wildcard labels:
1232                 if (state.backtracking == 0) {
1233                     retval.tree = root_0;
1234                     new RewriteRuleSubtreeStream(
1235                             adaptor, "rule retval",
1236                             retval != null ? retval.tree : null);
1237
1238                     root_0 = (CommonTree) adaptor.nil();
1239                     // 252:99: -> ^( UNARY_EXPRESSION_STRING_QUOTES
1240                     // STRING_LITERAL )
1241                     {
1242                         // Grammar/CTFParser.g:252:102: ^(
1243                         // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
1244                         {
1245                             CommonTree root_1 = (CommonTree) adaptor.nil();
1246                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
1247                                     .create(UNARY_EXPRESSION_STRING_QUOTES,
1248                                             "UNARY_EXPRESSION_STRING_QUOTES"),
1249                                     root_1);
1250
1251                             adaptor.addChild(root_1,
1252                                     stream_STRING_LITERAL.nextNode());
1253
1254                             adaptor.addChild(root_0, root_1);
1255                         }
1256
1257                     }
1258
1259                     retval.tree = root_0;
1260                 }
1261             }
1262                 break;
1263             case 4:
1264             // Grammar/CTFParser.g:254:5: constant
1265             {
1266                 root_0 = (CommonTree) adaptor.nil();
1267
1268                 pushFollow(FOLLOW_constant_in_primaryExpression538);
1269                 constant13 = constant();
1270
1271                 state._fsp--;
1272                 if (state.failed) {
1273                     return retval;
1274                 }
1275                 if (state.backtracking == 0) {
1276                     adaptor.addChild(root_0, constant13.getTree());
1277                 }
1278
1279             }
1280                 break;
1281
1282             }
1283             retval.stop = input.LT(-1);
1284
1285             if (state.backtracking == 0) {
1286
1287                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
1288                 adaptor.setTokenBoundaries(retval.tree, retval.start,
1289                         retval.stop);
1290             }
1291             if (state.backtracking == 0) {
1292
1293                 exit("primaryExpression");
1294
1295             }
1296         }
1297
1298         catch (RecognitionException e) {
1299             throw e;
1300         }
1301         return retval;
1302     }
1303
1304     // $ANTLR end "primaryExpression"
1305
1306     public static class reference_return extends ParserRuleReturnScope {
1307         CommonTree tree;
1308
1309         @Override
1310         public Object getTree() {
1311             return tree;
1312         }
1313     }
1314
1315     // $ANTLR start "reference"
1316     // Grammar/CTFParser.g:257:1: reference : (ref= DOT | ref= ARROW )
1317     // IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) ;
1318     public final CTFParser.reference_return reference()
1319             throws RecognitionException {
1320         CTFParser.reference_return retval = new CTFParser.reference_return();
1321         retval.start = input.LT(1);
1322
1323         CommonTree root_0 = null;
1324
1325         Token ref = null;
1326         Token IDENTIFIER14 = null;
1327
1328         CommonTree ref_tree = null;
1329         CommonTree IDENTIFIER14_tree = null;
1330         RewriteRuleTokenStream stream_ARROW = new RewriteRuleTokenStream(
1331                 adaptor, "token ARROW");
1332         RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor,
1333                 "token DOT");
1334         RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
1335                 adaptor, "token IDENTIFIER");
1336
1337         enter("reference");
1338
1339         try {
1340             // Grammar/CTFParser.g:265:1: ( (ref= DOT | ref= ARROW ) IDENTIFIER
1341             // -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) )
1342             // Grammar/CTFParser.g:266:3: (ref= DOT | ref= ARROW ) IDENTIFIER
1343             {
1344                 // Grammar/CTFParser.g:266:3: (ref= DOT | ref= ARROW )
1345                 int alt6 = 2;
1346                 int LA6_0 = input.LA(1);
1347
1348                 if ((LA6_0 == DOT)) {
1349                     alt6 = 1;
1350                 } else if ((LA6_0 == ARROW)) {
1351                     alt6 = 2;
1352                 } else {
1353                     if (state.backtracking > 0) {
1354                         state.failed = true;
1355                         return retval;
1356                     }
1357                     NoViableAltException nvae = new NoViableAltException("", 6,
1358                             0, input);
1359
1360                     throw nvae;
1361                 }
1362                 switch (alt6) {
1363                 case 1:
1364                 // Grammar/CTFParser.g:266:4: ref= DOT
1365                 {
1366                     ref = (Token) match(input, DOT, FOLLOW_DOT_in_reference564);
1367                     if (state.failed) {
1368                         return retval;
1369                     }
1370                     if (state.backtracking == 0) {
1371                         stream_DOT.add(ref);
1372                     }
1373
1374                 }
1375                     break;
1376                 case 2:
1377                 // Grammar/CTFParser.g:266:14: ref= ARROW
1378                 {
1379                     ref = (Token) match(input, ARROW,
1380                             FOLLOW_ARROW_in_reference570);
1381                     if (state.failed) {
1382                         return retval;
1383                     }
1384                     if (state.backtracking == 0) {
1385                         stream_ARROW.add(ref);
1386                     }
1387
1388                 }
1389                     break;
1390
1391                 }
1392
1393                 IDENTIFIER14 = (Token) match(input, IDENTIFIER,
1394                         FOLLOW_IDENTIFIER_in_reference573);
1395                 if (state.failed) {
1396                     return retval;
1397                 }
1398                 if (state.backtracking == 0) {
1399                     stream_IDENTIFIER.add(IDENTIFIER14);
1400                 }
1401
1402                 // AST REWRITE
1403                 // elements: IDENTIFIER, ref
1404                 // token labels: ref
1405                 // rule labels: retval
1406                 // token list labels:
1407                 // rule list labels:
1408                 // wildcard labels:
1409                 if (state.backtracking == 0) {
1410                     retval.tree = root_0;
1411                     RewriteRuleTokenStream stream_ref = new RewriteRuleTokenStream(
1412                             adaptor, "token ref", ref);
1413 //                    RewriteRuleSubtreeStream stream_retval =
1414                             new RewriteRuleSubtreeStream(
1415                             adaptor, "rule retval",
1416                             retval != null ? retval.tree : null);
1417
1418                     root_0 = (CommonTree) adaptor.nil();
1419                     // 266:36: -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER
1420                     // ) )
1421                     {
1422                         // Grammar/CTFParser.g:266:39: ^( $ref ^(
1423                         // UNARY_EXPRESSION_STRING IDENTIFIER ) )
1424                         {
1425                             CommonTree root_1 = (CommonTree) adaptor.nil();
1426                             root_1 = (CommonTree) adaptor.becomeRoot(
1427                                     stream_ref.nextNode(), root_1);
1428
1429                             // Grammar/CTFParser.g:266:46: ^(
1430                             // UNARY_EXPRESSION_STRING IDENTIFIER )
1431                             {
1432                                 CommonTree root_2 = (CommonTree) adaptor.nil();
1433                                 root_2 = (CommonTree) adaptor.becomeRoot(
1434                                         adaptor.create(UNARY_EXPRESSION_STRING,
1435                                                 "UNARY_EXPRESSION_STRING"),
1436                                         root_2);
1437
1438                                 adaptor.addChild(root_2,
1439                                         stream_IDENTIFIER.nextNode());
1440
1441                                 adaptor.addChild(root_1, root_2);
1442                             }
1443
1444                             adaptor.addChild(root_0, root_1);
1445                         }
1446
1447                     }
1448
1449                     retval.tree = root_0;
1450                 }
1451             }
1452
1453             retval.stop = input.LT(-1);
1454
1455             if (state.backtracking == 0) {
1456
1457                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
1458                 adaptor.setTokenBoundaries(retval.tree, retval.start,
1459                         retval.stop);
1460             }
1461             if (state.backtracking == 0) {
1462
1463                 debug_print(input.toString(retval.start, input.LT(-1)));
1464                 exit("reference");
1465
1466             }
1467         }
1468
1469         catch (RecognitionException e) {
1470             throw e;
1471         }
1472         return retval;
1473     }
1474
1475     // $ANTLR end "reference"
1476
1477     public static class postfixExpressionSuffix_return extends
1478             ParserRuleReturnScope {
1479         CommonTree tree;
1480
1481         @Override
1482         public Object getTree() {
1483             return tree;
1484         }
1485     }
1486
1487     // $ANTLR start "postfixExpressionSuffix"
1488     // Grammar/CTFParser.g:269:1: postfixExpressionSuffix : ( ( OPENBRAC
1489     // unaryExpression CLOSEBRAC ) | reference );
1490     public final CTFParser.postfixExpressionSuffix_return postfixExpressionSuffix()
1491             throws RecognitionException {
1492         CTFParser.postfixExpressionSuffix_return retval = new CTFParser.postfixExpressionSuffix_return();
1493         retval.start = input.LT(1);
1494
1495         CommonTree root_0 = null;
1496
1497         Token OPENBRAC15 = null;
1498         Token CLOSEBRAC17 = null;
1499         CTFParser.unaryExpression_return unaryExpression16 = null;
1500
1501         CTFParser.reference_return reference18 = null;
1502
1503         CommonTree OPENBRAC15_tree = null;
1504         CommonTree CLOSEBRAC17_tree = null;
1505
1506         enter("postfixExpressionSuffix");
1507
1508         try {
1509             // Grammar/CTFParser.g:276:1: ( ( OPENBRAC unaryExpression CLOSEBRAC
1510             // ) | reference )
1511             int alt7 = 2;
1512             int LA7_0 = input.LA(1);
1513
1514             if ((LA7_0 == OPENBRAC)) {
1515                 alt7 = 1;
1516             } else if ((((LA7_0 >= ARROW) && (LA7_0 <= DOT)))) {
1517                 alt7 = 2;
1518             } else {
1519                 if (state.backtracking > 0) {
1520                     state.failed = true;
1521                     return retval;
1522                 }
1523                 NoViableAltException nvae = new NoViableAltException("", 7, 0,
1524                         input);
1525
1526                 throw nvae;
1527             }
1528             switch (alt7) {
1529             case 1:
1530             // Grammar/CTFParser.g:277:5: ( OPENBRAC unaryExpression CLOSEBRAC )
1531             {
1532                 root_0 = (CommonTree) adaptor.nil();
1533
1534                 // Grammar/CTFParser.g:277:5: ( OPENBRAC unaryExpression
1535                 // CLOSEBRAC )
1536                 // Grammar/CTFParser.g:277:6: OPENBRAC unaryExpression CLOSEBRAC
1537                 {
1538                     OPENBRAC15 = (Token) match(input, OPENBRAC,
1539                             FOLLOW_OPENBRAC_in_postfixExpressionSuffix612);
1540                     if (state.failed) {
1541                         return retval;
1542                     }
1543                     if (state.backtracking == 0) {
1544                         OPENBRAC15_tree = (CommonTree) adaptor
1545                                 .create(OPENBRAC15);
1546                         adaptor.addChild(root_0, OPENBRAC15_tree);
1547                     }
1548                     pushFollow(FOLLOW_unaryExpression_in_postfixExpressionSuffix614);
1549                     unaryExpression16 = unaryExpression();
1550
1551                     state._fsp--;
1552                     if (state.failed) {
1553                         return retval;
1554                     }
1555                     if (state.backtracking == 0) {
1556                         adaptor.addChild(root_0, unaryExpression16.getTree());
1557                     }
1558 //                    CLOSEBRAC17 = (Token)
1559                             match(input, CLOSEBRAC,
1560                             FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix616);
1561                     if (state.failed) {
1562                         return retval;
1563                     }
1564
1565                 }
1566
1567             }
1568                 break;
1569             case 2:
1570             // Grammar/CTFParser.g:278:5: reference
1571             {
1572                 root_0 = (CommonTree) adaptor.nil();
1573
1574                 pushFollow(FOLLOW_reference_in_postfixExpressionSuffix624);
1575                 reference18 = reference();
1576
1577                 state._fsp--;
1578                 if (state.failed) {
1579                     return retval;
1580                 }
1581                 if (state.backtracking == 0) {
1582                     adaptor.addChild(root_0, reference18.getTree());
1583                 }
1584
1585             }
1586                 break;
1587
1588             }
1589             retval.stop = input.LT(-1);
1590
1591             if (state.backtracking == 0) {
1592
1593                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
1594                 adaptor.setTokenBoundaries(retval.tree, retval.start,
1595                         retval.stop);
1596             }
1597             if (state.backtracking == 0) {
1598
1599                 exit("postfixExpressionSuffix");
1600
1601             }
1602         }
1603
1604         catch (RecognitionException e) {
1605             throw e;
1606         }
1607         return retval;
1608     }
1609
1610     // $ANTLR end "postfixExpressionSuffix"
1611
1612     public static class postfixExpression_return extends ParserRuleReturnScope {
1613         CommonTree tree;
1614
1615         @Override
1616         public Object getTree() {
1617             return tree;
1618         }
1619     }
1620
1621     // $ANTLR start "postfixExpression"
1622     // Grammar/CTFParser.g:281:1: postfixExpression : ( ( primaryExpression ) (
1623     // postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) (
1624     // postfixExpressionSuffix )+ ) );
1625     public final CTFParser.postfixExpression_return postfixExpression()
1626             throws RecognitionException {
1627         CTFParser.postfixExpression_return retval = new CTFParser.postfixExpression_return();
1628         retval.start = input.LT(1);
1629
1630         CommonTree root_0 = null;
1631
1632         CTFParser.primaryExpression_return primaryExpression19 = null;
1633
1634         CTFParser.postfixExpressionSuffix_return postfixExpressionSuffix20 = null;
1635
1636         CTFParser.ctfSpecifierHead_return ctfSpecifierHead21 = null;
1637
1638         CTFParser.postfixExpressionSuffix_return postfixExpressionSuffix22 = null;
1639
1640         enter("postfixExpression");
1641
1642         try {
1643             // Grammar/CTFParser.g:288:1: ( ( primaryExpression ) (
1644             // postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) (
1645             // postfixExpressionSuffix )+ ) )
1646             int alt10 = 2;
1647             alt10 = dfa10.predict(input);
1648             switch (alt10) {
1649             case 1:
1650             // Grammar/CTFParser.g:289:3: ( primaryExpression ) (
1651             // postfixExpressionSuffix )*
1652             {
1653                 root_0 = (CommonTree) adaptor.nil();
1654
1655                 // Grammar/CTFParser.g:289:3: ( primaryExpression )
1656                 // Grammar/CTFParser.g:289:4: primaryExpression
1657                 {
1658                     pushFollow(FOLLOW_primaryExpression_in_postfixExpression648);
1659                     primaryExpression19 = primaryExpression();
1660
1661                     state._fsp--;
1662                     if (state.failed) {
1663                         return retval;
1664                     }
1665                     if (state.backtracking == 0) {
1666                         adaptor.addChild(root_0, primaryExpression19.getTree());
1667                     }
1668
1669                 }
1670
1671                 // Grammar/CTFParser.g:289:23: ( postfixExpressionSuffix )*
1672                 loop8: do {
1673                     int alt8 = 2;
1674                     int LA8_0 = input.LA(1);
1675
1676                     if (((LA8_0 == OPENBRAC) || ((LA8_0 >= ARROW) && (LA8_0 <= DOT)))) {
1677                         alt8 = 1;
1678                     }
1679
1680                     switch (alt8) {
1681                     case 1:
1682                     // Grammar/CTFParser.g:289:24: postfixExpressionSuffix
1683                     {
1684                         pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression652);
1685                         postfixExpressionSuffix20 = postfixExpressionSuffix();
1686
1687                         state._fsp--;
1688                         if (state.failed) {
1689                             return retval;
1690                         }
1691                         if (state.backtracking == 0) {
1692                             adaptor.addChild(root_0,
1693                                     postfixExpressionSuffix20.getTree());
1694                         }
1695
1696                     }
1697                         break;
1698
1699                     default:
1700                         break loop8;
1701                     }
1702                 } while (true);
1703
1704             }
1705                 break;
1706             case 2:
1707             // Grammar/CTFParser.g:290:3: ( ( ctfSpecifierHead ) (
1708             // postfixExpressionSuffix )+ )
1709             {
1710                 root_0 = (CommonTree) adaptor.nil();
1711
1712                 // Grammar/CTFParser.g:290:3: ( ( ctfSpecifierHead ) (
1713                 // postfixExpressionSuffix )+ )
1714                 // Grammar/CTFParser.g:290:4: ( ctfSpecifierHead ) (
1715                 // postfixExpressionSuffix )+
1716                 {
1717                     // Grammar/CTFParser.g:290:4: ( ctfSpecifierHead )
1718                     // Grammar/CTFParser.g:290:5: ctfSpecifierHead
1719                     {
1720                         pushFollow(FOLLOW_ctfSpecifierHead_in_postfixExpression661);
1721                         ctfSpecifierHead21 = ctfSpecifierHead();
1722
1723                         state._fsp--;
1724                         if (state.failed) {
1725                             return retval;
1726                         }
1727                         if (state.backtracking == 0) {
1728                             adaptor.addChild(root_0,
1729                                     ctfSpecifierHead21.getTree());
1730                         }
1731
1732                     }
1733
1734                     // Grammar/CTFParser.g:290:24: ( postfixExpressionSuffix )+
1735                     int cnt9 = 0;
1736                     loop9: do {
1737                         int alt9 = 2;
1738                         int LA9_0 = input.LA(1);
1739
1740                         if (((LA9_0 == OPENBRAC) || ((LA9_0 >= ARROW) && (LA9_0 <= DOT)))) {
1741                             alt9 = 1;
1742                         }
1743
1744                         switch (alt9) {
1745                         case 1:
1746                         // Grammar/CTFParser.g:290:25: postfixExpressionSuffix
1747                         {
1748                             pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression666);
1749                             postfixExpressionSuffix22 = postfixExpressionSuffix();
1750
1751                             state._fsp--;
1752                             if (state.failed) {
1753                                 return retval;
1754                             }
1755                             if (state.backtracking == 0) {
1756                                 adaptor.addChild(root_0,
1757                                         postfixExpressionSuffix22.getTree());
1758                             }
1759
1760                         }
1761                             break;
1762
1763                         default:
1764                             if (cnt9 >= 1) {
1765                                 break loop9;
1766                             }
1767                             if (state.backtracking > 0) {
1768                                 state.failed = true;
1769                                 return retval;
1770                             }
1771                             EarlyExitException eee = new EarlyExitException(9,
1772                                     input);
1773                             throw eee;
1774                         }
1775                         cnt9++;
1776                     } while (true);
1777
1778                 }
1779
1780             }
1781                 break;
1782
1783             }
1784             retval.stop = input.LT(-1);
1785
1786             if (state.backtracking == 0) {
1787
1788                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
1789                 adaptor.setTokenBoundaries(retval.tree, retval.start,
1790                         retval.stop);
1791             }
1792             if (state.backtracking == 0) {
1793
1794                 exit("postfixExpression");
1795
1796             }
1797         }
1798
1799         catch (RecognitionException e) {
1800             throw e;
1801         }
1802         return retval;
1803     }
1804
1805     // $ANTLR end "postfixExpression"
1806
1807     public static class unaryExpression_return extends ParserRuleReturnScope {
1808         CommonTree tree;
1809
1810         @Override
1811         public Object getTree() {
1812             return tree;
1813         }
1814     }
1815
1816     // $ANTLR start "unaryExpression"
1817     // Grammar/CTFParser.g:293:1: unaryExpression : postfixExpression ;
1818     public final CTFParser.unaryExpression_return unaryExpression()
1819             throws RecognitionException {
1820         CTFParser.unaryExpression_return retval = new CTFParser.unaryExpression_return();
1821         retval.start = input.LT(1);
1822
1823         CommonTree root_0 = null;
1824
1825         CTFParser.postfixExpression_return postfixExpression23 = null;
1826
1827         enter("unaryExpression");
1828
1829         try {
1830             // Grammar/CTFParser.g:300:1: ( postfixExpression )
1831             // Grammar/CTFParser.g:303:5: postfixExpression
1832             {
1833                 root_0 = (CommonTree) adaptor.nil();
1834
1835                 pushFollow(FOLLOW_postfixExpression_in_unaryExpression700);
1836                 postfixExpression23 = postfixExpression();
1837
1838                 state._fsp--;
1839                 if (state.failed) {
1840                     return retval;
1841                 }
1842                 if (state.backtracking == 0) {
1843                     adaptor.addChild(root_0, postfixExpression23.getTree());
1844                 }
1845
1846             }
1847
1848             retval.stop = input.LT(-1);
1849
1850             if (state.backtracking == 0) {
1851
1852                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
1853                 adaptor.setTokenBoundaries(retval.tree, retval.start,
1854                         retval.stop);
1855             }
1856             if (state.backtracking == 0) {
1857
1858                 exit("unaryExpression");
1859
1860             }
1861         }
1862
1863         catch (RecognitionException e) {
1864             throw e;
1865         }
1866         return retval;
1867     }
1868
1869     // $ANTLR end "unaryExpression"
1870
1871     public static class enumConstant_return extends ParserRuleReturnScope {
1872         CommonTree tree;
1873
1874         @Override
1875         public Object getTree() {
1876             return tree;
1877         }
1878     }
1879
1880     // $ANTLR start "enumConstant"
1881     // Grammar/CTFParser.g:306:1: enumConstant : ( STRING_LITERAL -> ^(
1882     // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER -> ^(
1883     // UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^(
1884     // UNARY_EXPRESSION_STRING ctfKeyword ) );
1885     public final CTFParser.enumConstant_return enumConstant()
1886             throws RecognitionException {
1887         CTFParser.enumConstant_return retval = new CTFParser.enumConstant_return();
1888         retval.start = input.LT(1);
1889
1890         CommonTree root_0 = null;
1891
1892         Token STRING_LITERAL24 = null;
1893         Token IDENTIFIER25 = null;
1894         CTFParser.ctfKeyword_return ctfKeyword26 = null;
1895
1896         CommonTree STRING_LITERAL24_tree = null;
1897         CommonTree IDENTIFIER25_tree = null;
1898         RewriteRuleTokenStream stream_STRING_LITERAL = new RewriteRuleTokenStream(
1899                 adaptor, "token STRING_LITERAL");
1900         RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
1901                 adaptor, "token IDENTIFIER");
1902         RewriteRuleSubtreeStream stream_ctfKeyword = new RewriteRuleSubtreeStream(
1903                 adaptor, "rule ctfKeyword");
1904
1905         enter("enumConstant");
1906
1907         try {
1908             // Grammar/CTFParser.g:314:1: ( STRING_LITERAL -> ^(
1909             // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER ->
1910             // ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^(
1911             // UNARY_EXPRESSION_STRING ctfKeyword ) )
1912             int alt11 = 3;
1913             switch (input.LA(1)) {
1914             case STRING_LITERAL: {
1915                 alt11 = 1;
1916             }
1917                 break;
1918             case IDENTIFIER: {
1919                 alt11 = 2;
1920             }
1921                 break;
1922             case ALIGNTOK:
1923             case EVENTTOK:
1924             case SIGNEDTOK:
1925             case STRINGTOK: {
1926                 alt11 = 3;
1927             }
1928                 break;
1929             default:
1930                 if (state.backtracking > 0) {
1931                     state.failed = true;
1932                     return retval;
1933                 }
1934                 NoViableAltException nvae = new NoViableAltException("", 11, 0,
1935                         input);
1936
1937                 throw nvae;
1938             }
1939
1940             switch (alt11) {
1941             case 1:
1942             // Grammar/CTFParser.g:315:5: STRING_LITERAL
1943             {
1944                 STRING_LITERAL24 = (Token) match(input, STRING_LITERAL,
1945                         FOLLOW_STRING_LITERAL_in_enumConstant725);
1946                 if (state.failed) {
1947                     return retval;
1948                 }
1949                 if (state.backtracking == 0) {
1950                     stream_STRING_LITERAL.add(STRING_LITERAL24);
1951                 }
1952
1953                 // AST REWRITE
1954                 // elements: STRING_LITERAL
1955                 // token labels:
1956                 // rule labels: retval
1957                 // token list labels:
1958                 // rule list labels:
1959                 // wildcard labels:
1960                 if (state.backtracking == 0) {
1961                     retval.tree = root_0;
1962 //                    RewriteRuleSubtreeStream stream_retval =
1963                             new RewriteRuleSubtreeStream(
1964                             adaptor, "rule retval",
1965                             retval != null ? retval.tree : null);
1966
1967                     root_0 = (CommonTree) adaptor.nil();
1968                     // 315:20: -> ^( UNARY_EXPRESSION_STRING_QUOTES
1969                     // STRING_LITERAL )
1970                     {
1971                         // Grammar/CTFParser.g:315:23: ^(
1972                         // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
1973                         {
1974                             CommonTree root_1 = (CommonTree) adaptor.nil();
1975                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
1976                                     .create(UNARY_EXPRESSION_STRING_QUOTES,
1977                                             "UNARY_EXPRESSION_STRING_QUOTES"),
1978                                     root_1);
1979
1980                             adaptor.addChild(root_1,
1981                                     stream_STRING_LITERAL.nextNode());
1982
1983                             adaptor.addChild(root_0, root_1);
1984                         }
1985
1986                     }
1987
1988                     retval.tree = root_0;
1989                 }
1990             }
1991                 break;
1992             case 2:
1993             // Grammar/CTFParser.g:316:7: IDENTIFIER
1994             {
1995                 IDENTIFIER25 = (Token) match(input, IDENTIFIER,
1996                         FOLLOW_IDENTIFIER_in_enumConstant741);
1997                 if (state.failed) {
1998                     return retval;
1999                 }
2000                 if (state.backtracking == 0) {
2001                     stream_IDENTIFIER.add(IDENTIFIER25);
2002                 }
2003
2004                 // AST REWRITE
2005                 // elements: IDENTIFIER
2006                 // token labels:
2007                 // rule labels: retval
2008                 // token list labels:
2009                 // rule list labels:
2010                 // wildcard labels:
2011                 if (state.backtracking == 0) {
2012                     retval.tree = root_0;
2013 //                    RewriteRuleSubtreeStream stream_retval =
2014                             new RewriteRuleSubtreeStream(
2015                             adaptor, "rule retval",
2016                             retval != null ? retval.tree : null);
2017
2018                     root_0 = (CommonTree) adaptor.nil();
2019                     // 316:18: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
2020                     {
2021                         // Grammar/CTFParser.g:316:21: ^(
2022                         // UNARY_EXPRESSION_STRING IDENTIFIER )
2023                         {
2024                             CommonTree root_1 = (CommonTree) adaptor.nil();
2025                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
2026                                     .create(UNARY_EXPRESSION_STRING,
2027                                             "UNARY_EXPRESSION_STRING"), root_1);
2028
2029                             adaptor.addChild(root_1,
2030                                     stream_IDENTIFIER.nextNode());
2031
2032                             adaptor.addChild(root_0, root_1);
2033                         }
2034
2035                     }
2036
2037                     retval.tree = root_0;
2038                 }
2039             }
2040                 break;
2041             case 3:
2042             // Grammar/CTFParser.g:317:7: ctfKeyword
2043             {
2044                 pushFollow(FOLLOW_ctfKeyword_in_enumConstant757);
2045                 ctfKeyword26 = ctfKeyword();
2046
2047                 state._fsp--;
2048                 if (state.failed) {
2049                     return retval;
2050                 }
2051                 if (state.backtracking == 0) {
2052                     stream_ctfKeyword.add(ctfKeyword26.getTree());
2053                 }
2054
2055                 // AST REWRITE
2056                 // elements: ctfKeyword
2057                 // token labels:
2058                 // rule labels: retval
2059                 // token list labels:
2060                 // rule list labels:
2061                 // wildcard labels:
2062                 if (state.backtracking == 0) {
2063                     retval.tree = root_0;
2064 //                    RewriteRuleSubtreeStream stream_retval =
2065                             new RewriteRuleSubtreeStream(
2066                             adaptor, "rule retval",
2067                             retval != null ? retval.tree : null);
2068
2069                     root_0 = (CommonTree) adaptor.nil();
2070                     // 317:18: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
2071                     {
2072                         // Grammar/CTFParser.g:317:21: ^(
2073                         // UNARY_EXPRESSION_STRING ctfKeyword )
2074                         {
2075                             CommonTree root_1 = (CommonTree) adaptor.nil();
2076                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
2077                                     .create(UNARY_EXPRESSION_STRING,
2078                                             "UNARY_EXPRESSION_STRING"), root_1);
2079
2080                             adaptor.addChild(root_1,
2081                                     stream_ctfKeyword.nextTree());
2082
2083                             adaptor.addChild(root_0, root_1);
2084                         }
2085
2086                     }
2087
2088                     retval.tree = root_0;
2089                 }
2090             }
2091                 break;
2092
2093             }
2094             retval.stop = input.LT(-1);
2095
2096             if (state.backtracking == 0) {
2097
2098                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
2099                 adaptor.setTokenBoundaries(retval.tree, retval.start,
2100                         retval.stop);
2101             }
2102             if (state.backtracking == 0) {
2103
2104                 debug_print(input.toString(retval.start, input.LT(-1)));
2105                 exit("enumConstant");
2106
2107             }
2108         }
2109
2110         catch (RecognitionException e) {
2111             throw e;
2112         }
2113         return retval;
2114     }
2115
2116     // $ANTLR end "enumConstant"
2117
2118     public static class declaration_return extends ParserRuleReturnScope {
2119         CommonTree tree;
2120
2121         @Override
2122         public Object getTree() {
2123             return tree;
2124         }
2125     }
2126
2127     // $ANTLR start "declaration"
2128     // Grammar/CTFParser.g:321:1: declaration : ( ( declarationSpecifiers (
2129     // declaratorList )? TERM ) -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF
2130     // declaratorList declarationSpecifiers ) ) -> ^( DECLARATION
2131     // declarationSpecifiers ( declaratorList )? ) | ( ctfSpecifier TERM ) );
2132     public final CTFParser.declaration_return declaration()
2133             throws RecognitionException {
2134         CTFParser.declaration_return retval = new CTFParser.declaration_return();
2135         retval.start = input.LT(1);
2136
2137         CommonTree root_0 = null;
2138
2139         Token TERM29 = null;
2140         Token TERM31 = null;
2141         CTFParser.declarationSpecifiers_return declarationSpecifiers27 = null;
2142
2143         CTFParser.declaratorList_return declaratorList28 = null;
2144
2145         CTFParser.ctfSpecifier_return ctfSpecifier30 = null;
2146
2147         CommonTree TERM29_tree = null;
2148         CommonTree TERM31_tree = null;
2149         RewriteRuleTokenStream stream_TERM = new RewriteRuleTokenStream(
2150                 adaptor, "token TERM");
2151         RewriteRuleSubtreeStream stream_declaratorList = new RewriteRuleSubtreeStream(
2152                 adaptor, "rule declaratorList");
2153         RewriteRuleSubtreeStream stream_declarationSpecifiers = new RewriteRuleSubtreeStream(
2154                 adaptor, "rule declarationSpecifiers");
2155
2156         enter("declaration");
2157
2158         try {
2159             // Grammar/CTFParser.g:330:1: ( ( declarationSpecifiers (
2160             // declaratorList )? TERM ) -> {inTypedef()}? ^( DECLARATION ^(
2161             // TYPEDEF declaratorList declarationSpecifiers ) ) -> ^(
2162             // DECLARATION declarationSpecifiers ( declaratorList )? ) | (
2163             // ctfSpecifier TERM ) )
2164             int alt13 = 2;
2165             int LA13_0 = input.LA(1);
2166
2167             if ((((LA13_0 >= CONSTTOK) && (LA13_0 <= ENUMTOK))
2168                     || ((LA13_0 >= FLOATINGPOINTTOK) && (LA13_0 <= SIGNEDTOK))
2169                     || ((LA13_0 >= STRINGTOK) && (LA13_0 <= STRUCTTOK)) || ((LA13_0 >= TYPEDEFTOK) && (LA13_0 <= IMAGINARYTOK)))) {
2170                 alt13 = 1;
2171             } else if ((LA13_0 == IDENTIFIER)
2172                     && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
2173                 alt13 = 1;
2174             } else if (((LA13_0 == EVENTTOK) || (LA13_0 == STREAMTOK)
2175                     || ((LA13_0 >= TRACETOK) && (LA13_0 <= TYPEALIASTOK)) || ((LA13_0 >= ENVTOK) && (LA13_0 <= CLOCKTOK)))) {
2176                 alt13 = 2;
2177             } else {
2178                 if (state.backtracking > 0) {
2179                     state.failed = true;
2180                     return retval;
2181                 }
2182                 NoViableAltException nvae = new NoViableAltException("", 13, 0,
2183                         input);
2184
2185                 throw nvae;
2186             }
2187             switch (alt13) {
2188             case 1:
2189             // Grammar/CTFParser.g:331:3: ( declarationSpecifiers (
2190             // declaratorList )? TERM )
2191             {
2192                 // Grammar/CTFParser.g:331:3: ( declarationSpecifiers (
2193                 // declaratorList )? TERM )
2194                 // Grammar/CTFParser.g:331:4: declarationSpecifiers (
2195                 // declaratorList )? TERM
2196                 {
2197                     pushFollow(FOLLOW_declarationSpecifiers_in_declaration790);
2198                     declarationSpecifiers27 = declarationSpecifiers();
2199
2200                     state._fsp--;
2201                     if (state.failed) {
2202                         return retval;
2203                     }
2204                     if (state.backtracking == 0) {
2205                         stream_declarationSpecifiers
2206                                 .add(declarationSpecifiers27.getTree());
2207                     }
2208                     // Grammar/CTFParser.g:331:26: ( declaratorList )?
2209                     int alt12 = 2;
2210                     int LA12_0 = input.LA(1);
2211
2212                     if (((LA12_0 == POINTER) || (LA12_0 == IDENTIFIER))) {
2213                         alt12 = 1;
2214                     }
2215                     switch (alt12) {
2216                     case 1:
2217                     // Grammar/CTFParser.g:331:26: declaratorList
2218                     {
2219                         pushFollow(FOLLOW_declaratorList_in_declaration792);
2220                         declaratorList28 = declaratorList();
2221
2222                         state._fsp--;
2223                         if (state.failed) {
2224                             return retval;
2225                         }
2226                         if (state.backtracking == 0) {
2227                             stream_declaratorList.add(declaratorList28
2228                                     .getTree());
2229                         }
2230
2231                     }
2232                         break;
2233
2234                     }
2235
2236                     TERM29 = (Token) match(input, TERM,
2237                             FOLLOW_TERM_in_declaration795);
2238                     if (state.failed) {
2239                         return retval;
2240                     }
2241                     if (state.backtracking == 0) {
2242                         stream_TERM.add(TERM29);
2243                     }
2244
2245                 }
2246
2247                 // AST REWRITE
2248                 // elements: declaratorList, declaratorList,
2249                 // declarationSpecifiers, declarationSpecifiers
2250                 // token labels:
2251                 // rule labels: retval
2252                 // token list labels:
2253                 // rule list labels:
2254                 // wildcard labels:
2255                 if (state.backtracking == 0) {
2256                     retval.tree = root_0;
2257 //                    RewriteRuleSubtreeStream stream_retval =
2258                             new RewriteRuleSubtreeStream(
2259                             adaptor, "rule retval",
2260                             retval != null ? retval.tree : null);
2261
2262                     root_0 = (CommonTree) adaptor.nil();
2263                     // 334:3: -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF
2264                     // declaratorList declarationSpecifiers ) )
2265                     if (inTypedef()) {
2266                         // Grammar/CTFParser.g:334:21: ^( DECLARATION ^( TYPEDEF
2267                         // declaratorList declarationSpecifiers ) )
2268                         {
2269                             CommonTree root_1 = (CommonTree) adaptor.nil();
2270                             root_1 = (CommonTree) adaptor.becomeRoot(
2271                                     adaptor.create(DECLARATION, "DECLARATION"),
2272                                     root_1);
2273
2274                             // Grammar/CTFParser.g:334:35: ^( TYPEDEF
2275                             // declaratorList declarationSpecifiers )
2276                             {
2277                                 CommonTree root_2 = (CommonTree) adaptor.nil();
2278                                 root_2 = (CommonTree) adaptor.becomeRoot(
2279                                         adaptor.create(TYPEDEF, "TYPEDEF"),
2280                                         root_2);
2281
2282                                 adaptor.addChild(root_2,
2283                                         stream_declaratorList.nextTree());
2284                                 adaptor.addChild(root_2,
2285                                         stream_declarationSpecifiers.nextTree());
2286
2287                                 adaptor.addChild(root_1, root_2);
2288                             }
2289
2290                             adaptor.addChild(root_0, root_1);
2291                         }
2292
2293                     } else // 335:3: -> ^( DECLARATION declarationSpecifiers (
2294                            // declaratorList )? )
2295                     {
2296                         // Grammar/CTFParser.g:335:6: ^( DECLARATION
2297                         // declarationSpecifiers ( declaratorList )? )
2298                         {
2299                             CommonTree root_1 = (CommonTree) adaptor.nil();
2300                             root_1 = (CommonTree) adaptor.becomeRoot(
2301                                     adaptor.create(DECLARATION, "DECLARATION"),
2302                                     root_1);
2303
2304                             adaptor.addChild(root_1,
2305                                     stream_declarationSpecifiers.nextTree());
2306                             // Grammar/CTFParser.g:335:42: ( declaratorList )?
2307                             if (stream_declaratorList.hasNext()) {
2308                                 adaptor.addChild(root_1,
2309                                         stream_declaratorList.nextTree());
2310
2311                             }
2312                             stream_declaratorList.reset();
2313
2314                             adaptor.addChild(root_0, root_1);
2315                         }
2316
2317                     }
2318
2319                     retval.tree = root_0;
2320                 }
2321             }
2322                 break;
2323             case 2:
2324             // Grammar/CTFParser.g:337:5: ( ctfSpecifier TERM )
2325             {
2326                 root_0 = (CommonTree) adaptor.nil();
2327
2328                 // Grammar/CTFParser.g:337:5: ( ctfSpecifier TERM )
2329                 // Grammar/CTFParser.g:337:6: ctfSpecifier TERM
2330                 {
2331                     pushFollow(FOLLOW_ctfSpecifier_in_declaration844);
2332                     ctfSpecifier30 = ctfSpecifier();
2333
2334                     state._fsp--;
2335                     if (state.failed) {
2336                         return retval;
2337                     }
2338                     if (state.backtracking == 0) {
2339                         adaptor.addChild(root_0, ctfSpecifier30.getTree());
2340                     }
2341 //                    TERM31 = (Token)
2342                             match(input, TERM,
2343                             FOLLOW_TERM_in_declaration846);
2344                     if (state.failed) {
2345                         return retval;
2346                     }
2347
2348                 }
2349
2350             }
2351                 break;
2352
2353             }
2354             retval.stop = input.LT(-1);
2355
2356             if (state.backtracking == 0) {
2357
2358                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
2359                 adaptor.setTokenBoundaries(retval.tree, retval.start,
2360                         retval.stop);
2361             }
2362             if (state.backtracking == 0) {
2363
2364                 exit("declaration");
2365                 if (inTypedef()) {
2366                     typedefOff();
2367                 }
2368
2369             }
2370         }
2371
2372         catch (RecognitionException e) {
2373             throw e;
2374         }
2375         return retval;
2376     }
2377
2378     // $ANTLR end "declaration"
2379
2380     public static class declarationSpecifiers_return extends
2381             ParserRuleReturnScope {
2382         CommonTree tree;
2383
2384         @Override
2385         public Object getTree() {
2386             return tree;
2387         }
2388     }
2389
2390     // $ANTLR start "declarationSpecifiers"
2391     // Grammar/CTFParser.g:340:1: declarationSpecifiers : (
2392     // storageClassSpecifier | typeQualifier | typeSpecifier )+ -> ^(
2393     // TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
2394     public final CTFParser.declarationSpecifiers_return declarationSpecifiers()
2395             throws RecognitionException {
2396         CTFParser.declarationSpecifiers_return retval = new CTFParser.declarationSpecifiers_return();
2397         retval.start = input.LT(1);
2398
2399         CommonTree root_0 = null;
2400
2401         CTFParser.storageClassSpecifier_return storageClassSpecifier32 = null;
2402
2403         CTFParser.typeQualifier_return typeQualifier33 = null;
2404
2405         CTFParser.typeSpecifier_return typeSpecifier34 = null;
2406
2407         RewriteRuleSubtreeStream stream_typeSpecifier = new RewriteRuleSubtreeStream(
2408                 adaptor, "rule typeSpecifier");
2409         RewriteRuleSubtreeStream stream_typeQualifier = new RewriteRuleSubtreeStream(
2410                 adaptor, "rule typeQualifier");
2411         RewriteRuleSubtreeStream stream_storageClassSpecifier = new RewriteRuleSubtreeStream(
2412                 adaptor, "rule storageClassSpecifier");
2413
2414         enter("declarationSpecifiers");
2415
2416         try {
2417             // Grammar/CTFParser.g:348:1: ( ( storageClassSpecifier |
2418             // typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST (
2419             // typeQualifier )* ( typeSpecifier )* ) )
2420             // Grammar/CTFParser.g:349:3: ( storageClassSpecifier |
2421             // typeQualifier | typeSpecifier )+
2422             {
2423                 // Grammar/CTFParser.g:349:3: ( storageClassSpecifier |
2424                 // typeQualifier | typeSpecifier )+
2425                 int cnt14 = 0;
2426                 loop14: do {
2427                     int alt14 = 4;
2428                     switch (input.LA(1)) {
2429                     case IDENTIFIER: {
2430                         int LA14_2 = input.LA(2);
2431
2432                         if (((inTypealiasAlias() || isTypeName(input.LT(1)
2433                                 .getText())))) {
2434                             alt14 = 3;
2435                         }
2436
2437                     }
2438                         break;
2439                     case TYPEDEFTOK: {
2440                         alt14 = 1;
2441                     }
2442                         break;
2443                     case CONSTTOK: {
2444                         alt14 = 2;
2445                     }
2446                         break;
2447                     case CHARTOK:
2448                     case DOUBLETOK:
2449                     case ENUMTOK:
2450                     case FLOATINGPOINTTOK:
2451                     case FLOATTOK:
2452                     case INTEGERTOK:
2453                     case INTTOK:
2454                     case LONGTOK:
2455                     case SHORTTOK:
2456                     case SIGNEDTOK:
2457                     case STRINGTOK:
2458                     case STRUCTTOK:
2459                     case UNSIGNEDTOK:
2460                     case VARIANTTOK:
2461                     case VOIDTOK:
2462                     case BOOLTOK:
2463                     case COMPLEXTOK:
2464                     case IMAGINARYTOK: {
2465                         alt14 = 3;
2466                     }
2467                         break;
2468
2469                     }
2470
2471                     switch (alt14) {
2472                     case 1:
2473                     // Grammar/CTFParser.g:352:6: storageClassSpecifier
2474                     {
2475                         pushFollow(FOLLOW_storageClassSpecifier_in_declarationSpecifiers891);
2476                         storageClassSpecifier32 = storageClassSpecifier();
2477
2478                         state._fsp--;
2479                         if (state.failed) {
2480                             return retval;
2481                         }
2482                         if (state.backtracking == 0) {
2483                             stream_storageClassSpecifier
2484                                     .add(storageClassSpecifier32.getTree());
2485                         }
2486
2487                     }
2488                         break;
2489                     case 2:
2490                     // Grammar/CTFParser.g:353:6: typeQualifier
2491                     {
2492                         pushFollow(FOLLOW_typeQualifier_in_declarationSpecifiers898);
2493                         typeQualifier33 = typeQualifier();
2494
2495                         state._fsp--;
2496                         if (state.failed) {
2497                             return retval;
2498                         }
2499                         if (state.backtracking == 0) {
2500                             stream_typeQualifier.add(typeQualifier33.getTree());
2501                         }
2502
2503                     }
2504                         break;
2505                     case 3:
2506                     // Grammar/CTFParser.g:354:6: typeSpecifier
2507                     {
2508                         pushFollow(FOLLOW_typeSpecifier_in_declarationSpecifiers905);
2509                         typeSpecifier34 = typeSpecifier();
2510
2511                         state._fsp--;
2512                         if (state.failed) {
2513                             return retval;
2514                         }
2515                         if (state.backtracking == 0) {
2516                             stream_typeSpecifier.add(typeSpecifier34.getTree());
2517                         }
2518
2519                     }
2520                         break;
2521
2522                     default:
2523                         if (cnt14 >= 1) {
2524                             break loop14;
2525                         }
2526                         if (state.backtracking > 0) {
2527                             state.failed = true;
2528                             return retval;
2529                         }
2530                         EarlyExitException eee = new EarlyExitException(14,
2531                                 input);
2532                         throw eee;
2533                     }
2534                     cnt14++;
2535                 } while (true);
2536
2537                 // AST REWRITE
2538                 // elements: typeQualifier, typeSpecifier
2539                 // token labels:
2540                 // rule labels: retval
2541                 // token list labels:
2542                 // rule list labels:
2543                 // wildcard labels:
2544                 if (state.backtracking == 0) {
2545                     retval.tree = root_0;
2546 //                    RewriteRuleSubtreeStream stream_retval =
2547                             new RewriteRuleSubtreeStream(
2548                             adaptor, "rule retval",
2549                             retval != null ? retval.tree : null);
2550
2551                     root_0 = (CommonTree) adaptor.nil();
2552                     // 355:6: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
2553                     // typeSpecifier )* )
2554                     {
2555                         // Grammar/CTFParser.g:355:9: ^( TYPE_SPECIFIER_LIST (
2556                         // typeQualifier )* ( typeSpecifier )* )
2557                         {
2558                             CommonTree root_1 = (CommonTree) adaptor.nil();
2559                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
2560                                     .create(TYPE_SPECIFIER_LIST,
2561                                             "TYPE_SPECIFIER_LIST"), root_1);
2562
2563                             // Grammar/CTFParser.g:355:31: ( typeQualifier )*
2564                             while (stream_typeQualifier.hasNext()) {
2565                                 adaptor.addChild(root_1,
2566                                         stream_typeQualifier.nextTree());
2567
2568                             }
2569                             stream_typeQualifier.reset();
2570                             // Grammar/CTFParser.g:355:46: ( typeSpecifier )*
2571                             while (stream_typeSpecifier.hasNext()) {
2572                                 adaptor.addChild(root_1,
2573                                         stream_typeSpecifier.nextTree());
2574
2575                             }
2576                             stream_typeSpecifier.reset();
2577
2578                             adaptor.addChild(root_0, root_1);
2579                         }
2580
2581                     }
2582
2583                     retval.tree = root_0;
2584                 }
2585             }
2586
2587             retval.stop = input.LT(-1);
2588
2589             if (state.backtracking == 0) {
2590
2591                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
2592                 adaptor.setTokenBoundaries(retval.tree, retval.start,
2593                         retval.stop);
2594             }
2595             if (state.backtracking == 0) {
2596
2597                 debug_print(input.toString(retval.start, input.LT(-1)));
2598                 exit("declarationSpecifiers");
2599
2600             }
2601         }
2602
2603         catch (RecognitionException e) {
2604             throw e;
2605
2606         }
2607         return retval;
2608     }
2609
2610     // $ANTLR end "declarationSpecifiers"
2611
2612     public static class declaratorList_return extends ParserRuleReturnScope {
2613         CommonTree tree;
2614
2615         @Override
2616         public Object getTree() {
2617             return tree;
2618         }
2619     }
2620
2621     // $ANTLR start "declaratorList"
2622     // Grammar/CTFParser.g:358:1: declaratorList : declarator ( SEPARATOR
2623     // declarator )* -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) ;
2624     public final CTFParser.declaratorList_return declaratorList()
2625             throws RecognitionException {
2626         CTFParser.declaratorList_return retval = new CTFParser.declaratorList_return();
2627         retval.start = input.LT(1);
2628
2629         CommonTree root_0 = null;
2630
2631         Token SEPARATOR36 = null;
2632         CTFParser.declarator_return declarator35 = null;
2633
2634         CTFParser.declarator_return declarator37 = null;
2635
2636         CommonTree SEPARATOR36_tree = null;
2637         RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
2638                 adaptor, "token SEPARATOR");
2639         RewriteRuleSubtreeStream stream_declarator = new RewriteRuleSubtreeStream(
2640                 adaptor, "rule declarator");
2641
2642         enter("declaratorList");
2643
2644         try {
2645             // Grammar/CTFParser.g:365:1: ( declarator ( SEPARATOR declarator )*
2646             // -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) )
2647             // Grammar/CTFParser.g:366:3: declarator ( SEPARATOR declarator )*
2648             {
2649                 pushFollow(FOLLOW_declarator_in_declaratorList946);
2650                 declarator35 = declarator();
2651
2652                 state._fsp--;
2653                 if (state.failed) {
2654                     return retval;
2655                 }
2656                 if (state.backtracking == 0) {
2657                     stream_declarator.add(declarator35.getTree());
2658                 }
2659                 // Grammar/CTFParser.g:366:14: ( SEPARATOR declarator )*
2660                 loop15: do {
2661                     int alt15 = 2;
2662                     int LA15_0 = input.LA(1);
2663
2664                     if ((LA15_0 == SEPARATOR)) {
2665                         alt15 = 1;
2666                     }
2667
2668                     switch (alt15) {
2669                     case 1:
2670                     // Grammar/CTFParser.g:366:15: SEPARATOR declarator
2671                     {
2672                         SEPARATOR36 = (Token) match(input, SEPARATOR,
2673                                 FOLLOW_SEPARATOR_in_declaratorList949);
2674                         if (state.failed) {
2675                             return retval;
2676                         }
2677                         if (state.backtracking == 0) {
2678                             stream_SEPARATOR.add(SEPARATOR36);
2679                         }
2680
2681                         pushFollow(FOLLOW_declarator_in_declaratorList951);
2682                         declarator37 = declarator();
2683
2684                         state._fsp--;
2685                         if (state.failed) {
2686                             return retval;
2687                         }
2688                         if (state.backtracking == 0) {
2689                             stream_declarator.add(declarator37.getTree());
2690                         }
2691
2692                     }
2693                         break;
2694
2695                     default:
2696                         break loop15;
2697                     }
2698                 } while (true);
2699
2700                 // AST REWRITE
2701                 // elements: declarator
2702                 // token labels:
2703                 // rule labels: retval
2704                 // token list labels:
2705                 // rule list labels:
2706                 // wildcard labels:
2707                 if (state.backtracking == 0) {
2708                     retval.tree = root_0;
2709 //                    RewriteRuleSubtreeStream stream_retval =
2710                             new RewriteRuleSubtreeStream(
2711                             adaptor, "rule retval",
2712                             retval != null ? retval.tree : null);
2713
2714                     root_0 = (CommonTree) adaptor.nil();
2715                     // 366:38: -> ^( TYPE_DECLARATOR_LIST ( declarator )+ )
2716                     {
2717                         // Grammar/CTFParser.g:366:41: ^( TYPE_DECLARATOR_LIST (
2718                         // declarator )+ )
2719                         {
2720                             CommonTree root_1 = (CommonTree) adaptor.nil();
2721                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
2722                                     .create(TYPE_DECLARATOR_LIST,
2723                                             "TYPE_DECLARATOR_LIST"), root_1);
2724
2725                             if (!(stream_declarator.hasNext())) {
2726                                 throw new RewriteEarlyExitException();
2727                             }
2728                             while (stream_declarator.hasNext()) {
2729                                 adaptor.addChild(root_1,
2730                                         stream_declarator.nextTree());
2731
2732                             }
2733                             stream_declarator.reset();
2734
2735                             adaptor.addChild(root_0, root_1);
2736                         }
2737
2738                     }
2739
2740                     retval.tree = root_0;
2741                 }
2742             }
2743
2744             retval.stop = input.LT(-1);
2745
2746             if (state.backtracking == 0) {
2747
2748                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
2749                 adaptor.setTokenBoundaries(retval.tree, retval.start,
2750                         retval.stop);
2751             }
2752             if (state.backtracking == 0) {
2753
2754                 exit("declaratorList");
2755
2756             }
2757         }
2758
2759         catch (RecognitionException e) {
2760             throw e;
2761
2762         }
2763         return retval;
2764     }
2765
2766     // $ANTLR end "declaratorList"
2767
2768     public static class abstractDeclaratorList_return extends
2769             ParserRuleReturnScope {
2770         CommonTree tree;
2771
2772         @Override
2773         public Object getTree() {
2774             return tree;
2775         }
2776     }
2777
2778     // $ANTLR start "abstractDeclaratorList"
2779     // Grammar/CTFParser.g:369:1: abstractDeclaratorList : abstractDeclarator (
2780     // SEPARATOR abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST (
2781     // abstractDeclarator )+ ) ;
2782     public final CTFParser.abstractDeclaratorList_return abstractDeclaratorList()
2783             throws RecognitionException {
2784         CTFParser.abstractDeclaratorList_return retval = new CTFParser.abstractDeclaratorList_return();
2785         retval.start = input.LT(1);
2786
2787         CommonTree root_0 = null;
2788
2789         Token SEPARATOR39 = null;
2790         CTFParser.abstractDeclarator_return abstractDeclarator38 = null;
2791
2792         CTFParser.abstractDeclarator_return abstractDeclarator40 = null;
2793
2794         CommonTree SEPARATOR39_tree = null;
2795         RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
2796                 adaptor, "token SEPARATOR");
2797         RewriteRuleSubtreeStream stream_abstractDeclarator = new RewriteRuleSubtreeStream(
2798                 adaptor, "rule abstractDeclarator");
2799
2800         enter("abstractDeclaratorList");
2801
2802         try {
2803             // Grammar/CTFParser.g:376:1: ( abstractDeclarator ( SEPARATOR
2804             // abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST (
2805             // abstractDeclarator )+ ) )
2806             // Grammar/CTFParser.g:377:3: abstractDeclarator ( SEPARATOR
2807             // abstractDeclarator )*
2808             {
2809                 pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList985);
2810                 abstractDeclarator38 = abstractDeclarator();
2811
2812                 state._fsp--;
2813                 if (state.failed) {
2814                     return retval;
2815                 }
2816                 if (state.backtracking == 0) {
2817                     stream_abstractDeclarator.add(abstractDeclarator38
2818                             .getTree());
2819                 }
2820                 // Grammar/CTFParser.g:377:22: ( SEPARATOR abstractDeclarator )*
2821                 loop16: do {
2822                     int alt16 = 2;
2823                     int LA16_0 = input.LA(1);
2824
2825                     if ((LA16_0 == SEPARATOR)) {
2826                         alt16 = 1;
2827                     }
2828
2829                     switch (alt16) {
2830                     case 1:
2831                     // Grammar/CTFParser.g:377:23: SEPARATOR abstractDeclarator
2832                     {
2833                         SEPARATOR39 = (Token) match(input, SEPARATOR,
2834                                 FOLLOW_SEPARATOR_in_abstractDeclaratorList988);
2835                         if (state.failed) {
2836                             return retval;
2837                         }
2838                         if (state.backtracking == 0) {
2839                             stream_SEPARATOR.add(SEPARATOR39);
2840                         }
2841
2842                         pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList990);
2843                         abstractDeclarator40 = abstractDeclarator();
2844
2845                         state._fsp--;
2846                         if (state.failed) {
2847                             return retval;
2848                         }
2849                         if (state.backtracking == 0) {
2850                             stream_abstractDeclarator.add(abstractDeclarator40
2851                                     .getTree());
2852                         }
2853
2854                     }
2855                         break;
2856
2857                     default:
2858                         break loop16;
2859                     }
2860                 } while (true);
2861
2862                 // AST REWRITE
2863                 // elements: abstractDeclarator
2864                 // token labels:
2865                 // rule labels: retval
2866                 // token list labels:
2867                 // rule list labels:
2868                 // wildcard labels:
2869                 if (state.backtracking == 0) {
2870                     retval.tree = root_0;
2871 //                    RewriteRuleSubtreeStream stream_retval =
2872                             new RewriteRuleSubtreeStream(
2873                             adaptor, "rule retval",
2874                             retval != null ? retval.tree : null);
2875
2876                     root_0 = (CommonTree) adaptor.nil();
2877                     // 377:54: -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator
2878                     // )+ )
2879                     {
2880                         // Grammar/CTFParser.g:377:57: ^( TYPE_DECLARATOR_LIST (
2881                         // abstractDeclarator )+ )
2882                         {
2883                             CommonTree root_1 = (CommonTree) adaptor.nil();
2884                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
2885                                     .create(TYPE_DECLARATOR_LIST,
2886                                             "TYPE_DECLARATOR_LIST"), root_1);
2887
2888                             if (!(stream_abstractDeclarator.hasNext())) {
2889                                 throw new RewriteEarlyExitException();
2890                             }
2891                             while (stream_abstractDeclarator.hasNext()) {
2892                                 adaptor.addChild(root_1,
2893                                         stream_abstractDeclarator.nextTree());
2894
2895                             }
2896                             stream_abstractDeclarator.reset();
2897
2898                             adaptor.addChild(root_0, root_1);
2899                         }
2900
2901                     }
2902
2903                     retval.tree = root_0;
2904                 }
2905             }
2906
2907             retval.stop = input.LT(-1);
2908
2909             if (state.backtracking == 0) {
2910
2911                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
2912                 adaptor.setTokenBoundaries(retval.tree, retval.start,
2913                         retval.stop);
2914             }
2915             if (state.backtracking == 0) {
2916
2917                 exit("abstractDeclaratorList");
2918
2919             }
2920         }
2921
2922         catch (RecognitionException e) {
2923             throw e;
2924         }
2925         return retval;
2926     }
2927
2928     // $ANTLR end "abstractDeclaratorList"
2929
2930     public static class storageClassSpecifier_return extends
2931             ParserRuleReturnScope {
2932         CommonTree tree;
2933
2934         @Override
2935         public Object getTree() {
2936             return tree;
2937         }
2938     }
2939
2940     // $ANTLR start "storageClassSpecifier"
2941     // Grammar/CTFParser.g:380:1: storageClassSpecifier : TYPEDEFTOK ;
2942     public final CTFParser.storageClassSpecifier_return storageClassSpecifier()
2943             throws RecognitionException {
2944         CTFParser.storageClassSpecifier_return retval = new CTFParser.storageClassSpecifier_return();
2945         retval.start = input.LT(1);
2946
2947         CommonTree root_0 = null;
2948
2949         Token TYPEDEFTOK41 = null;
2950
2951         CommonTree TYPEDEFTOK41_tree = null;
2952
2953         try {
2954             // Grammar/CTFParser.g:380:23: ( TYPEDEFTOK )
2955             // Grammar/CTFParser.g:381:3: TYPEDEFTOK
2956             {
2957                 root_0 = (CommonTree) adaptor.nil();
2958
2959                 TYPEDEFTOK41 = (Token) match(input, TYPEDEFTOK,
2960                         FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1014);
2961                 if (state.failed) {
2962                     return retval;
2963                 }
2964                 if (state.backtracking == 0) {
2965                     TYPEDEFTOK41_tree = (CommonTree) adaptor
2966                             .create(TYPEDEFTOK41);
2967                     adaptor.addChild(root_0, TYPEDEFTOK41_tree);
2968                 }
2969                 if (state.backtracking == 0) {
2970                     typedefOn();
2971                 }
2972
2973             }
2974
2975             retval.stop = input.LT(-1);
2976
2977             if (state.backtracking == 0) {
2978
2979                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
2980                 adaptor.setTokenBoundaries(retval.tree, retval.start,
2981                         retval.stop);
2982             }
2983         }
2984
2985         catch (RecognitionException e) {
2986             throw e;
2987
2988         }
2989         return retval;
2990     }
2991
2992     // $ANTLR end "storageClassSpecifier"
2993
2994     public static class typeSpecifier_return extends ParserRuleReturnScope {
2995         CommonTree tree;
2996
2997         @Override
2998         public Object getTree() {
2999             return tree;
3000         }
3001     }
3002
3003     // $ANTLR start "typeSpecifier"
3004     // Grammar/CTFParser.g:384:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK
3005     // | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK |
3006     // BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier
3007     // | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName );
3008     public final CTFParser.typeSpecifier_return typeSpecifier()
3009             throws RecognitionException {
3010         CTFParser.typeSpecifier_return retval = new CTFParser.typeSpecifier_return();
3011         retval.start = input.LT(1);
3012
3013         CommonTree root_0 = null;
3014
3015         Token FLOATTOK42 = null;
3016         Token INTTOK43 = null;
3017         Token LONGTOK44 = null;
3018         Token SHORTTOK45 = null;
3019         Token SIGNEDTOK46 = null;
3020         Token UNSIGNEDTOK47 = null;
3021         Token CHARTOK48 = null;
3022         Token DOUBLETOK49 = null;
3023         Token VOIDTOK50 = null;
3024         Token BOOLTOK51 = null;
3025         Token COMPLEXTOK52 = null;
3026         Token IMAGINARYTOK53 = null;
3027         CTFParser.structSpecifier_return structSpecifier54 = null;
3028
3029         CTFParser.variantSpecifier_return variantSpecifier55 = null;
3030
3031         CTFParser.enumSpecifier_return enumSpecifier56 = null;
3032
3033         CTFParser.ctfTypeSpecifier_return ctfTypeSpecifier57 = null;
3034
3035         CTFParser.typedefName_return typedefName58 = null;
3036
3037         CommonTree FLOATTOK42_tree = null;
3038         CommonTree INTTOK43_tree = null;
3039         CommonTree LONGTOK44_tree = null;
3040         CommonTree SHORTTOK45_tree = null;
3041         CommonTree SIGNEDTOK46_tree = null;
3042         CommonTree UNSIGNEDTOK47_tree = null;
3043         CommonTree CHARTOK48_tree = null;
3044         CommonTree DOUBLETOK49_tree = null;
3045         CommonTree VOIDTOK50_tree = null;
3046         CommonTree BOOLTOK51_tree = null;
3047         CommonTree COMPLEXTOK52_tree = null;
3048         CommonTree IMAGINARYTOK53_tree = null;
3049
3050         enter("typeSpecifier");
3051
3052         try {
3053             // Grammar/CTFParser.g:392:1: ( FLOATTOK | INTTOK | LONGTOK |
3054             // SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK |
3055             // VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier |
3056             // variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? =>
3057             // typedefName )
3058             int alt17 = 17;
3059             alt17 = dfa17.predict(input);
3060             switch (alt17) {
3061             case 1:
3062             // Grammar/CTFParser.g:393:3: FLOATTOK
3063             {
3064                 root_0 = (CommonTree) adaptor.nil();
3065
3066                 FLOATTOK42 = (Token) match(input, FLOATTOK,
3067                         FOLLOW_FLOATTOK_in_typeSpecifier1040);
3068                 if (state.failed) {
3069                     return retval;
3070                 }
3071                 if (state.backtracking == 0) {
3072                     FLOATTOK42_tree = (CommonTree) adaptor.create(FLOATTOK42);
3073                     adaptor.addChild(root_0, FLOATTOK42_tree);
3074                 }
3075
3076             }
3077                 break;
3078             case 2:
3079             // Grammar/CTFParser.g:394:5: INTTOK
3080             {
3081                 root_0 = (CommonTree) adaptor.nil();
3082
3083                 INTTOK43 = (Token) match(input, INTTOK,
3084                         FOLLOW_INTTOK_in_typeSpecifier1046);
3085                 if (state.failed) {
3086                     return retval;
3087                 }
3088                 if (state.backtracking == 0) {
3089                     INTTOK43_tree = (CommonTree) adaptor.create(INTTOK43);
3090                     adaptor.addChild(root_0, INTTOK43_tree);
3091                 }
3092
3093             }
3094                 break;
3095             case 3:
3096             // Grammar/CTFParser.g:395:5: LONGTOK
3097             {
3098                 root_0 = (CommonTree) adaptor.nil();
3099
3100                 LONGTOK44 = (Token) match(input, LONGTOK,
3101                         FOLLOW_LONGTOK_in_typeSpecifier1052);
3102                 if (state.failed) {
3103                     return retval;
3104                 }
3105                 if (state.backtracking == 0) {
3106                     LONGTOK44_tree = (CommonTree) adaptor.create(LONGTOK44);
3107                     adaptor.addChild(root_0, LONGTOK44_tree);
3108                 }
3109
3110             }
3111                 break;
3112             case 4:
3113             // Grammar/CTFParser.g:396:5: SHORTTOK
3114             {
3115                 root_0 = (CommonTree) adaptor.nil();
3116
3117                 SHORTTOK45 = (Token) match(input, SHORTTOK,
3118                         FOLLOW_SHORTTOK_in_typeSpecifier1058);
3119                 if (state.failed) {
3120                     return retval;
3121                 }
3122                 if (state.backtracking == 0) {
3123                     SHORTTOK45_tree = (CommonTree) adaptor.create(SHORTTOK45);
3124                     adaptor.addChild(root_0, SHORTTOK45_tree);
3125                 }
3126
3127             }
3128                 break;
3129             case 5:
3130             // Grammar/CTFParser.g:397:5: SIGNEDTOK
3131             {
3132                 root_0 = (CommonTree) adaptor.nil();
3133
3134                 SIGNEDTOK46 = (Token) match(input, SIGNEDTOK,
3135                         FOLLOW_SIGNEDTOK_in_typeSpecifier1064);
3136                 if (state.failed) {
3137                     return retval;
3138                 }
3139                 if (state.backtracking == 0) {
3140                     SIGNEDTOK46_tree = (CommonTree) adaptor.create(SIGNEDTOK46);
3141                     adaptor.addChild(root_0, SIGNEDTOK46_tree);
3142                 }
3143
3144             }
3145                 break;
3146             case 6:
3147             // Grammar/CTFParser.g:398:5: UNSIGNEDTOK
3148             {
3149                 root_0 = (CommonTree) adaptor.nil();
3150
3151                 UNSIGNEDTOK47 = (Token) match(input, UNSIGNEDTOK,
3152                         FOLLOW_UNSIGNEDTOK_in_typeSpecifier1070);
3153                 if (state.failed) {
3154                     return retval;
3155                 }
3156                 if (state.backtracking == 0) {
3157                     UNSIGNEDTOK47_tree = (CommonTree) adaptor
3158                             .create(UNSIGNEDTOK47);
3159                     adaptor.addChild(root_0, UNSIGNEDTOK47_tree);
3160                 }
3161
3162             }
3163                 break;
3164             case 7:
3165             // Grammar/CTFParser.g:399:5: CHARTOK
3166             {
3167                 root_0 = (CommonTree) adaptor.nil();
3168
3169                 CHARTOK48 = (Token) match(input, CHARTOK,
3170                         FOLLOW_CHARTOK_in_typeSpecifier1076);
3171                 if (state.failed) {
3172                     return retval;
3173                 }
3174                 if (state.backtracking == 0) {
3175                     CHARTOK48_tree = (CommonTree) adaptor.create(CHARTOK48);
3176                     adaptor.addChild(root_0, CHARTOK48_tree);
3177                 }
3178
3179             }
3180                 break;
3181             case 8:
3182             // Grammar/CTFParser.g:400:5: DOUBLETOK
3183             {
3184                 root_0 = (CommonTree) adaptor.nil();
3185
3186                 DOUBLETOK49 = (Token) match(input, DOUBLETOK,
3187                         FOLLOW_DOUBLETOK_in_typeSpecifier1082);
3188                 if (state.failed) {
3189                     return retval;
3190                 }
3191                 if (state.backtracking == 0) {
3192                     DOUBLETOK49_tree = (CommonTree) adaptor.create(DOUBLETOK49);
3193                     adaptor.addChild(root_0, DOUBLETOK49_tree);
3194                 }
3195
3196             }
3197                 break;
3198             case 9:
3199             // Grammar/CTFParser.g:401:5: VOIDTOK
3200             {
3201                 root_0 = (CommonTree) adaptor.nil();
3202
3203                 VOIDTOK50 = (Token) match(input, VOIDTOK,
3204                         FOLLOW_VOIDTOK_in_typeSpecifier1088);
3205                 if (state.failed) {
3206                     return retval;
3207                 }
3208                 if (state.backtracking == 0) {
3209                     VOIDTOK50_tree = (CommonTree) adaptor.create(VOIDTOK50);
3210                     adaptor.addChild(root_0, VOIDTOK50_tree);
3211                 }
3212
3213             }
3214                 break;
3215             case 10:
3216             // Grammar/CTFParser.g:402:5: BOOLTOK
3217             {
3218                 root_0 = (CommonTree) adaptor.nil();
3219
3220                 BOOLTOK51 = (Token) match(input, BOOLTOK,
3221                         FOLLOW_BOOLTOK_in_typeSpecifier1094);
3222                 if (state.failed) {
3223                     return retval;
3224                 }
3225                 if (state.backtracking == 0) {
3226                     BOOLTOK51_tree = (CommonTree) adaptor.create(BOOLTOK51);
3227                     adaptor.addChild(root_0, BOOLTOK51_tree);
3228                 }
3229
3230             }
3231                 break;
3232             case 11:
3233             // Grammar/CTFParser.g:403:5: COMPLEXTOK
3234             {
3235                 root_0 = (CommonTree) adaptor.nil();
3236
3237                 COMPLEXTOK52 = (Token) match(input, COMPLEXTOK,
3238                         FOLLOW_COMPLEXTOK_in_typeSpecifier1100);
3239                 if (state.failed) {
3240                     return retval;
3241                 }
3242                 if (state.backtracking == 0) {
3243                     COMPLEXTOK52_tree = (CommonTree) adaptor
3244                             .create(COMPLEXTOK52);
3245                     adaptor.addChild(root_0, COMPLEXTOK52_tree);
3246                 }
3247
3248             }
3249                 break;
3250             case 12:
3251             // Grammar/CTFParser.g:404:5: IMAGINARYTOK
3252             {
3253                 root_0 = (CommonTree) adaptor.nil();
3254
3255                 IMAGINARYTOK53 = (Token) match(input, IMAGINARYTOK,
3256                         FOLLOW_IMAGINARYTOK_in_typeSpecifier1106);
3257                 if (state.failed) {
3258                     return retval;
3259                 }
3260                 if (state.backtracking == 0) {
3261                     IMAGINARYTOK53_tree = (CommonTree) adaptor
3262                             .create(IMAGINARYTOK53);
3263                     adaptor.addChild(root_0, IMAGINARYTOK53_tree);
3264                 }
3265
3266             }
3267                 break;
3268             case 13:
3269             // Grammar/CTFParser.g:405:5: structSpecifier
3270             {
3271                 root_0 = (CommonTree) adaptor.nil();
3272
3273                 pushFollow(FOLLOW_structSpecifier_in_typeSpecifier1112);
3274                 structSpecifier54 = structSpecifier();
3275
3276                 state._fsp--;
3277                 if (state.failed) {
3278                     return retval;
3279                 }
3280                 if (state.backtracking == 0) {
3281                     adaptor.addChild(root_0, structSpecifier54.getTree());
3282                 }
3283
3284             }
3285                 break;
3286             case 14:
3287             // Grammar/CTFParser.g:406:5: variantSpecifier
3288             {
3289                 root_0 = (CommonTree) adaptor.nil();
3290
3291                 pushFollow(FOLLOW_variantSpecifier_in_typeSpecifier1118);
3292                 variantSpecifier55 = variantSpecifier();
3293
3294                 state._fsp--;
3295                 if (state.failed) {
3296                     return retval;
3297                 }
3298                 if (state.backtracking == 0) {
3299                     adaptor.addChild(root_0, variantSpecifier55.getTree());
3300                 }
3301
3302             }
3303                 break;
3304             case 15:
3305             // Grammar/CTFParser.g:407:5: enumSpecifier
3306             {
3307                 root_0 = (CommonTree) adaptor.nil();
3308
3309                 pushFollow(FOLLOW_enumSpecifier_in_typeSpecifier1124);
3310                 enumSpecifier56 = enumSpecifier();
3311
3312                 state._fsp--;
3313                 if (state.failed) {
3314                     return retval;
3315                 }
3316                 if (state.backtracking == 0) {
3317                     adaptor.addChild(root_0, enumSpecifier56.getTree());
3318                 }
3319
3320             }
3321                 break;
3322             case 16:
3323             // Grammar/CTFParser.g:408:5: ctfTypeSpecifier
3324             {
3325                 root_0 = (CommonTree) adaptor.nil();
3326
3327                 pushFollow(FOLLOW_ctfTypeSpecifier_in_typeSpecifier1130);
3328                 ctfTypeSpecifier57 = ctfTypeSpecifier();
3329
3330                 state._fsp--;
3331                 if (state.failed) {
3332                     return retval;
3333                 }
3334                 if (state.backtracking == 0) {
3335                     adaptor.addChild(root_0, ctfTypeSpecifier57.getTree());
3336                 }
3337
3338             }
3339                 break;
3340             case 17:
3341             // Grammar/CTFParser.g:409:5: {...}? => typedefName
3342             {
3343                 root_0 = (CommonTree) adaptor.nil();
3344
3345                 if (!((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
3346                     if (state.backtracking > 0) {
3347                         state.failed = true;
3348                         return retval;
3349                     }
3350                     throw new FailedPredicateException(input, "typeSpecifier",
3351                             "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
3352                 }
3353                 pushFollow(FOLLOW_typedefName_in_typeSpecifier1140);
3354                 typedefName58 = typedefName();
3355
3356                 state._fsp--;
3357                 if (state.failed) {
3358                     return retval;
3359                 }
3360                 if (state.backtracking == 0) {
3361                     adaptor.addChild(root_0, typedefName58.getTree());
3362                 }
3363
3364             }
3365                 break;
3366
3367             }
3368             retval.stop = input.LT(-1);
3369
3370             if (state.backtracking == 0) {
3371
3372                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
3373                 adaptor.setTokenBoundaries(retval.tree, retval.start,
3374                         retval.stop);
3375             }
3376             if (state.backtracking == 0) {
3377
3378                 debug_print(input.toString(retval.start, input.LT(-1)));
3379                 exit("typeSpecifier");
3380
3381             }
3382         }
3383
3384         catch (RecognitionException e) {
3385             throw e;
3386
3387         }
3388         return retval;
3389     }
3390
3391     // $ANTLR end "typeSpecifier"
3392
3393     public static class typeQualifier_return extends ParserRuleReturnScope {
3394         CommonTree tree;
3395
3396         @Override
3397         public Object getTree() {
3398             return tree;
3399         }
3400     }
3401
3402     // $ANTLR start "typeQualifier"
3403     // Grammar/CTFParser.g:412:1: typeQualifier : CONSTTOK ;
3404     public final CTFParser.typeQualifier_return typeQualifier()
3405             throws RecognitionException {
3406         CTFParser.typeQualifier_return retval = new CTFParser.typeQualifier_return();
3407         retval.start = input.LT(1);
3408
3409         CommonTree root_0 = null;
3410
3411         Token CONSTTOK59 = null;
3412
3413         CommonTree CONSTTOK59_tree = null;
3414
3415         enter("typeQualifier");
3416
3417         try {
3418             // Grammar/CTFParser.g:420:1: ( CONSTTOK )
3419             // Grammar/CTFParser.g:421:3: CONSTTOK
3420             {
3421                 root_0 = (CommonTree) adaptor.nil();
3422
3423                 CONSTTOK59 = (Token) match(input, CONSTTOK,
3424                         FOLLOW_CONSTTOK_in_typeQualifier1163);
3425                 if (state.failed) {
3426                     return retval;
3427                 }
3428                 if (state.backtracking == 0) {
3429                     CONSTTOK59_tree = (CommonTree) adaptor.create(CONSTTOK59);
3430                     adaptor.addChild(root_0, CONSTTOK59_tree);
3431                 }
3432
3433             }
3434
3435             retval.stop = input.LT(-1);
3436
3437             if (state.backtracking == 0) {
3438
3439                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
3440                 adaptor.setTokenBoundaries(retval.tree, retval.start,
3441                         retval.stop);
3442             }
3443             if (state.backtracking == 0) {
3444
3445                 debug_print(input.toString(retval.start, input.LT(-1)));
3446                 exit("typeQualifier");
3447
3448             }
3449         }
3450
3451         catch (RecognitionException e) {
3452             throw e;
3453         }
3454
3455         return retval;
3456     }
3457
3458     // $ANTLR end "typeQualifier"
3459
3460     public static class alignAttribute_return extends ParserRuleReturnScope {
3461         CommonTree tree;
3462
3463         @Override
3464         public Object getTree() {
3465             return tree;
3466         }
3467     }
3468
3469     // $ANTLR start "alignAttribute"
3470     // Grammar/CTFParser.g:424:1: alignAttribute : ALIGNTOK LPAREN
3471     // unaryExpression RPAREN -> ^( ALIGN unaryExpression ) ;
3472     public final CTFParser.alignAttribute_return alignAttribute()
3473             throws RecognitionException {
3474         CTFParser.alignAttribute_return retval = new CTFParser.alignAttribute_return();
3475         retval.start = input.LT(1);
3476
3477         CommonTree root_0 = null;
3478
3479         Token ALIGNTOK60 = null;
3480         Token LPAREN61 = null;
3481         Token RPAREN63 = null;
3482         CTFParser.unaryExpression_return unaryExpression62 = null;
3483
3484         CommonTree ALIGNTOK60_tree = null;
3485         CommonTree LPAREN61_tree = null;
3486         CommonTree RPAREN63_tree = null;
3487         RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(
3488                 adaptor, "token RPAREN");
3489         RewriteRuleTokenStream stream_ALIGNTOK = new RewriteRuleTokenStream(
3490                 adaptor, "token ALIGNTOK");
3491         RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(
3492                 adaptor, "token LPAREN");
3493         RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(
3494                 adaptor, "rule unaryExpression");
3495         try {
3496             // Grammar/CTFParser.g:424:16: ( ALIGNTOK LPAREN unaryExpression
3497             // RPAREN -> ^( ALIGN unaryExpression ) )
3498             // Grammar/CTFParser.g:425:3: ALIGNTOK LPAREN unaryExpression RPAREN
3499             {
3500                 ALIGNTOK60 = (Token) match(input, ALIGNTOK,
3501                         FOLLOW_ALIGNTOK_in_alignAttribute1176);
3502                 if (state.failed) {
3503                     return retval;
3504                 }
3505                 if (state.backtracking == 0) {
3506                     stream_ALIGNTOK.add(ALIGNTOK60);
3507                 }
3508
3509                 LPAREN61 = (Token) match(input, LPAREN,
3510                         FOLLOW_LPAREN_in_alignAttribute1178);
3511                 if (state.failed) {
3512                     return retval;
3513                 }
3514                 if (state.backtracking == 0) {
3515                     stream_LPAREN.add(LPAREN61);
3516                 }
3517
3518                 pushFollow(FOLLOW_unaryExpression_in_alignAttribute1180);
3519                 unaryExpression62 = unaryExpression();
3520
3521                 state._fsp--;
3522                 if (state.failed) {
3523                     return retval;
3524                 }
3525                 if (state.backtracking == 0) {
3526                     stream_unaryExpression.add(unaryExpression62.getTree());
3527                 }
3528                 RPAREN63 = (Token) match(input, RPAREN,
3529                         FOLLOW_RPAREN_in_alignAttribute1182);
3530                 if (state.failed) {
3531                     return retval;
3532                 }
3533                 if (state.backtracking == 0) {
3534                     stream_RPAREN.add(RPAREN63);
3535                 }
3536
3537                 // AST REWRITE
3538                 // elements: unaryExpression
3539                 // token labels:
3540                 // rule labels: retval
3541                 // token list labels:
3542                 // rule list labels:
3543                 // wildcard labels:
3544                 if (state.backtracking == 0) {
3545                     retval.tree = root_0;
3546 //                    RewriteRuleSubtreeStream stream_retval =
3547                             new RewriteRuleSubtreeStream(
3548                             adaptor, "rule retval",
3549                             retval != null ? retval.tree : null);
3550
3551                     root_0 = (CommonTree) adaptor.nil();
3552                     // 425:42: -> ^( ALIGN unaryExpression )
3553                     {
3554                         // Grammar/CTFParser.g:425:45: ^( ALIGN unaryExpression
3555                         // )
3556                         {
3557                             CommonTree root_1 = (CommonTree) adaptor.nil();
3558                             root_1 = (CommonTree) adaptor.becomeRoot(
3559                                     adaptor.create(ALIGN, "ALIGN"), root_1);
3560
3561                             adaptor.addChild(root_1,
3562                                     stream_unaryExpression.nextTree());
3563
3564                             adaptor.addChild(root_0, root_1);
3565                         }
3566
3567                     }
3568
3569                     retval.tree = root_0;
3570                 }
3571             }
3572
3573             retval.stop = input.LT(-1);
3574
3575             if (state.backtracking == 0) {
3576
3577                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
3578                 adaptor.setTokenBoundaries(retval.tree, retval.start,
3579                         retval.stop);
3580             }
3581         }
3582
3583         catch (RecognitionException e) {
3584             throw e;
3585         }
3586
3587         return retval;
3588     }
3589
3590     // $ANTLR end "alignAttribute"
3591
3592     public static class structBody_return extends ParserRuleReturnScope {
3593         CommonTree tree;
3594
3595         @Override
3596         public Object getTree() {
3597             return tree;
3598         }
3599     }
3600
3601     // $ANTLR start "structBody"
3602     // Grammar/CTFParser.g:429:1: structBody : LCURL (
3603     // structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY (
3604     // structOrVariantDeclarationList )? ) ;
3605     public final CTFParser.structBody_return structBody()
3606             throws RecognitionException {
3607         Symbols_stack.push(new Symbols_scope());
3608
3609         CTFParser.structBody_return retval = new CTFParser.structBody_return();
3610         retval.start = input.LT(1);
3611
3612         CommonTree root_0 = null;
3613
3614         Token LCURL64 = null;
3615         Token RCURL66 = null;
3616         CTFParser.structOrVariantDeclarationList_return structOrVariantDeclarationList65 = null;
3617
3618         CommonTree LCURL64_tree = null;
3619         CommonTree RCURL66_tree = null;
3620         RewriteRuleTokenStream stream_LCURL = new RewriteRuleTokenStream(
3621                 adaptor, "token LCURL");
3622         RewriteRuleTokenStream stream_RCURL = new RewriteRuleTokenStream(
3623                 adaptor, "token RCURL");
3624         RewriteRuleSubtreeStream stream_structOrVariantDeclarationList = new RewriteRuleSubtreeStream(
3625                 adaptor, "rule structOrVariantDeclarationList");
3626
3627         enter("structBody");
3628         debug_print("Scope push " + Symbols_stack.size());
3629         ((Symbols_scope) Symbols_stack.peek()).types = new HashSet<String>();
3630
3631         try {
3632             // Grammar/CTFParser.g:440:1: ( LCURL (
3633             // structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY (
3634             // structOrVariantDeclarationList )? ) )
3635             // Grammar/CTFParser.g:441:3: LCURL ( structOrVariantDeclarationList
3636             // )? RCURL
3637             {
3638                 LCURL64 = (Token) match(input, LCURL,
3639                         FOLLOW_LCURL_in_structBody1223);
3640                 if (state.failed) {
3641                     return retval;
3642                 }
3643                 if (state.backtracking == 0) {
3644                     stream_LCURL.add(LCURL64);
3645                 }
3646
3647                 // Grammar/CTFParser.g:441:9: ( structOrVariantDeclarationList
3648                 // )?
3649                 int alt18 = 2;
3650                 int LA18_0 = input.LA(1);
3651
3652                 if ((((LA18_0 >= CONSTTOK) && (LA18_0 <= ENUMTOK))
3653                         || ((LA18_0 >= FLOATINGPOINTTOK) && (LA18_0 <= SIGNEDTOK))
3654                         || ((LA18_0 >= STRINGTOK) && (LA18_0 <= STRUCTTOK)) || ((LA18_0 >= TYPEDEFTOK) && (LA18_0 <= IMAGINARYTOK)))) {
3655                     alt18 = 1;
3656                 } else if ((LA18_0 == IDENTIFIER)
3657                         && ((inTypealiasAlias() || isTypeName(input.LT(1)
3658                                 .getText())))) {
3659                     alt18 = 1;
3660                 } else if ((LA18_0 == TYPEALIASTOK)) {
3661                     alt18 = 1;
3662                 }
3663                 switch (alt18) {
3664                 case 1:
3665                 // Grammar/CTFParser.g:441:9: structOrVariantDeclarationList
3666                 {
3667                     pushFollow(FOLLOW_structOrVariantDeclarationList_in_structBody1225);
3668                     structOrVariantDeclarationList65 = structOrVariantDeclarationList();
3669
3670                     state._fsp--;
3671                     if (state.failed) {
3672                         return retval;
3673                     }
3674                     if (state.backtracking == 0) {
3675                         stream_structOrVariantDeclarationList
3676                                 .add(structOrVariantDeclarationList65.getTree());
3677                     }
3678
3679                 }
3680                     break;
3681
3682                 }
3683
3684                 RCURL66 = (Token) match(input, RCURL,
3685                         FOLLOW_RCURL_in_structBody1228);
3686                 if (state.failed) {
3687                     return retval;
3688                 }
3689                 if (state.backtracking == 0) {
3690                     stream_RCURL.add(RCURL66);
3691                 }
3692
3693                 // AST REWRITE
3694                 // elements: structOrVariantDeclarationList
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 =
3703                             new RewriteRuleSubtreeStream(
3704                             adaptor, "rule retval",
3705                             retval != null ? retval.tree : null);
3706
3707                     root_0 = (CommonTree) adaptor.nil();
3708                     // 441:47: -> ^( STRUCT_BODY (
3709                     // structOrVariantDeclarationList )? )
3710                     {
3711                         // Grammar/CTFParser.g:441:50: ^( STRUCT_BODY (
3712                         // structOrVariantDeclarationList )? )
3713                         {
3714                             CommonTree root_1 = (CommonTree) adaptor.nil();
3715                             root_1 = (CommonTree) adaptor.becomeRoot(
3716                                     adaptor.create(STRUCT_BODY, "STRUCT_BODY"),
3717                                     root_1);
3718
3719                             // Grammar/CTFParser.g:441:64: (
3720                             // structOrVariantDeclarationList )?
3721                             if (stream_structOrVariantDeclarationList.hasNext()) {
3722                                 adaptor.addChild(root_1,
3723                                         stream_structOrVariantDeclarationList
3724                                                 .nextTree());
3725
3726                             }
3727                             stream_structOrVariantDeclarationList.reset();
3728
3729                             adaptor.addChild(root_0, root_1);
3730                         }
3731
3732                     }
3733
3734                     retval.tree = root_0;
3735                 }
3736             }
3737
3738             retval.stop = input.LT(-1);
3739
3740             if (state.backtracking == 0) {
3741
3742                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
3743                 adaptor.setTokenBoundaries(retval.tree, retval.start,
3744                         retval.stop);
3745             }
3746             if (state.backtracking == 0) {
3747
3748                 debug_print("Scope pop " + Symbols_stack.size());
3749                 exit("structBody");
3750
3751             }
3752         }
3753
3754         catch (RecognitionException e) {
3755             throw e;
3756         } finally {
3757             Symbols_stack.pop();
3758
3759         }
3760         return retval;
3761     }
3762
3763     // $ANTLR end "structBody"
3764
3765     public static class structSpecifier_return extends ParserRuleReturnScope {
3766         CommonTree tree;
3767
3768         @Override
3769         public Object getTree() {
3770             return tree;
3771         }
3772     }
3773
3774     // $ANTLR start "structSpecifier"
3775     // Grammar/CTFParser.g:446:1: structSpecifier : STRUCTTOK ( ( structName (
3776     // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | ( structBody
3777     // ( alignAttribute | ) ) ) -> ^( STRUCT ( structName )? ( structBody )? (
3778     // alignAttribute )? ) ;
3779     public final CTFParser.structSpecifier_return structSpecifier()
3780             throws RecognitionException {
3781         CTFParser.structSpecifier_return retval = new CTFParser.structSpecifier_return();
3782         retval.start = input.LT(1);
3783
3784         CommonTree root_0 = null;
3785
3786         Token STRUCTTOK67 = null;
3787         CTFParser.structName_return structName68 = null;
3788
3789         CTFParser.alignAttribute_return alignAttribute69 = null;
3790
3791         CTFParser.structBody_return structBody70 = null;
3792
3793         CTFParser.alignAttribute_return alignAttribute71 = null;
3794
3795         CTFParser.structBody_return structBody72 = null;
3796
3797         CTFParser.alignAttribute_return alignAttribute73 = null;
3798
3799         CommonTree STRUCTTOK67_tree = null;
3800         RewriteRuleTokenStream stream_STRUCTTOK = new RewriteRuleTokenStream(
3801                 adaptor, "token STRUCTTOK");
3802         RewriteRuleSubtreeStream stream_structName = new RewriteRuleSubtreeStream(
3803                 adaptor, "rule structName");
3804         RewriteRuleSubtreeStream stream_structBody = new RewriteRuleSubtreeStream(
3805                 adaptor, "rule structBody");
3806         RewriteRuleSubtreeStream stream_alignAttribute = new RewriteRuleSubtreeStream(
3807                 adaptor, "rule alignAttribute");
3808
3809         enter("structSpecifier");
3810
3811         try {
3812             // Grammar/CTFParser.g:453:1: ( STRUCTTOK ( ( structName (
3813             // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | (
3814             // structBody ( alignAttribute | ) ) ) -> ^( STRUCT ( structName )?
3815             // ( structBody )? ( alignAttribute )? ) )
3816             // Grammar/CTFParser.g:454:3: STRUCTTOK ( ( structName (
3817             // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | (
3818             // structBody ( alignAttribute | ) ) )
3819             {
3820                 STRUCTTOK67 = (Token) match(input, STRUCTTOK,
3821                         FOLLOW_STRUCTTOK_in_structSpecifier1266);
3822                 if (state.failed) {
3823                     return retval;
3824                 }
3825                 if (state.backtracking == 0) {
3826                     stream_STRUCTTOK.add(STRUCTTOK67);
3827                 }
3828
3829                 // Grammar/CTFParser.g:455:3: ( ( structName ( alignAttribute |
3830                 // ( structBody ( alignAttribute | ) ) | ) ) | ( structBody (
3831                 // alignAttribute | ) ) )
3832                 int alt22 = 2;
3833                 int LA22_0 = input.LA(1);
3834
3835                 if ((LA22_0 == IDENTIFIER)) {
3836                     alt22 = 1;
3837                 } else if ((LA22_0 == LCURL)) {
3838                     alt22 = 2;
3839                 } else {
3840                     if (state.backtracking > 0) {
3841                         state.failed = true;
3842                         return retval;
3843                     }
3844                     NoViableAltException nvae = new NoViableAltException("",
3845                             22, 0, input);
3846
3847                     throw nvae;
3848                 }
3849                 switch (alt22) {
3850                 case 1:
3851                 // Grammar/CTFParser.g:457:5: ( structName ( alignAttribute | (
3852                 // structBody ( alignAttribute | ) ) | ) )
3853                 {
3854                     // Grammar/CTFParser.g:457:5: ( structName ( alignAttribute
3855                     // | ( structBody ( alignAttribute | ) ) | ) )
3856                     // Grammar/CTFParser.g:458:6: structName ( alignAttribute |
3857                     // ( structBody ( alignAttribute | ) ) | )
3858                     {
3859                         pushFollow(FOLLOW_structName_in_structSpecifier1288);
3860                         structName68 = structName();
3861
3862                         state._fsp--;
3863                         if (state.failed) {
3864                             return retval;
3865                         }
3866                         if (state.backtracking == 0) {
3867                             stream_structName.add(structName68.getTree());
3868                         }
3869                         // Grammar/CTFParser.g:459:6: ( alignAttribute | (
3870                         // structBody ( alignAttribute | ) ) | )
3871                         int alt20 = 3;
3872                         switch (input.LA(1)) {
3873                         case ALIGNTOK: {
3874                             alt20 = 1;
3875                         }
3876                             break;
3877                         case LCURL: {
3878                             switch (input.LA(2)) {
3879                             case CONSTTOK:
3880                             case CHARTOK:
3881                             case DOUBLETOK:
3882                             case ENUMTOK:
3883                             case FLOATINGPOINTTOK:
3884                             case FLOATTOK:
3885                             case INTEGERTOK:
3886                             case INTTOK:
3887                             case LONGTOK:
3888                             case SHORTTOK:
3889                             case STRUCTTOK:
3890                             case TYPEALIASTOK:
3891                             case TYPEDEFTOK:
3892                             case UNSIGNEDTOK:
3893                             case VARIANTTOK:
3894                             case VOIDTOK:
3895                             case BOOLTOK:
3896                             case COMPLEXTOK:
3897                             case IMAGINARYTOK:
3898                             case RCURL: {
3899                                 alt20 = 2;
3900                             }
3901                                 break;
3902                             case SIGNEDTOK: {
3903                                 int LA20_5 = input.LA(3);
3904
3905                                 if ((((LA20_5 >= CONSTTOK) && (LA20_5 <= ENUMTOK))
3906                                         || ((LA20_5 >= FLOATINGPOINTTOK) && (LA20_5 <= SIGNEDTOK))
3907                                         || ((LA20_5 >= STRINGTOK) && (LA20_5 <= STRUCTTOK))
3908                                         || ((LA20_5 >= TYPEDEFTOK) && (LA20_5 <= IMAGINARYTOK))
3909                                         || (LA20_5 == POINTER) || (LA20_5 == IDENTIFIER))) {
3910                                     alt20 = 2;
3911                                 } else if (((LA20_5 == SEPARATOR)
3912                                         || (LA20_5 == ASSIGNMENT) || (LA20_5 == RCURL))) {
3913                                     alt20 = 3;
3914                                 } else {
3915                                     if (state.backtracking > 0) {
3916                                         state.failed = true;
3917                                         return retval;
3918                                     }
3919                                     NoViableAltException nvae = new NoViableAltException(
3920                                             "", 20, 5, input);
3921
3922                                     throw nvae;
3923                                 }
3924                             }
3925                                 break;
3926                             case STRINGTOK: {
3927                                 int LA20_6 = input.LA(3);
3928
3929                                 if ((((LA20_6 >= CONSTTOK) && (LA20_6 <= ENUMTOK))
3930                                         || ((LA20_6 >= FLOATINGPOINTTOK) && (LA20_6 <= SIGNEDTOK))
3931                                         || ((LA20_6 >= STRINGTOK) && (LA20_6 <= STRUCTTOK))
3932                                         || ((LA20_6 >= TYPEDEFTOK) && (LA20_6 <= IMAGINARYTOK))
3933                                         || (LA20_6 == LCURL)
3934                                         || (LA20_6 == POINTER) || (LA20_6 == IDENTIFIER))) {
3935                                     alt20 = 2;
3936                                 } else if (((LA20_6 == SEPARATOR)
3937                                         || (LA20_6 == ASSIGNMENT) || (LA20_6 == RCURL))) {
3938                                     alt20 = 3;
3939                                 } else {
3940                                     if (state.backtracking > 0) {
3941                                         state.failed = true;
3942                                         return retval;
3943                                     }
3944                                     NoViableAltException nvae = new NoViableAltException(
3945                                             "", 20, 6, input);
3946
3947                                     throw nvae;
3948                                 }
3949                             }
3950                                 break;
3951                             case IDENTIFIER: {
3952                                 int LA20_7 = input.LA(3);
3953
3954                                 if (((LA20_7 == SEPARATOR)
3955                                         || (LA20_7 == ASSIGNMENT) || (LA20_7 == RCURL))) {
3956                                     alt20 = 3;
3957                                 } else if ((((LA20_7 >= CONSTTOK) && (LA20_7 <= ENUMTOK))
3958                                         || ((LA20_7 >= FLOATINGPOINTTOK) && (LA20_7 <= SIGNEDTOK))
3959                                         || ((LA20_7 >= STRINGTOK) && (LA20_7 <= STRUCTTOK))
3960                                         || ((LA20_7 >= TYPEDEFTOK) && (LA20_7 <= IMAGINARYTOK))
3961                                         || (LA20_7 == POINTER) || (LA20_7 == IDENTIFIER))) {
3962                                     alt20 = 2;
3963                                 } else {
3964                                     if (state.backtracking > 0) {
3965                                         state.failed = true;
3966                                         return retval;
3967                                     }
3968                                     NoViableAltException nvae = new NoViableAltException(
3969                                             "", 20, 7, input);
3970
3971                                     throw nvae;
3972                                 }
3973                             }
3974                                 break;
3975                             case ALIGNTOK:
3976                             case EVENTTOK:
3977                             case STRING_LITERAL: {
3978                                 alt20 = 3;
3979                             }
3980                                 break;
3981                             default:
3982                                 if (state.backtracking > 0) {
3983                                     state.failed = true;
3984                                     return retval;
3985                                 }
3986                                 NoViableAltException nvae = new NoViableAltException(
3987                                         "", 20, 2, input);
3988
3989                                 throw nvae;
3990                             }
3991
3992                         }
3993                             break;
3994                         case EOF:
3995                         case CONSTTOK:
3996                         case CHARTOK:
3997                         case DOUBLETOK:
3998                         case ENUMTOK:
3999                         case FLOATINGPOINTTOK:
4000                         case FLOATTOK:
4001                         case INTEGERTOK:
4002                         case INTTOK:
4003                         case LONGTOK:
4004                         case SHORTTOK:
4005                         case SIGNEDTOK:
4006                         case STRINGTOK:
4007                         case STRUCTTOK:
4008                         case TYPEDEFTOK:
4009                         case UNSIGNEDTOK:
4010                         case VARIANTTOK:
4011                         case VOIDTOK:
4012                         case BOOLTOK:
4013                         case COMPLEXTOK:
4014                         case IMAGINARYTOK:
4015                         case TYPE_ASSIGNMENT:
4016                         case LPAREN:
4017                         case TERM:
4018                         case POINTER:
4019                         case IDENTIFIER: {
4020                             alt20 = 3;
4021                         }
4022                             break;
4023                         default:
4024                             if (state.backtracking > 0) {
4025                                 state.failed = true;
4026                                 return retval;
4027                             }
4028                             NoViableAltException nvae = new NoViableAltException(
4029                                     "", 20, 0, input);
4030
4031                             throw nvae;
4032                         }
4033
4034                         switch (alt20) {
4035                         case 1:
4036                         // Grammar/CTFParser.g:460:8: alignAttribute
4037                         {
4038                             pushFollow(FOLLOW_alignAttribute_in_structSpecifier1304);
4039                             alignAttribute69 = alignAttribute();
4040
4041                             state._fsp--;
4042                             if (state.failed) {
4043                                 return retval;
4044                             }
4045                             if (state.backtracking == 0) {
4046                                 stream_alignAttribute.add(alignAttribute69
4047                                         .getTree());
4048                             }
4049
4050                         }
4051                             break;
4052                         case 2:
4053                         // Grammar/CTFParser.g:462:8: ( structBody (
4054                         // alignAttribute | ) )
4055                         {
4056                             // Grammar/CTFParser.g:462:8: ( structBody (
4057                             // alignAttribute | ) )
4058                             // Grammar/CTFParser.g:463:10: structBody (
4059                             // alignAttribute | )
4060                             {
4061                                 pushFollow(FOLLOW_structBody_in_structSpecifier1333);
4062                                 structBody70 = structBody();
4063
4064                                 state._fsp--;
4065                                 if (state.failed) {
4066                                     return retval;
4067                                 }
4068                                 if (state.backtracking == 0) {
4069                                     stream_structBody.add(structBody70
4070                                             .getTree());
4071                                 }
4072                                 // Grammar/CTFParser.g:464:10: ( alignAttribute
4073                                 // | )
4074                                 int alt19 = 2;
4075                                 int LA19_0 = input.LA(1);
4076
4077                                 if ((LA19_0 == ALIGNTOK)) {
4078                                     alt19 = 1;
4079                                 } else if (((LA19_0 == EOF)
4080                                         || ((LA19_0 >= CONSTTOK) && (LA19_0 <= ENUMTOK))
4081                                         || ((LA19_0 >= FLOATINGPOINTTOK) && (LA19_0 <= SIGNEDTOK))
4082                                         || ((LA19_0 >= STRINGTOK) && (LA19_0 <= STRUCTTOK))
4083                                         || ((LA19_0 >= TYPEDEFTOK) && (LA19_0 <= IMAGINARYTOK))
4084                                         || (LA19_0 == TYPE_ASSIGNMENT)
4085                                         || (LA19_0 == LPAREN)
4086                                         || (LA19_0 == LCURL)
4087                                         || ((LA19_0 >= TERM) && (LA19_0 <= POINTER)) || (LA19_0 == IDENTIFIER))) {
4088                                     alt19 = 2;
4089                                 } else {
4090                                     if (state.backtracking > 0) {
4091                                         state.failed = true;
4092                                         return retval;
4093                                     }
4094                                     NoViableAltException nvae = new NoViableAltException(
4095                                             "", 19, 0, input);
4096
4097                                     throw nvae;
4098                                 }
4099                                 switch (alt19) {
4100                                 case 1:
4101                                 // Grammar/CTFParser.g:465:11: alignAttribute
4102                                 {
4103                                     pushFollow(FOLLOW_alignAttribute_in_structSpecifier1358);
4104                                     alignAttribute71 = alignAttribute();
4105
4106                                     state._fsp--;
4107                                     if (state.failed) {
4108                                         return retval;
4109                                     }
4110                                     if (state.backtracking == 0) {
4111                                         stream_alignAttribute
4112                                                 .add(alignAttribute71.getTree());
4113                                     }
4114
4115                                 }
4116                                     break;
4117                                 case 2:
4118                                 // Grammar/CTFParser.g:468:10:
4119                                     break;
4120
4121                                 }
4122
4123                             }
4124
4125                         }
4126                             break;
4127                         case 3:
4128                         // Grammar/CTFParser.g:472:6:
4129                             break;
4130
4131                         }
4132
4133                     }
4134
4135                 }
4136                     break;
4137                 case 2:
4138                 // Grammar/CTFParser.g:476:5: ( structBody ( alignAttribute | )
4139                 // )
4140                 {
4141                     // Grammar/CTFParser.g:476:5: ( structBody ( alignAttribute
4142                     // | ) )
4143                     // Grammar/CTFParser.g:477:7: structBody ( alignAttribute |
4144                     // )
4145                     {
4146                         pushFollow(FOLLOW_structBody_in_structSpecifier1456);
4147                         structBody72 = structBody();
4148
4149                         state._fsp--;
4150                         if (state.failed) {
4151                             return retval;
4152                         }
4153                         if (state.backtracking == 0) {
4154                             stream_structBody.add(structBody72.getTree());
4155                         }
4156                         // Grammar/CTFParser.g:478:7: ( alignAttribute | )
4157                         int alt21 = 2;
4158                         int LA21_0 = input.LA(1);
4159
4160                         if ((LA21_0 == ALIGNTOK)) {
4161                             alt21 = 1;
4162                         } else if (((LA21_0 == EOF)
4163                                 || ((LA21_0 >= CONSTTOK) && (LA21_0 <= ENUMTOK))
4164                                 || ((LA21_0 >= FLOATINGPOINTTOK) && (LA21_0 <= SIGNEDTOK))
4165                                 || ((LA21_0 >= STRINGTOK) && (LA21_0 <= STRUCTTOK))
4166                                 || ((LA21_0 >= TYPEDEFTOK) && (LA21_0 <= IMAGINARYTOK))
4167                                 || (LA21_0 == TYPE_ASSIGNMENT)
4168                                 || (LA21_0 == LPAREN) || (LA21_0 == LCURL)
4169                                 || ((LA21_0 >= TERM) && (LA21_0 <= POINTER)) || (LA21_0 == IDENTIFIER))) {
4170                             alt21 = 2;
4171                         } else {
4172                             if (state.backtracking > 0) {
4173                                 state.failed = true;
4174                                 return retval;
4175                             }
4176                             NoViableAltException nvae = new NoViableAltException(
4177                                     "", 21, 0, input);
4178
4179                             throw nvae;
4180                         }
4181                         switch (alt21) {
4182                         case 1:
4183                         // Grammar/CTFParser.g:479:9: alignAttribute
4184                         {
4185                             pushFollow(FOLLOW_alignAttribute_in_structSpecifier1474);
4186                             alignAttribute73 = alignAttribute();
4187
4188                             state._fsp--;
4189                             if (state.failed) {
4190                                 return retval;
4191                             }
4192                             if (state.backtracking == 0) {
4193                                 stream_alignAttribute.add(alignAttribute73
4194                                         .getTree());
4195                             }
4196
4197                         }
4198                             break;
4199                         case 2:
4200                             break;
4201
4202                         }
4203
4204                     }
4205
4206                 }
4207                     break;
4208
4209                 }
4210
4211                 // AST REWRITE
4212                 // elements: alignAttribute, structName, structBody
4213                 // token labels:
4214                 // rule labels: retval
4215                 // token list labels:
4216                 // rule list labels:
4217                 // wildcard labels:
4218                 if (state.backtracking == 0) {
4219                     retval.tree = root_0;
4220                     RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
4221                             adaptor, "rule retval",
4222                             retval != null ? retval.tree : null);
4223
4224                     root_0 = (CommonTree) adaptor.nil();
4225                     // 484:5: -> ^( STRUCT ( structName )? ( structBody )? (
4226                     // alignAttribute )? )
4227                     {
4228                         // Grammar/CTFParser.g:484:8: ^( STRUCT ( structName )?
4229                         // ( structBody )? ( alignAttribute )? )
4230                         {
4231                             CommonTree root_1 = (CommonTree) adaptor.nil();
4232                             root_1 = (CommonTree) adaptor.becomeRoot(
4233                                     adaptor.create(STRUCT, "STRUCT"), root_1);
4234
4235                             // Grammar/CTFParser.g:484:17: ( structName )?
4236                             if (stream_structName.hasNext()) {
4237                                 adaptor.addChild(root_1,
4238                                         stream_structName.nextTree());
4239
4240                             }
4241                             stream_structName.reset();
4242                             // Grammar/CTFParser.g:484:29: ( structBody )?
4243                             if (stream_structBody.hasNext()) {
4244                                 adaptor.addChild(root_1,
4245                                         stream_structBody.nextTree());
4246
4247                             }
4248                             stream_structBody.reset();
4249                             // Grammar/CTFParser.g:484:41: ( alignAttribute )?
4250                             if (stream_alignAttribute.hasNext()) {
4251                                 adaptor.addChild(root_1,
4252                                         stream_alignAttribute.nextTree());
4253
4254                             }
4255                             stream_alignAttribute.reset();
4256
4257                             adaptor.addChild(root_0, root_1);
4258                         }
4259
4260                     }
4261
4262                     retval.tree = root_0;
4263                 }
4264             }
4265
4266             retval.stop = input.LT(-1);
4267
4268             if (state.backtracking == 0) {
4269
4270                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
4271                 adaptor.setTokenBoundaries(retval.tree, retval.start,
4272                         retval.stop);
4273             }
4274             if (state.backtracking == 0) {
4275
4276                 exit("structSpecifier");
4277
4278             }
4279         }
4280
4281         catch (RecognitionException e) {
4282             throw e;
4283         }
4284         return retval;
4285     }
4286
4287     // $ANTLR end "structSpecifier"
4288
4289     public static class structName_return extends ParserRuleReturnScope {
4290         CommonTree tree;
4291
4292         @Override
4293         public Object getTree() {
4294             return tree;
4295         }
4296     }
4297
4298     // $ANTLR start "structName"
4299     // Grammar/CTFParser.g:487:1: structName : IDENTIFIER -> ^( STRUCT_NAME
4300     // IDENTIFIER ) ;
4301     public final CTFParser.structName_return structName()
4302             throws RecognitionException {
4303         CTFParser.structName_return retval = new CTFParser.structName_return();
4304         retval.start = input.LT(1);
4305
4306         CommonTree root_0 = null;
4307
4308         Token IDENTIFIER74 = null;
4309
4310         CommonTree IDENTIFIER74_tree = null;
4311         RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
4312                 adaptor, "token IDENTIFIER");
4313
4314         enter("structName");
4315
4316         try {
4317             // Grammar/CTFParser.g:495:1: ( IDENTIFIER -> ^( STRUCT_NAME
4318             // IDENTIFIER ) )
4319             // Grammar/CTFParser.g:496:3: IDENTIFIER
4320             {
4321                 IDENTIFIER74 = (Token) match(input, IDENTIFIER,
4322                         FOLLOW_IDENTIFIER_in_structName1550);
4323                 if (state.failed) {
4324                     return retval;
4325                 }
4326                 if (state.backtracking == 0) {
4327                     stream_IDENTIFIER.add(IDENTIFIER74);
4328                 }
4329
4330                 // AST REWRITE
4331                 // elements: IDENTIFIER
4332                 // token labels:
4333                 // rule labels: retval
4334                 // token list labels:
4335                 // rule list labels:
4336                 // wildcard labels:
4337                 if (state.backtracking == 0) {
4338                     retval.tree = root_0;
4339 //                    RewriteRuleSubtreeStream stream_retval =
4340                             new RewriteRuleSubtreeStream(
4341                             adaptor, "rule retval",
4342                             retval != null ? retval.tree : null);
4343
4344                     root_0 = (CommonTree) adaptor.nil();
4345                     // 496:14: -> ^( STRUCT_NAME IDENTIFIER )
4346                     {
4347                         // Grammar/CTFParser.g:496:17: ^( STRUCT_NAME IDENTIFIER
4348                         // )
4349                         {
4350                             CommonTree root_1 = (CommonTree) adaptor.nil();
4351                             root_1 = (CommonTree) adaptor.becomeRoot(
4352                                     adaptor.create(STRUCT_NAME, "STRUCT_NAME"),
4353                                     root_1);
4354
4355                             adaptor.addChild(root_1,
4356                                     stream_IDENTIFIER.nextNode());
4357
4358                             adaptor.addChild(root_0, root_1);
4359                         }
4360
4361                     }
4362
4363                     retval.tree = root_0;
4364                 }
4365             }
4366
4367             retval.stop = input.LT(-1);
4368
4369             if (state.backtracking == 0) {
4370
4371                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
4372                 adaptor.setTokenBoundaries(retval.tree, retval.start,
4373                         retval.stop);
4374             }
4375             if (state.backtracking == 0) {
4376
4377                 debug_print(input.toString(retval.start, input.LT(-1)));
4378                 exit("structName");
4379
4380             }
4381         }
4382
4383         catch (RecognitionException e) {
4384             throw e;
4385         }
4386         return retval;
4387     }
4388
4389     // $ANTLR end "structName"
4390
4391     public static class structOrVariantDeclarationList_return extends
4392             ParserRuleReturnScope {
4393         CommonTree tree;
4394
4395         @Override
4396         public Object getTree() {
4397             return tree;
4398         }
4399     }
4400
4401     // $ANTLR start "structOrVariantDeclarationList"
4402     // Grammar/CTFParser.g:499:1: structOrVariantDeclarationList : (
4403     // structOrVariantDeclaration )+ ;
4404     public final CTFParser.structOrVariantDeclarationList_return structOrVariantDeclarationList()
4405             throws RecognitionException {
4406         CTFParser.structOrVariantDeclarationList_return retval = new CTFParser.structOrVariantDeclarationList_return();
4407         retval.start = input.LT(1);
4408
4409         CommonTree root_0 = null;
4410
4411         CTFParser.structOrVariantDeclaration_return structOrVariantDeclaration75 = null;
4412
4413         enter("structOrVariantDeclarationList");
4414
4415         try {
4416             // Grammar/CTFParser.g:506:1: ( ( structOrVariantDeclaration )+ )
4417             // Grammar/CTFParser.g:507:3: ( structOrVariantDeclaration )+
4418             {
4419                 root_0 = (CommonTree) adaptor.nil();
4420
4421                 // Grammar/CTFParser.g:507:3: ( structOrVariantDeclaration )+
4422                 int cnt23 = 0;
4423                 loop23: do {
4424                     int alt23 = 2;
4425                     int LA23_0 = input.LA(1);
4426
4427                     if ((((LA23_0 >= CONSTTOK) && (LA23_0 <= ENUMTOK))
4428                             || ((LA23_0 >= FLOATINGPOINTTOK) && (LA23_0 <= SIGNEDTOK))
4429                             || ((LA23_0 >= STRINGTOK) && (LA23_0 <= STRUCTTOK)) || ((LA23_0 >= TYPEDEFTOK) && (LA23_0 <= IMAGINARYTOK)))) {
4430                         alt23 = 1;
4431                     } else if ((LA23_0 == IDENTIFIER)
4432                             && ((inTypealiasAlias() || isTypeName(input.LT(1)
4433                                     .getText())))) {
4434                         alt23 = 1;
4435                     } else if ((LA23_0 == TYPEALIASTOK)) {
4436                         alt23 = 1;
4437                     }
4438
4439                     switch (alt23) {
4440                     case 1:
4441                     // Grammar/CTFParser.g:507:3: structOrVariantDeclaration
4442                     {
4443                         pushFollow(FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1581);
4444                         structOrVariantDeclaration75 = structOrVariantDeclaration();
4445
4446                         state._fsp--;
4447                         if (state.failed) {
4448                             return retval;
4449                         }
4450                         if (state.backtracking == 0) {
4451                             adaptor.addChild(root_0,
4452                                     structOrVariantDeclaration75.getTree());
4453                         }
4454
4455                     }
4456                         break;
4457
4458                     default:
4459                         if (cnt23 >= 1) {
4460                             break loop23;
4461                         }
4462                         if (state.backtracking > 0) {
4463                             state.failed = true;
4464                             return retval;
4465                         }
4466                         EarlyExitException eee = new EarlyExitException(23,
4467                                 input);
4468                         throw eee;
4469                     }
4470                     cnt23++;
4471                 } while (true);
4472
4473             }
4474
4475             retval.stop = input.LT(-1);
4476
4477             if (state.backtracking == 0) {
4478
4479                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
4480                 adaptor.setTokenBoundaries(retval.tree, retval.start,
4481                         retval.stop);
4482             }
4483             if (state.backtracking == 0) {
4484
4485                 exit("structOrVariantDeclarationList");
4486
4487             }
4488         }
4489
4490         catch (RecognitionException e) {
4491             throw e;
4492
4493         }
4494         return retval;
4495     }
4496
4497     // $ANTLR end "structOrVariantDeclarationList"
4498
4499     public static class structOrVariantDeclaration_return extends
4500             ParserRuleReturnScope {
4501         CommonTree tree;
4502
4503         @Override
4504         public Object getTree() {
4505             return tree;
4506         }
4507     }
4508
4509     // $ANTLR start "structOrVariantDeclaration"
4510     // Grammar/CTFParser.g:510:1: structOrVariantDeclaration : ( (
4511     // declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF
4512     // declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList ->
4513     // ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )
4514     // ) | typealiasDecl -> typealiasDecl ) TERM ;
4515     public final CTFParser.structOrVariantDeclaration_return structOrVariantDeclaration()
4516             throws RecognitionException {
4517         CTFParser.structOrVariantDeclaration_return retval = new CTFParser.structOrVariantDeclaration_return();
4518         retval.start = input.LT(1);
4519
4520         CommonTree root_0 = null;
4521
4522         Token TERM80 = null;
4523         CTFParser.declarationSpecifiers_return declarationSpecifiers76 = null;
4524
4525         CTFParser.declaratorList_return declaratorList77 = null;
4526
4527         CTFParser.structOrVariantDeclaratorList_return structOrVariantDeclaratorList78 = null;
4528
4529         CTFParser.typealiasDecl_return typealiasDecl79 = null;
4530
4531         CommonTree TERM80_tree = null;
4532         RewriteRuleTokenStream stream_TERM = new RewriteRuleTokenStream(
4533                 adaptor, "token TERM");
4534         RewriteRuleSubtreeStream stream_declaratorList = new RewriteRuleSubtreeStream(
4535                 adaptor, "rule declaratorList");
4536         RewriteRuleSubtreeStream stream_typealiasDecl = new RewriteRuleSubtreeStream(
4537                 adaptor, "rule typealiasDecl");
4538         RewriteRuleSubtreeStream stream_declarationSpecifiers = new RewriteRuleSubtreeStream(
4539                 adaptor, "rule declarationSpecifiers");
4540         RewriteRuleSubtreeStream stream_structOrVariantDeclaratorList = new RewriteRuleSubtreeStream(
4541                 adaptor, "rule structOrVariantDeclaratorList");
4542
4543         enter("structOrVariantDeclaration");
4544
4545         try {
4546             // Grammar/CTFParser.g:517:1: ( ( ( declarationSpecifiers ({...}? =>
4547             // declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers
4548             // ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION
4549             // declarationSpecifiers structOrVariantDeclaratorList ) ) ) |
4550             // typealiasDecl -> typealiasDecl ) TERM )
4551             // Grammar/CTFParser.g:518:3: ( ( declarationSpecifiers ({...}? =>
4552             // declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers
4553             // ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION
4554             // declarationSpecifiers structOrVariantDeclaratorList ) ) ) |
4555             // typealiasDecl -> typealiasDecl ) TERM
4556             {
4557                 // Grammar/CTFParser.g:518:3: ( ( declarationSpecifiers ({...}?
4558                 // => declaratorList -> ^( TYPEDEF declaratorList
4559                 // declarationSpecifiers ) | structOrVariantDeclaratorList -> ^(
4560                 // SV_DECLARATION declarationSpecifiers
4561                 // structOrVariantDeclaratorList ) ) ) | typealiasDecl ->
4562                 // typealiasDecl )
4563                 int alt25 = 2;
4564                 int LA25_0 = input.LA(1);
4565
4566                 if ((((LA25_0 >= CONSTTOK) && (LA25_0 <= ENUMTOK))
4567                         || ((LA25_0 >= FLOATINGPOINTTOK) && (LA25_0 <= SIGNEDTOK))
4568                         || ((LA25_0 >= STRINGTOK) && (LA25_0 <= STRUCTTOK)) || ((LA25_0 >= TYPEDEFTOK) && (LA25_0 <= IMAGINARYTOK)))) {
4569                     alt25 = 1;
4570                 } else if ((LA25_0 == IDENTIFIER)
4571                         && ((inTypealiasAlias() || isTypeName(input.LT(1)
4572                                 .getText())))) {
4573                     alt25 = 1;
4574                 } else if ((LA25_0 == TYPEALIASTOK)) {
4575                     alt25 = 2;
4576                 } else {
4577                     if (state.backtracking > 0) {
4578                         state.failed = true;
4579                         return retval;
4580                     }
4581                     NoViableAltException nvae = new NoViableAltException("",
4582                             25, 0, input);
4583
4584                     throw nvae;
4585                 }
4586                 switch (alt25) {
4587                 case 1:
4588                 // Grammar/CTFParser.g:519:4: ( declarationSpecifiers ({...}? =>
4589                 // declaratorList -> ^( TYPEDEF declaratorList
4590                 // declarationSpecifiers ) | structOrVariantDeclaratorList -> ^(
4591                 // SV_DECLARATION declarationSpecifiers
4592                 // structOrVariantDeclaratorList ) ) )
4593                 {
4594                     // Grammar/CTFParser.g:519:4: ( declarationSpecifiers
4595                     // ({...}? => declaratorList -> ^( TYPEDEF declaratorList
4596                     // declarationSpecifiers ) | structOrVariantDeclaratorList
4597                     // -> ^( SV_DECLARATION declarationSpecifiers
4598                     // structOrVariantDeclaratorList ) ) )
4599                     // Grammar/CTFParser.g:520:5: declarationSpecifiers ({...}?
4600                     // => declaratorList -> ^( TYPEDEF declaratorList
4601                     // declarationSpecifiers ) | structOrVariantDeclaratorList
4602                     // -> ^( SV_DECLARATION declarationSpecifiers
4603                     // structOrVariantDeclaratorList ) )
4604                     {
4605                         pushFollow(FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1619);
4606                         declarationSpecifiers76 = declarationSpecifiers();
4607
4608                         state._fsp--;
4609                         if (state.failed) {
4610                             return retval;
4611                         }
4612                         if (state.backtracking == 0) {
4613                             stream_declarationSpecifiers
4614                                     .add(declarationSpecifiers76.getTree());
4615                         }
4616                         // Grammar/CTFParser.g:521:7: ({...}? => declaratorList
4617                         // -> ^( TYPEDEF declaratorList declarationSpecifiers )
4618                         // | structOrVariantDeclaratorList -> ^( SV_DECLARATION
4619                         // declarationSpecifiers structOrVariantDeclaratorList )
4620                         // )
4621                         int alt24 = 2;
4622                         alt24 = dfa24.predict(input);
4623                         switch (alt24) {
4624                         case 1:
4625                         // Grammar/CTFParser.g:523:9: {...}? => declaratorList
4626                         {
4627                             if (!((inTypedef()))) {
4628                                 if (state.backtracking > 0) {
4629                                     state.failed = true;
4630                                     return retval;
4631                                 }
4632                                 throw new FailedPredicateException(input,
4633                                         "structOrVariantDeclaration",
4634                                         "inTypedef()");
4635                             }
4636                             pushFollow(FOLLOW_declaratorList_in_structOrVariantDeclaration1651);
4637                             declaratorList77 = declaratorList();
4638
4639                             state._fsp--;
4640                             if (state.failed) {
4641                                 return retval;
4642                             }
4643                             if (state.backtracking == 0) {
4644                                 stream_declaratorList.add(declaratorList77
4645                                         .getTree());
4646                             }
4647                             if (state.backtracking == 0) {
4648                                 typedefOff();
4649                             }
4650
4651                             // AST REWRITE
4652                             // elements: declarationSpecifiers, declaratorList
4653                             // token labels:
4654                             // rule labels: retval
4655                             // token list labels:
4656                             // rule list labels:
4657                             // wildcard labels:
4658                             if (state.backtracking == 0) {
4659                                 retval.tree = root_0;
4660 //                                RewriteRuleSubtreeStream stream_retval =
4661                                         new RewriteRuleSubtreeStream(
4662                                         adaptor, "rule retval",
4663                                         retval != null ? retval.tree : null);
4664
4665                                 root_0 = (CommonTree) adaptor.nil();
4666                                 // 524:11: -> ^( TYPEDEF declaratorList
4667                                 // declarationSpecifiers )
4668                                 {
4669                                     // Grammar/CTFParser.g:524:14: ^( TYPEDEF
4670                                     // declaratorList declarationSpecifiers )
4671                                     {
4672                                         CommonTree root_1 = (CommonTree) adaptor
4673                                                 .nil();
4674                                         root_1 = (CommonTree) adaptor
4675                                                 .becomeRoot(adaptor.create(
4676                                                         TYPEDEF, "TYPEDEF"),
4677                                                         root_1);
4678
4679                                         adaptor.addChild(root_1,
4680                                                 stream_declaratorList
4681                                                         .nextTree());
4682                                         adaptor.addChild(root_1,
4683                                                 stream_declarationSpecifiers
4684                                                         .nextTree());
4685
4686                                         adaptor.addChild(root_0, root_1);
4687                                     }
4688
4689                                 }
4690
4691                                 retval.tree = root_0;
4692                             }
4693                         }
4694                             break;
4695                         case 2:
4696                         // Grammar/CTFParser.g:525:11:
4697                         // structOrVariantDeclaratorList
4698                         {
4699                             pushFollow(FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1685);
4700                             structOrVariantDeclaratorList78 = structOrVariantDeclaratorList();
4701
4702                             state._fsp--;
4703                             if (state.failed) {
4704                                 return retval;
4705                             }
4706                             if (state.backtracking == 0) {
4707                                 stream_structOrVariantDeclaratorList
4708                                         .add(structOrVariantDeclaratorList78
4709                                                 .getTree());
4710                             }
4711
4712                             // AST REWRITE
4713                             // elements: structOrVariantDeclaratorList,
4714                             // declarationSpecifiers
4715                             // token labels:
4716                             // rule labels: retval
4717                             // token list labels:
4718                             // rule list labels:
4719                             // wildcard labels:
4720                             if (state.backtracking == 0) {
4721                                 retval.tree = root_0;
4722 //                                RewriteRuleSubtreeStream stream_retval =
4723                                         new RewriteRuleSubtreeStream(
4724                                         adaptor, "rule retval",
4725                                         retval != null ? retval.tree : null);
4726
4727                                 root_0 = (CommonTree) adaptor.nil();
4728                                 // 526:11: -> ^( SV_DECLARATION
4729                                 // declarationSpecifiers
4730                                 // structOrVariantDeclaratorList )
4731                                 {
4732                                     // Grammar/CTFParser.g:526:14: ^(
4733                                     // SV_DECLARATION declarationSpecifiers
4734                                     // structOrVariantDeclaratorList )
4735                                     {
4736                                         CommonTree root_1 = (CommonTree) adaptor
4737                                                 .nil();
4738                                         root_1 = (CommonTree) adaptor
4739                                                 .becomeRoot(adaptor.create(
4740                                                         SV_DECLARATION,
4741                                                         "SV_DECLARATION"),
4742                                                         root_1);
4743
4744                                         adaptor.addChild(root_1,
4745                                                 stream_declarationSpecifiers
4746                                                         .nextTree());
4747                                         adaptor.addChild(root_1,
4748                                                 stream_structOrVariantDeclaratorList
4749                                                         .nextTree());
4750
4751                                         adaptor.addChild(root_0, root_1);
4752                                     }
4753
4754                                 }
4755
4756                                 retval.tree = root_0;
4757                             }
4758                         }
4759                             break;
4760
4761                         }
4762
4763                     }
4764
4765                 }
4766                     break;
4767                 case 2:
4768                 // Grammar/CTFParser.g:531:5: typealiasDecl
4769                 {
4770                     pushFollow(FOLLOW_typealiasDecl_in_structOrVariantDeclaration1735);
4771                     typealiasDecl79 = typealiasDecl();
4772
4773                     state._fsp--;
4774                     if (state.failed) {
4775                         return retval;
4776                     }
4777                     if (state.backtracking == 0) {
4778                         stream_typealiasDecl.add(typealiasDecl79.getTree());
4779                     }
4780
4781                     // AST REWRITE
4782                     // elements: typealiasDecl
4783                     // token labels:
4784                     // rule labels: retval
4785                     // token list labels:
4786                     // rule list labels:
4787                     // wildcard labels:
4788                     if (state.backtracking == 0) {
4789                         retval.tree = root_0;
4790 //                        RewriteRuleSubtreeStream stream_retval =
4791                                 new RewriteRuleSubtreeStream(
4792                                 adaptor, "rule retval",
4793                                 retval != null ? retval.tree : null);
4794
4795                         root_0 = (CommonTree) adaptor.nil();
4796                         // 531:19: -> typealiasDecl
4797                         {
4798                             adaptor.addChild(root_0,
4799                                     stream_typealiasDecl.nextTree());
4800
4801                         }
4802
4803                         retval.tree = root_0;
4804                     }
4805                 }
4806                     break;
4807
4808                 }
4809
4810                 TERM80 = (Token) match(input, TERM,
4811                         FOLLOW_TERM_in_structOrVariantDeclaration1747);
4812                 if (state.failed) {
4813                     return retval;
4814                 }
4815                 if (state.backtracking == 0) {
4816                     stream_TERM.add(TERM80);
4817                 }
4818
4819             }
4820
4821             retval.stop = input.LT(-1);
4822
4823             if (state.backtracking == 0) {
4824
4825                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
4826                 adaptor.setTokenBoundaries(retval.tree, retval.start,
4827                         retval.stop);
4828             }
4829             if (state.backtracking == 0) {
4830
4831                 exit("structOrVariantDeclaration");
4832
4833             }
4834         }
4835
4836         catch (RecognitionException e) {
4837             throw e;
4838
4839         }
4840         return retval;
4841     }
4842
4843     // $ANTLR end "structOrVariantDeclaration"
4844
4845     public static class specifierQualifierList_return extends
4846             ParserRuleReturnScope {
4847         CommonTree tree;
4848
4849         @Override
4850         public Object getTree() {
4851             return tree;
4852         }
4853     }
4854
4855     // $ANTLR start "specifierQualifierList"
4856     // Grammar/CTFParser.g:536:1: specifierQualifierList : ( typeQualifier |
4857     // typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
4858     // typeSpecifier )* ) ;
4859     public final CTFParser.specifierQualifierList_return specifierQualifierList()
4860             throws RecognitionException {
4861         CTFParser.specifierQualifierList_return retval = new CTFParser.specifierQualifierList_return();
4862         retval.start = input.LT(1);
4863
4864         CommonTree root_0 = null;
4865
4866         CTFParser.typeQualifier_return typeQualifier81 = null;
4867
4868         CTFParser.typeSpecifier_return typeSpecifier82 = null;
4869
4870         RewriteRuleSubtreeStream stream_typeSpecifier = new RewriteRuleSubtreeStream(
4871                 adaptor, "rule typeSpecifier");
4872         RewriteRuleSubtreeStream stream_typeQualifier = new RewriteRuleSubtreeStream(
4873                 adaptor, "rule typeQualifier");
4874
4875         enter("specifierQualifierList");
4876
4877         try {
4878             // Grammar/CTFParser.g:543:1: ( ( typeQualifier | typeSpecifier )+
4879             // -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
4880             // )
4881             // Grammar/CTFParser.g:544:3: ( typeQualifier | typeSpecifier )+
4882             {
4883                 // Grammar/CTFParser.g:544:3: ( typeQualifier | typeSpecifier )+
4884                 int cnt26 = 0;
4885                 loop26: do {
4886                     int alt26 = 3;
4887                     int LA26_0 = input.LA(1);
4888
4889                     if ((LA26_0 == CONSTTOK)) {
4890                         alt26 = 1;
4891                     } else if ((((LA26_0 >= CHARTOK) && (LA26_0 <= ENUMTOK))
4892                             || ((LA26_0 >= FLOATINGPOINTTOK) && (LA26_0 <= SIGNEDTOK))
4893                             || ((LA26_0 >= STRINGTOK) && (LA26_0 <= STRUCTTOK)) || ((LA26_0 >= UNSIGNEDTOK) && (LA26_0 <= IMAGINARYTOK)))) {
4894                         alt26 = 2;
4895                     } else if ((LA26_0 == IDENTIFIER)
4896                             && ((inTypealiasAlias() || isTypeName(input.LT(1)
4897                                     .getText())))) {
4898                         alt26 = 2;
4899                     }
4900
4901                     switch (alt26) {
4902                     case 1:
4903                     // Grammar/CTFParser.g:544:4: typeQualifier
4904                     {
4905                         pushFollow(FOLLOW_typeQualifier_in_specifierQualifierList1771);
4906                         typeQualifier81 = typeQualifier();
4907
4908                         state._fsp--;
4909                         if (state.failed) {
4910                             return retval;
4911                         }
4912                         if (state.backtracking == 0) {
4913                             stream_typeQualifier.add(typeQualifier81.getTree());
4914                         }
4915
4916                     }
4917                         break;
4918                     case 2:
4919                     // Grammar/CTFParser.g:544:20: typeSpecifier
4920                     {
4921                         pushFollow(FOLLOW_typeSpecifier_in_specifierQualifierList1775);
4922                         typeSpecifier82 = typeSpecifier();
4923
4924                         state._fsp--;
4925                         if (state.failed) {
4926                             return retval;
4927                         }
4928                         if (state.backtracking == 0) {
4929                             stream_typeSpecifier.add(typeSpecifier82.getTree());
4930                         }
4931
4932                     }
4933                         break;
4934
4935                     default:
4936                         if (cnt26 >= 1) {
4937                             break loop26;
4938                         }
4939                         if (state.backtracking > 0) {
4940                             state.failed = true;
4941                             return retval;
4942                         }
4943                         EarlyExitException eee = new EarlyExitException(26,
4944                                 input);
4945                         throw eee;
4946                     }
4947                     cnt26++;
4948                 } while (true);
4949
4950                 // AST REWRITE
4951                 // elements: typeSpecifier, typeQualifier
4952                 // token labels:
4953                 // rule labels: retval
4954                 // token list labels:
4955                 // rule list labels:
4956                 // wildcard labels:
4957                 if (state.backtracking == 0) {
4958                     retval.tree = root_0;
4959 //                    RewriteRuleSubtreeStream stream_retval =
4960                             new RewriteRuleSubtreeStream(
4961                             adaptor, "rule retval",
4962                             retval != null ? retval.tree : null);
4963
4964                     root_0 = (CommonTree) adaptor.nil();
4965                     // 544:36: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
4966                     // typeSpecifier )* )
4967                     {
4968                         // Grammar/CTFParser.g:544:39: ^( TYPE_SPECIFIER_LIST (
4969                         // typeQualifier )* ( typeSpecifier )* )
4970                         {
4971                             CommonTree root_1 = (CommonTree) adaptor.nil();
4972                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
4973                                     .create(TYPE_SPECIFIER_LIST,
4974                                             "TYPE_SPECIFIER_LIST"), root_1);
4975
4976                             // Grammar/CTFParser.g:544:61: ( typeQualifier )*
4977                             while (stream_typeQualifier.hasNext()) {
4978                                 adaptor.addChild(root_1,
4979                                         stream_typeQualifier.nextTree());
4980
4981                             }
4982                             stream_typeQualifier.reset();
4983                             // Grammar/CTFParser.g:544:76: ( typeSpecifier )*
4984                             while (stream_typeSpecifier.hasNext()) {
4985                                 adaptor.addChild(root_1,
4986                                         stream_typeSpecifier.nextTree());
4987
4988                             }
4989                             stream_typeSpecifier.reset();
4990
4991                             adaptor.addChild(root_0, root_1);
4992                         }
4993
4994                     }
4995
4996                     retval.tree = root_0;
4997                 }
4998             }
4999
5000             retval.stop = input.LT(-1);
5001
5002             if (state.backtracking == 0) {
5003
5004                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
5005                 adaptor.setTokenBoundaries(retval.tree, retval.start,
5006                         retval.stop);
5007             }
5008             if (state.backtracking == 0) {
5009
5010                 exit("specifierQualifierList");
5011
5012             }
5013         }
5014
5015         catch (RecognitionException e) {
5016             throw e;
5017
5018         }
5019         return retval;
5020     }
5021
5022     // $ANTLR end "specifierQualifierList"
5023
5024     public static class structOrVariantDeclaratorList_return extends
5025             ParserRuleReturnScope {
5026         CommonTree tree;
5027
5028         @Override
5029         public Object getTree() {
5030             return tree;
5031         }
5032     }
5033
5034     // $ANTLR start "structOrVariantDeclaratorList"
5035     // Grammar/CTFParser.g:547:1: structOrVariantDeclaratorList :
5036     // structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )* -> ^(
5037     // TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ ) ;
5038     public final CTFParser.structOrVariantDeclaratorList_return structOrVariantDeclaratorList()
5039             throws RecognitionException {
5040         CTFParser.structOrVariantDeclaratorList_return retval = new CTFParser.structOrVariantDeclaratorList_return();
5041         retval.start = input.LT(1);
5042
5043         CommonTree root_0 = null;
5044
5045         Token SEPARATOR84 = null;
5046         CTFParser.structOrVariantDeclarator_return structOrVariantDeclarator83 = null;
5047
5048         CTFParser.structOrVariantDeclarator_return structOrVariantDeclarator85 = null;
5049
5050         CommonTree SEPARATOR84_tree = null;
5051         RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
5052                 adaptor, "token SEPARATOR");
5053         RewriteRuleSubtreeStream stream_structOrVariantDeclarator = new RewriteRuleSubtreeStream(
5054                 adaptor, "rule structOrVariantDeclarator");
5055
5056         enter("structOrVariantDeclaratorList");
5057
5058         try {
5059             // Grammar/CTFParser.g:554:1: ( structOrVariantDeclarator (
5060             // SEPARATOR structOrVariantDeclarator )* -> ^( TYPE_DECLARATOR_LIST
5061             // ( structOrVariantDeclarator )+ ) )
5062             // Grammar/CTFParser.g:555:3: structOrVariantDeclarator ( SEPARATOR
5063             // structOrVariantDeclarator )*
5064             {
5065                 pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1812);
5066                 structOrVariantDeclarator83 = structOrVariantDeclarator();
5067
5068                 state._fsp--;
5069                 if (state.failed) {
5070                     return retval;
5071                 }
5072                 if (state.backtracking == 0) {
5073                     stream_structOrVariantDeclarator
5074                             .add(structOrVariantDeclarator83.getTree());
5075                 }
5076                 // Grammar/CTFParser.g:555:29: ( SEPARATOR
5077                 // structOrVariantDeclarator )*
5078                 loop27: do {
5079                     int alt27 = 2;
5080                     int LA27_0 = input.LA(1);
5081
5082                     if ((LA27_0 == SEPARATOR)) {
5083                         alt27 = 1;
5084                     }
5085
5086                     switch (alt27) {
5087                     case 1:
5088                     // Grammar/CTFParser.g:555:30: SEPARATOR
5089                     // structOrVariantDeclarator
5090                     {
5091                         SEPARATOR84 = (Token) match(input, SEPARATOR,
5092                                 FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1815);
5093                         if (state.failed) {
5094                             return retval;
5095                         }
5096                         if (state.backtracking == 0) {
5097                             stream_SEPARATOR.add(SEPARATOR84);
5098                         }
5099
5100                         pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1817);
5101                         structOrVariantDeclarator85 = structOrVariantDeclarator();
5102
5103                         state._fsp--;
5104                         if (state.failed) {
5105                             return retval;
5106                         }
5107                         if (state.backtracking == 0) {
5108                             stream_structOrVariantDeclarator
5109                                     .add(structOrVariantDeclarator85.getTree());
5110                         }
5111
5112                     }
5113                         break;
5114
5115                     default:
5116                         break loop27;
5117                     }
5118                 } while (true);
5119
5120                 // AST REWRITE
5121                 // elements: structOrVariantDeclarator
5122                 // token labels:
5123                 // rule labels: retval
5124                 // token list labels:
5125                 // rule list labels:
5126                 // wildcard labels:
5127                 if (state.backtracking == 0) {
5128                     retval.tree = root_0;
5129 //                    RewriteRuleSubtreeStream stream_retval =
5130                             new RewriteRuleSubtreeStream(
5131                             adaptor, "rule retval",
5132                             retval != null ? retval.tree : null);
5133
5134                     root_0 = (CommonTree) adaptor.nil();
5135                     // 555:68: -> ^( TYPE_DECLARATOR_LIST (
5136                     // structOrVariantDeclarator )+ )
5137                     {
5138                         // Grammar/CTFParser.g:555:71: ^( TYPE_DECLARATOR_LIST (
5139                         // structOrVariantDeclarator )+ )
5140                         {
5141                             CommonTree root_1 = (CommonTree) adaptor.nil();
5142                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
5143                                     .create(TYPE_DECLARATOR_LIST,
5144                                             "TYPE_DECLARATOR_LIST"), root_1);
5145
5146                             if (!(stream_structOrVariantDeclarator.hasNext())) {
5147                                 throw new RewriteEarlyExitException();
5148                             }
5149                             while (stream_structOrVariantDeclarator.hasNext()) {
5150                                 adaptor.addChild(root_1,
5151                                         stream_structOrVariantDeclarator
5152                                                 .nextTree());
5153
5154                             }
5155                             stream_structOrVariantDeclarator.reset();
5156
5157                             adaptor.addChild(root_0, root_1);
5158                         }
5159
5160                     }
5161
5162                     retval.tree = root_0;
5163                 }
5164             }
5165
5166             retval.stop = input.LT(-1);
5167
5168             if (state.backtracking == 0) {
5169
5170                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
5171                 adaptor.setTokenBoundaries(retval.tree, retval.start,
5172                         retval.stop);
5173             }
5174             if (state.backtracking == 0) {
5175
5176                 exit("structOrVariantDeclaratorList");
5177
5178             }
5179         }
5180
5181         catch (RecognitionException e) {
5182             throw e;
5183         }
5184         return retval;
5185     }
5186
5187     // $ANTLR end "structOrVariantDeclaratorList"
5188
5189     public static class structOrVariantDeclarator_return extends
5190             ParserRuleReturnScope {
5191         CommonTree tree;
5192
5193         @Override
5194         public Object getTree() {
5195             return tree;
5196         }
5197     }
5198
5199     // $ANTLR start "structOrVariantDeclarator"
5200     // Grammar/CTFParser.g:558:1: structOrVariantDeclarator : ( declarator (
5201     // COLON numberLiteral )? ) -> declarator ;
5202     public final CTFParser.structOrVariantDeclarator_return structOrVariantDeclarator()
5203             throws RecognitionException {
5204         CTFParser.structOrVariantDeclarator_return retval = new CTFParser.structOrVariantDeclarator_return();
5205         retval.start = input.LT(1);
5206
5207         CommonTree root_0 = null;
5208
5209         Token COLON87 = null;
5210         CTFParser.declarator_return declarator86 = null;
5211
5212         CTFParser.numberLiteral_return numberLiteral88 = null;
5213
5214         CommonTree COLON87_tree = null;
5215         RewriteRuleTokenStream stream_COLON = new RewriteRuleTokenStream(
5216                 adaptor, "token COLON");
5217         RewriteRuleSubtreeStream stream_declarator = new RewriteRuleSubtreeStream(
5218                 adaptor, "rule declarator");
5219         RewriteRuleSubtreeStream stream_numberLiteral = new RewriteRuleSubtreeStream(
5220                 adaptor, "rule numberLiteral");
5221
5222         enter("structOrVariantDeclarator");
5223
5224         try {
5225             // Grammar/CTFParser.g:565:1: ( ( declarator ( COLON numberLiteral
5226             // )? ) -> declarator )
5227             // Grammar/CTFParser.g:567:5: ( declarator ( COLON numberLiteral )?
5228             // )
5229             {
5230                 // Grammar/CTFParser.g:567:5: ( declarator ( COLON numberLiteral
5231                 // )? )
5232                 // Grammar/CTFParser.g:567:6: declarator ( COLON numberLiteral
5233                 // )?
5234                 {
5235                     pushFollow(FOLLOW_declarator_in_structOrVariantDeclarator1858);
5236                     declarator86 = declarator();
5237
5238                     state._fsp--;
5239                     if (state.failed) {
5240                         return retval;
5241                     }
5242                     if (state.backtracking == 0) {
5243                         stream_declarator.add(declarator86.getTree());
5244                     }
5245                     // Grammar/CTFParser.g:567:17: ( COLON numberLiteral )?
5246                     int alt28 = 2;
5247                     int LA28_0 = input.LA(1);
5248
5249                     if ((LA28_0 == COLON)) {
5250                         alt28 = 1;
5251                     }
5252                     switch (alt28) {
5253                     case 1:
5254                     // Grammar/CTFParser.g:567:18: COLON numberLiteral
5255                     {
5256                         COLON87 = (Token) match(input, COLON,
5257                                 FOLLOW_COLON_in_structOrVariantDeclarator1861);
5258                         if (state.failed) {
5259                             return retval;
5260                         }
5261                         if (state.backtracking == 0) {
5262                             stream_COLON.add(COLON87);
5263                         }
5264
5265                         pushFollow(FOLLOW_numberLiteral_in_structOrVariantDeclarator1863);
5266                         numberLiteral88 = numberLiteral();
5267
5268                         state._fsp--;
5269                         if (state.failed) {
5270                             return retval;
5271                         }
5272                         if (state.backtracking == 0) {
5273                             stream_numberLiteral.add(numberLiteral88.getTree());
5274                         }
5275
5276                     }
5277                         break;
5278
5279                     }
5280
5281                 }
5282
5283                 // AST REWRITE
5284                 // elements: declarator
5285                 // token labels:
5286                 // rule labels: retval
5287                 // token list labels:
5288                 // rule list labels:
5289                 // wildcard labels:
5290                 if (state.backtracking == 0) {
5291                     retval.tree = root_0;
5292 //                    RewriteRuleSubtreeStream stream_retval =
5293                             new RewriteRuleSubtreeStream(
5294                             adaptor, "rule retval",
5295                             retval != null ? retval.tree : null);
5296
5297                     root_0 = (CommonTree) adaptor.nil();
5298                     // 567:41: -> declarator
5299                     {
5300                         adaptor.addChild(root_0, stream_declarator.nextTree());
5301
5302                     }
5303
5304                     retval.tree = root_0;
5305                 }
5306             }
5307
5308             retval.stop = input.LT(-1);
5309
5310             if (state.backtracking == 0) {
5311
5312                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
5313                 adaptor.setTokenBoundaries(retval.tree, retval.start,
5314                         retval.stop);
5315             }
5316             if (state.backtracking == 0) {
5317
5318                 exit("structOrVariantDeclarator");
5319
5320             }
5321         }
5322
5323         catch (RecognitionException e) {
5324             throw e;
5325         }
5326         return retval;
5327     }
5328
5329     // $ANTLR end "structOrVariantDeclarator"
5330
5331     public static class variantSpecifier_return extends ParserRuleReturnScope {
5332         CommonTree tree;
5333
5334         @Override
5335         public Object getTree() {
5336             return tree;
5337         }
5338     }
5339
5340     // $ANTLR start "variantSpecifier"
5341     // Grammar/CTFParser.g:571:1: variantSpecifier : VARIANTTOK ( ( variantName
5342     // ( ( variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
5343     // variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? ( variantTag
5344     // )? ( variantBody )? ) ;
5345     public final CTFParser.variantSpecifier_return variantSpecifier()
5346             throws RecognitionException {
5347         CTFParser.variantSpecifier_return retval = new CTFParser.variantSpecifier_return();
5348         retval.start = input.LT(1);
5349
5350         CommonTree root_0 = null;
5351
5352         Token VARIANTTOK89 = null;
5353         CTFParser.variantName_return variantName90 = null;
5354
5355         CTFParser.variantTag_return variantTag91 = null;
5356
5357         CTFParser.variantBody_return variantBody92 = null;
5358
5359         CTFParser.variantBody_return variantBody93 = null;
5360
5361         CTFParser.variantTag_return variantTag94 = null;
5362
5363         CTFParser.variantBody_return variantBody95 = null;
5364
5365         CTFParser.variantBody_return variantBody96 = null;
5366
5367         CommonTree VARIANTTOK89_tree = null;
5368         RewriteRuleTokenStream stream_VARIANTTOK = new RewriteRuleTokenStream(
5369                 adaptor, "token VARIANTTOK");
5370         RewriteRuleSubtreeStream stream_variantName = new RewriteRuleSubtreeStream(
5371                 adaptor, "rule variantName");
5372         RewriteRuleSubtreeStream stream_variantTag = new RewriteRuleSubtreeStream(
5373                 adaptor, "rule variantTag");
5374         RewriteRuleSubtreeStream stream_variantBody = new RewriteRuleSubtreeStream(
5375                 adaptor, "rule variantBody");
5376
5377         enter("variantSpecifier");
5378
5379         try {
5380             // Grammar/CTFParser.g:578:1: ( VARIANTTOK ( ( variantName ( (
5381             // variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
5382             // variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? (
5383             // variantTag )? ( variantBody )? ) )
5384             // Grammar/CTFParser.g:579:3: VARIANTTOK ( ( variantName ( (
5385             // variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
5386             // variantBody ) | variantBody )
5387             {
5388                 VARIANTTOK89 = (Token) match(input, VARIANTTOK,
5389                         FOLLOW_VARIANTTOK_in_variantSpecifier1897);
5390                 if (state.failed) {
5391                     return retval;
5392                 }
5393                 if (state.backtracking == 0) {
5394                     stream_VARIANTTOK.add(VARIANTTOK89);
5395                 }
5396
5397                 // Grammar/CTFParser.g:580:3: ( ( variantName ( ( variantTag (
5398                 // variantBody | ) ) | variantBody ) ) | ( variantTag
5399                 // variantBody ) | variantBody )
5400                 int alt31 = 3;
5401                 switch (input.LA(1)) {
5402                 case IDENTIFIER: {
5403                     alt31 = 1;
5404                 }
5405                     break;
5406                 case LT: {
5407                     alt31 = 2;
5408                 }
5409                     break;
5410                 case LCURL: {
5411                     alt31 = 3;
5412                 }
5413                     break;
5414                 default:
5415                     if (state.backtracking > 0) {
5416                         state.failed = true;
5417                         return retval;
5418                     }
5419                     NoViableAltException nvae = new NoViableAltException("",
5420                             31, 0, input);
5421
5422                     throw nvae;
5423                 }
5424
5425                 switch (alt31) {
5426                 case 1:
5427                 // Grammar/CTFParser.g:581:5: ( variantName ( ( variantTag (
5428                 // variantBody | ) ) | variantBody ) )
5429                 {
5430                     // Grammar/CTFParser.g:581:5: ( variantName ( ( variantTag (
5431                     // variantBody | ) ) | variantBody ) )
5432                     // Grammar/CTFParser.g:582:7: variantName ( ( variantTag (
5433                     // variantBody | ) ) | variantBody )
5434                     {
5435                         pushFollow(FOLLOW_variantName_in_variantSpecifier1915);
5436                         variantName90 = variantName();
5437
5438                         state._fsp--;
5439                         if (state.failed) {
5440                             return retval;
5441                         }
5442                         if (state.backtracking == 0) {
5443                             stream_variantName.add(variantName90.getTree());
5444                         }
5445                         // Grammar/CTFParser.g:583:7: ( ( variantTag (
5446                         // variantBody | ) ) | variantBody )
5447                         int alt30 = 2;
5448                         int LA30_0 = input.LA(1);
5449
5450                         if ((LA30_0 == LT)) {
5451                             alt30 = 1;
5452                         } else if ((LA30_0 == LCURL)) {
5453                             alt30 = 2;
5454                         } else {
5455                             if (state.backtracking > 0) {
5456                                 state.failed = true;
5457                                 return retval;
5458                             }
5459                             NoViableAltException nvae = new NoViableAltException(
5460                                     "", 30, 0, input);
5461
5462                             throw nvae;
5463                         }
5464                         switch (alt30) {
5465                         case 1:
5466                         // Grammar/CTFParser.g:584:9: ( variantTag ( variantBody
5467                         // | ) )
5468                         {
5469                             // Grammar/CTFParser.g:584:9: ( variantTag (
5470                             // variantBody | ) )
5471                             // Grammar/CTFParser.g:585:11: variantTag (
5472                             // variantBody | )
5473                             {
5474                                 pushFollow(FOLLOW_variantTag_in_variantSpecifier1946);
5475                                 variantTag91 = variantTag();
5476
5477                                 state._fsp--;
5478                                 if (state.failed) {
5479                                     return retval;
5480                                 }
5481                                 if (state.backtracking == 0) {
5482                                     stream_variantTag.add(variantTag91
5483                                             .getTree());
5484                                 }
5485                                 // Grammar/CTFParser.g:586:11: ( variantBody | )
5486                                 int alt29 = 2;
5487                                 int LA29_0 = input.LA(1);
5488
5489                                 if ((LA29_0 == LCURL)) {
5490                                     switch (input.LA(2)) {
5491                                     case CONSTTOK:
5492                                     case CHARTOK:
5493                                     case DOUBLETOK:
5494                                     case ENUMTOK:
5495                                     case FLOATINGPOINTTOK:
5496                                     case FLOATTOK:
5497                                     case INTEGERTOK:
5498                                     case INTTOK:
5499                                     case LONGTOK:
5500                                     case SHORTTOK:
5501                                     case STRUCTTOK:
5502                                     case TYPEALIASTOK:
5503                                     case TYPEDEFTOK:
5504                                     case UNSIGNEDTOK:
5505                                     case VARIANTTOK:
5506                                     case VOIDTOK:
5507                                     case BOOLTOK:
5508                                     case COMPLEXTOK:
5509                                     case IMAGINARYTOK: {
5510                                         alt29 = 1;
5511                                     }
5512                                         break;
5513                                     case SIGNEDTOK: {
5514                                         int LA29_4 = input.LA(3);
5515
5516                                         if ((((LA29_4 >= CONSTTOK) && (LA29_4 <= ENUMTOK))
5517                                                 || ((LA29_4 >= FLOATINGPOINTTOK) && (LA29_4 <= SIGNEDTOK))
5518                                                 || ((LA29_4 >= STRINGTOK) && (LA29_4 <= STRUCTTOK))
5519                                                 || ((LA29_4 >= TYPEDEFTOK) && (LA29_4 <= IMAGINARYTOK))
5520                                                 || (LA29_4 == POINTER) || (LA29_4 == IDENTIFIER))) {
5521                                             alt29 = 1;
5522                                         } else if (((LA29_4 == SEPARATOR)
5523                                                 || (LA29_4 == ASSIGNMENT) || (LA29_4 == RCURL))) {
5524                                             alt29 = 2;
5525                                         } else {
5526                                             if (state.backtracking > 0) {
5527                                                 state.failed = true;
5528                                                 return retval;
5529                                             }
5530                                             NoViableAltException nvae = new NoViableAltException(
5531                                                     "", 29, 4, input);
5532
5533                                             throw nvae;
5534                                         }
5535                                     }
5536                                         break;
5537                                     case STRINGTOK: {
5538                                         int LA29_5 = input.LA(3);
5539
5540                                         if (((LA29_5 == SEPARATOR)
5541                                                 || (LA29_5 == ASSIGNMENT) || (LA29_5 == RCURL))) {
5542                                             alt29 = 2;
5543                                         } else if ((((LA29_5 >= CONSTTOK) && (LA29_5 <= ENUMTOK))
5544                                                 || ((LA29_5 >= FLOATINGPOINTTOK) && (LA29_5 <= SIGNEDTOK))
5545                                                 || ((LA29_5 >= STRINGTOK) && (LA29_5 <= STRUCTTOK))
5546                                                 || ((LA29_5 >= TYPEDEFTOK) && (LA29_5 <= IMAGINARYTOK))
5547                                                 || (LA29_5 == LCURL)
5548                                                 || (LA29_5 == POINTER) || (LA29_5 == IDENTIFIER))) {
5549                                             alt29 = 1;
5550                                         } else {
5551                                             if (state.backtracking > 0) {
5552                                                 state.failed = true;
5553                                                 return retval;
5554                                             }
5555                                             NoViableAltException nvae = new NoViableAltException(
5556                                                     "", 29, 5, input);
5557
5558                                             throw nvae;
5559                                         }
5560                                     }
5561                                         break;
5562                                     case IDENTIFIER: {
5563                                         int LA29_6 = input.LA(3);
5564
5565                                         if (((LA29_6 == SEPARATOR)
5566                                                 || (LA29_6 == ASSIGNMENT) || (LA29_6 == RCURL))) {
5567                                             alt29 = 2;
5568                                         } else if ((((LA29_6 >= CONSTTOK) && (LA29_6 <= ENUMTOK))
5569                                                 || ((LA29_6 >= FLOATINGPOINTTOK) && (LA29_6 <= SIGNEDTOK))
5570                                                 || ((LA29_6 >= STRINGTOK) && (LA29_6 <= STRUCTTOK))
5571                                                 || ((LA29_6 >= TYPEDEFTOK) && (LA29_6 <= IMAGINARYTOK))
5572                                                 || (LA29_6 == POINTER) || (LA29_6 == IDENTIFIER))) {
5573                                             alt29 = 1;
5574                                         } else {
5575                                             if (state.backtracking > 0) {
5576                                                 state.failed = true;
5577                                                 return retval;
5578                                             }
5579                                             NoViableAltException nvae = new NoViableAltException(
5580                                                     "", 29, 6, input);
5581
5582                                             throw nvae;
5583                                         }
5584                                     }
5585                                         break;
5586                                     case ALIGNTOK:
5587                                     case EVENTTOK:
5588                                     case STRING_LITERAL: {
5589                                         alt29 = 2;
5590                                     }
5591                                         break;
5592                                     default:
5593                                         if (state.backtracking > 0) {
5594                                             state.failed = true;
5595                                             return retval;
5596                                         }
5597                                         NoViableAltException nvae = new NoViableAltException(
5598                                                 "", 29, 1, input);
5599
5600                                         throw nvae;
5601                                     }
5602
5603                                 } else if (((LA29_0 == EOF)
5604                                         || ((LA29_0 >= CONSTTOK) && (LA29_0 <= ENUMTOK))
5605                                         || ((LA29_0 >= FLOATINGPOINTTOK) && (LA29_0 <= SIGNEDTOK))
5606                                         || ((LA29_0 >= STRINGTOK) && (LA29_0 <= STRUCTTOK))
5607                                         || ((LA29_0 >= TYPEDEFTOK) && (LA29_0 <= IMAGINARYTOK))
5608                                         || (LA29_0 == TYPE_ASSIGNMENT)
5609                                         || (LA29_0 == LPAREN)
5610                                         || ((LA29_0 >= TERM) && (LA29_0 <= POINTER)) || (LA29_0 == IDENTIFIER))) {
5611                                     alt29 = 2;
5612                                 } else {
5613                                     if (state.backtracking > 0) {
5614                                         state.failed = true;
5615                                         return retval;
5616                                     }
5617                                     NoViableAltException nvae = new NoViableAltException(
5618                                             "", 29, 0, input);
5619
5620                                     throw nvae;
5621                                 }
5622                                 switch (alt29) {
5623                                 case 1:
5624                                 // Grammar/CTFParser.g:587:13: variantBody
5625                                 {
5626                                     pushFollow(FOLLOW_variantBody_in_variantSpecifier1972);
5627                                     variantBody92 = variantBody();
5628
5629                                     state._fsp--;
5630                                     if (state.failed) {
5631                                         return retval;
5632                                     }
5633                                     if (state.backtracking == 0) {
5634                                         stream_variantBody.add(variantBody92
5635                                                 .getTree());
5636                                     }
5637
5638                                 }
5639                                     break;
5640                                 case 2:
5641                                     break;
5642
5643                                 }
5644
5645                             }
5646
5647                         }
5648                             break;
5649                         case 2:
5650                         // Grammar/CTFParser.g:593:9: variantBody
5651                         {
5652                             pushFollow(FOLLOW_variantBody_in_variantSpecifier2040);
5653                             variantBody93 = variantBody();
5654
5655                             state._fsp--;
5656                             if (state.failed) {
5657                                 return retval;
5658                             }
5659                             if (state.backtracking == 0) {
5660                                 stream_variantBody.add(variantBody93.getTree());
5661                             }
5662
5663                         }
5664                             break;
5665
5666                         }
5667
5668                     }
5669
5670                 }
5671                     break;
5672                 case 2:
5673                 // Grammar/CTFParser.g:597:5: ( variantTag variantBody )
5674                 {
5675                     // Grammar/CTFParser.g:597:5: ( variantTag variantBody )
5676                     // Grammar/CTFParser.g:597:6: variantTag variantBody
5677                     {
5678                         pushFollow(FOLLOW_variantTag_in_variantSpecifier2065);
5679                         variantTag94 = variantTag();
5680
5681                         state._fsp--;
5682                         if (state.failed) {
5683                             return retval;
5684                         }
5685                         if (state.backtracking == 0) {
5686                             stream_variantTag.add(variantTag94.getTree());
5687                         }
5688                         pushFollow(FOLLOW_variantBody_in_variantSpecifier2067);
5689                         variantBody95 = variantBody();
5690
5691                         state._fsp--;
5692                         if (state.failed) {
5693                             return retval;
5694                         }
5695                         if (state.backtracking == 0) {
5696                             stream_variantBody.add(variantBody95.getTree());
5697                         }
5698
5699                     }
5700
5701                 }
5702                     break;
5703                 case 3:
5704                 // Grammar/CTFParser.g:599:5: variantBody
5705                 {
5706                     pushFollow(FOLLOW_variantBody_in_variantSpecifier2078);
5707                     variantBody96 = variantBody();
5708
5709                     state._fsp--;
5710                     if (state.failed) {
5711                         return retval;
5712                     }
5713                     if (state.backtracking == 0) {
5714                         stream_variantBody.add(variantBody96.getTree());
5715                     }
5716
5717                 }
5718                     break;
5719
5720                 }
5721
5722                 // AST REWRITE
5723                 // elements: variantBody, variantTag, variantName
5724                 // token labels:
5725                 // rule labels: retval
5726                 // token list labels:
5727                 // rule list labels:
5728                 // wildcard labels:
5729                 if (state.backtracking == 0) {
5730                     retval.tree = root_0;
5731                     RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
5732                             adaptor, "rule retval",
5733                             retval != null ? retval.tree : null);
5734
5735                     root_0 = (CommonTree) adaptor.nil();
5736                     // 600:5: -> ^( VARIANT ( variantName )? ( variantTag )? (
5737                     // variantBody )? )
5738                     {
5739                         // Grammar/CTFParser.g:600:8: ^( VARIANT ( variantName
5740                         // )? ( variantTag )? ( variantBody )? )
5741                         {
5742                             CommonTree root_1 = (CommonTree) adaptor.nil();
5743                             root_1 = (CommonTree) adaptor.becomeRoot(
5744                                     adaptor.create(VARIANT, "VARIANT"), root_1);
5745
5746                             // Grammar/CTFParser.g:600:18: ( variantName )?
5747                             if (stream_variantName.hasNext()) {
5748                                 adaptor.addChild(root_1,
5749                                         stream_variantName.nextTree());
5750
5751                             }
5752                             stream_variantName.reset();
5753                             // Grammar/CTFParser.g:600:31: ( variantTag )?
5754                             if (stream_variantTag.hasNext()) {
5755                                 adaptor.addChild(root_1,
5756                                         stream_variantTag.nextTree());
5757
5758                             }
5759                             stream_variantTag.reset();
5760                             // Grammar/CTFParser.g:600:43: ( variantBody )?
5761                             if (stream_variantBody.hasNext()) {
5762                                 adaptor.addChild(root_1,
5763                                         stream_variantBody.nextTree());
5764
5765                             }
5766                             stream_variantBody.reset();
5767
5768                             adaptor.addChild(root_0, root_1);
5769                         }
5770
5771                     }
5772
5773                     retval.tree = root_0;
5774                 }
5775             }
5776
5777             retval.stop = input.LT(-1);
5778
5779             if (state.backtracking == 0) {
5780
5781                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
5782                 adaptor.setTokenBoundaries(retval.tree, retval.start,
5783                         retval.stop);
5784             }
5785             if (state.backtracking == 0) {
5786
5787                 exit("variantSpecifier");
5788
5789             }
5790         }
5791
5792         catch (RecognitionException e) {
5793             throw e;
5794         }
5795         return retval;
5796     }
5797
5798     // $ANTLR end "variantSpecifier"
5799
5800     public static class variantName_return extends ParserRuleReturnScope {
5801         CommonTree tree;
5802
5803         @Override
5804         public Object getTree() {
5805             return tree;
5806         }
5807     }
5808
5809     // $ANTLR start "variantName"
5810     // Grammar/CTFParser.g:603:1: variantName : IDENTIFIER -> ^( VARIANT_NAME
5811     // IDENTIFIER ) ;
5812     public final CTFParser.variantName_return variantName()
5813             throws RecognitionException {
5814         CTFParser.variantName_return retval = new CTFParser.variantName_return();
5815         retval.start = input.LT(1);
5816
5817         CommonTree root_0 = null;
5818
5819         Token IDENTIFIER97 = null;
5820
5821         CommonTree IDENTIFIER97_tree = null;
5822         RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
5823                 adaptor, "token IDENTIFIER");
5824
5825         enter("variantName");
5826
5827         try {
5828             // Grammar/CTFParser.g:611:1: ( IDENTIFIER -> ^( VARIANT_NAME
5829             // IDENTIFIER ) )
5830             // Grammar/CTFParser.g:612:3: IDENTIFIER
5831             {
5832                 IDENTIFIER97 = (Token) match(input, IDENTIFIER,
5833                         FOLLOW_IDENTIFIER_in_variantName2120);
5834                 if (state.failed) {
5835                     return retval;
5836                 }
5837                 if (state.backtracking == 0) {
5838                     stream_IDENTIFIER.add(IDENTIFIER97);
5839                 }
5840
5841                 // AST REWRITE
5842                 // elements: IDENTIFIER
5843                 // token labels:
5844                 // rule labels: retval
5845                 // token list labels:
5846                 // rule list labels:
5847                 // wildcard labels:
5848                 if (state.backtracking == 0) {
5849                     retval.tree = root_0;
5850 //                    RewriteRuleSubtreeStream stream_retval =
5851                             new RewriteRuleSubtreeStream(
5852                             adaptor, "rule retval",
5853                             retval != null ? retval.tree : null);
5854
5855                     root_0 = (CommonTree) adaptor.nil();
5856                     // 612:14: -> ^( VARIANT_NAME IDENTIFIER )
5857                     {
5858                         // Grammar/CTFParser.g:612:17: ^( VARIANT_NAME
5859                         // IDENTIFIER )
5860                         {
5861                             CommonTree root_1 = (CommonTree) adaptor.nil();
5862                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
5863                                     .create(VARIANT_NAME, "VARIANT_NAME"),
5864                                     root_1);
5865
5866                             adaptor.addChild(root_1,
5867                                     stream_IDENTIFIER.nextNode());
5868
5869                             adaptor.addChild(root_0, root_1);
5870                         }
5871
5872                     }
5873
5874                     retval.tree = root_0;
5875                 }
5876             }
5877
5878             retval.stop = input.LT(-1);
5879
5880             if (state.backtracking == 0) {
5881
5882                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
5883                 adaptor.setTokenBoundaries(retval.tree, retval.start,
5884                         retval.stop);
5885             }
5886             if (state.backtracking == 0) {
5887
5888                 debug_print(input.toString(retval.start, input.LT(-1)));
5889                 exit("variantName");
5890
5891             }
5892         }
5893
5894         catch (RecognitionException e) {
5895             throw e;
5896         }
5897         return retval;
5898     }
5899
5900     // $ANTLR end "variantName"
5901
5902     public static class variantBody_return extends ParserRuleReturnScope {
5903         CommonTree tree;
5904
5905         @Override
5906         public Object getTree() {
5907             return tree;
5908         }
5909     }
5910
5911     // $ANTLR start "variantBody"
5912     // Grammar/CTFParser.g:615:1: variantBody : LCURL
5913     // structOrVariantDeclarationList RCURL -> ^( VARIANT_BODY
5914     // structOrVariantDeclarationList ) ;
5915     public final CTFParser.variantBody_return variantBody()
5916             throws RecognitionException {
5917         Symbols_stack.push(new Symbols_scope());
5918
5919         CTFParser.variantBody_return retval = new CTFParser.variantBody_return();
5920         retval.start = input.LT(1);
5921
5922         CommonTree root_0 = null;
5923
5924         Token LCURL98 = null;
5925         Token RCURL100 = null;
5926         CTFParser.structOrVariantDeclarationList_return structOrVariantDeclarationList99 = null;
5927
5928         CommonTree LCURL98_tree = null;
5929         CommonTree RCURL100_tree = null;
5930         RewriteRuleTokenStream stream_LCURL = new RewriteRuleTokenStream(
5931                 adaptor, "token LCURL");
5932         RewriteRuleTokenStream stream_RCURL = new RewriteRuleTokenStream(
5933                 adaptor, "token RCURL");
5934         RewriteRuleSubtreeStream stream_structOrVariantDeclarationList = new RewriteRuleSubtreeStream(
5935                 adaptor, "rule structOrVariantDeclarationList");
5936
5937         enter("variantBody");
5938         debug_print("Scope push " + Symbols_stack.size());
5939         ((Symbols_scope) Symbols_stack.peek()).types = new HashSet<String>();
5940
5941         try {
5942             // Grammar/CTFParser.g:626:1: ( LCURL structOrVariantDeclarationList
5943             // RCURL -> ^( VARIANT_BODY structOrVariantDeclarationList ) )
5944             // Grammar/CTFParser.g:627:3: LCURL structOrVariantDeclarationList
5945             // RCURL
5946             {
5947                 LCURL98 = (Token) match(input, LCURL,
5948                         FOLLOW_LCURL_in_variantBody2156);
5949                 if (state.failed) {
5950                     return retval;
5951                 }
5952                 if (state.backtracking == 0) {
5953                     stream_LCURL.add(LCURL98);
5954                 }
5955
5956                 pushFollow(FOLLOW_structOrVariantDeclarationList_in_variantBody2158);
5957                 structOrVariantDeclarationList99 = structOrVariantDeclarationList();
5958
5959                 state._fsp--;
5960                 if (state.failed) {
5961                     return retval;
5962                 }
5963                 if (state.backtracking == 0) {
5964                     stream_structOrVariantDeclarationList
5965                             .add(structOrVariantDeclarationList99.getTree());
5966                 }
5967                 RCURL100 = (Token) match(input, RCURL,
5968                         FOLLOW_RCURL_in_variantBody2160);
5969                 if (state.failed) {
5970                     return retval;
5971                 }
5972                 if (state.backtracking == 0) {
5973                     stream_RCURL.add(RCURL100);
5974                 }
5975
5976                 // AST REWRITE
5977                 // elements: structOrVariantDeclarationList
5978                 // token labels:
5979                 // rule labels: retval
5980                 // token list labels:
5981                 // rule list labels:
5982                 // wildcard labels:
5983                 if (state.backtracking == 0) {
5984                     retval.tree = root_0;
5985 //                    RewriteRuleSubtreeStream stream_retval =
5986                             new RewriteRuleSubtreeStream(
5987                             adaptor, "rule retval",
5988                             retval != null ? retval.tree : null);
5989
5990                     root_0 = (CommonTree) adaptor.nil();
5991                     // 627:46: -> ^( VARIANT_BODY structOrVariantDeclarationList
5992                     // )
5993                     {
5994                         // Grammar/CTFParser.g:627:49: ^( VARIANT_BODY
5995                         // structOrVariantDeclarationList )
5996                         {
5997                             CommonTree root_1 = (CommonTree) adaptor.nil();
5998                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
5999                                     .create(VARIANT_BODY, "VARIANT_BODY"),
6000                                     root_1);
6001
6002                             adaptor.addChild(root_1,
6003                                     stream_structOrVariantDeclarationList
6004                                             .nextTree());
6005
6006                             adaptor.addChild(root_0, root_1);
6007                         }
6008
6009                     }
6010
6011                     retval.tree = root_0;
6012                 }
6013             }
6014
6015             retval.stop = input.LT(-1);
6016
6017             if (state.backtracking == 0) {
6018
6019                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
6020                 adaptor.setTokenBoundaries(retval.tree, retval.start,
6021                         retval.stop);
6022             }
6023             if (state.backtracking == 0) {
6024
6025                 debug_print("Scope pop " + Symbols_stack.size());
6026                 exit("variantBody");
6027
6028             }
6029         }
6030
6031         catch (RecognitionException e) {
6032             throw e;
6033         } finally {
6034             Symbols_stack.pop();
6035
6036         }
6037         return retval;
6038     }
6039
6040     // $ANTLR end "variantBody"
6041
6042     public static class variantTag_return extends ParserRuleReturnScope {
6043         CommonTree tree;
6044
6045         @Override
6046         public Object getTree() {
6047             return tree;
6048         }
6049     }
6050
6051     // $ANTLR start "variantTag"
6052     // Grammar/CTFParser.g:630:1: variantTag : LT IDENTIFIER GT -> ^(
6053     // VARIANT_TAG IDENTIFIER ) ;
6054     public final CTFParser.variantTag_return variantTag()
6055             throws RecognitionException {
6056         CTFParser.variantTag_return retval = new CTFParser.variantTag_return();
6057         retval.start = input.LT(1);
6058
6059         CommonTree root_0 = null;
6060
6061         Token LT101 = null;
6062         Token IDENTIFIER102 = null;
6063         Token GT103 = null;
6064
6065         CommonTree LT101_tree = null;
6066         CommonTree IDENTIFIER102_tree = null;
6067         CommonTree GT103_tree = null;
6068         RewriteRuleTokenStream stream_GT = new RewriteRuleTokenStream(adaptor,
6069                 "token GT");
6070         RewriteRuleTokenStream stream_LT = new RewriteRuleTokenStream(adaptor,
6071                 "token LT");
6072         RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
6073                 adaptor, "token IDENTIFIER");
6074
6075         enter("variantTag");
6076
6077         try {
6078             // Grammar/CTFParser.g:638:1: ( LT IDENTIFIER GT -> ^( VARIANT_TAG
6079             // IDENTIFIER ) )
6080             // Grammar/CTFParser.g:639:3: LT IDENTIFIER GT
6081             {
6082                 LT101 = (Token) match(input, LT, FOLLOW_LT_in_variantTag2191);
6083                 if (state.failed) {
6084                     return retval;
6085                 }
6086                 if (state.backtracking == 0) {
6087                     stream_LT.add(LT101);
6088                 }
6089
6090                 IDENTIFIER102 = (Token) match(input, IDENTIFIER,
6091                         FOLLOW_IDENTIFIER_in_variantTag2193);
6092                 if (state.failed) {
6093                     return retval;
6094                 }
6095                 if (state.backtracking == 0) {
6096                     stream_IDENTIFIER.add(IDENTIFIER102);
6097                 }
6098
6099                 GT103 = (Token) match(input, GT, FOLLOW_GT_in_variantTag2195);
6100                 if (state.failed) {
6101                     return retval;
6102                 }
6103                 if (state.backtracking == 0) {
6104                     stream_GT.add(GT103);
6105                 }
6106
6107                 // AST REWRITE
6108                 // elements: IDENTIFIER
6109                 // token labels:
6110                 // rule labels: retval
6111                 // token list labels:
6112                 // rule list labels:
6113                 // wildcard labels:
6114                 if (state.backtracking == 0) {
6115                     retval.tree = root_0;
6116 //                    RewriteRuleSubtreeStream stream_retval =
6117                             new RewriteRuleSubtreeStream(
6118                             adaptor, "rule retval",
6119                             retval != null ? retval.tree : null);
6120
6121                     root_0 = (CommonTree) adaptor.nil();
6122                     // 639:20: -> ^( VARIANT_TAG IDENTIFIER )
6123                     {
6124                         // Grammar/CTFParser.g:639:23: ^( VARIANT_TAG IDENTIFIER
6125                         // )
6126                         {
6127                             CommonTree root_1 = (CommonTree) adaptor.nil();
6128                             root_1 = (CommonTree) adaptor.becomeRoot(
6129                                     adaptor.create(VARIANT_TAG, "VARIANT_TAG"),
6130                                     root_1);
6131
6132                             adaptor.addChild(root_1,
6133                                     stream_IDENTIFIER.nextNode());
6134
6135                             adaptor.addChild(root_0, root_1);
6136                         }
6137
6138                     }
6139
6140                     retval.tree = root_0;
6141                 }
6142             }
6143
6144             retval.stop = input.LT(-1);
6145
6146             if (state.backtracking == 0) {
6147
6148                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
6149                 adaptor.setTokenBoundaries(retval.tree, retval.start,
6150                         retval.stop);
6151             }
6152             if (state.backtracking == 0) {
6153
6154                 debug_print(input.toString(retval.start, input.LT(-1)));
6155                 exit("variantTag");
6156
6157             }
6158         }
6159
6160         catch (RecognitionException e) {
6161             throw e;
6162
6163         }
6164         return retval;
6165     }
6166
6167     // $ANTLR end "variantTag"
6168
6169     public static class enumSpecifier_return extends ParserRuleReturnScope {
6170         CommonTree tree;
6171
6172         @Override
6173         public Object getTree() {
6174             return tree;
6175         }
6176     }
6177
6178     // $ANTLR start "enumSpecifier"
6179     // Grammar/CTFParser.g:642:1: enumSpecifier : ENUMTOK ( ( enumName (
6180     // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
6181     // enumBody | enumBody ) ) -> ^( ENUM ( enumName )? ( enumContainerType )? (
6182     // enumBody )? ) ;
6183     public final CTFParser.enumSpecifier_return enumSpecifier()
6184             throws RecognitionException {
6185         CTFParser.enumSpecifier_return retval = new CTFParser.enumSpecifier_return();
6186         retval.start = input.LT(1);
6187
6188         CommonTree root_0 = null;
6189
6190         Token ENUMTOK104 = null;
6191         CTFParser.enumName_return enumName105 = null;
6192
6193         CTFParser.enumContainerType_return enumContainerType106 = null;
6194
6195         CTFParser.enumBody_return enumBody107 = null;
6196
6197         CTFParser.enumBody_return enumBody108 = null;
6198
6199         CTFParser.enumContainerType_return enumContainerType109 = null;
6200
6201         CTFParser.enumBody_return enumBody110 = null;
6202
6203         CTFParser.enumBody_return enumBody111 = null;
6204
6205         CommonTree ENUMTOK104_tree = null;
6206         RewriteRuleTokenStream stream_ENUMTOK = new RewriteRuleTokenStream(
6207                 adaptor, "token ENUMTOK");
6208         RewriteRuleSubtreeStream stream_enumName = new RewriteRuleSubtreeStream(
6209                 adaptor, "rule enumName");
6210         RewriteRuleSubtreeStream stream_enumContainerType = new RewriteRuleSubtreeStream(
6211                 adaptor, "rule enumContainerType");
6212         RewriteRuleSubtreeStream stream_enumBody = new RewriteRuleSubtreeStream(
6213                 adaptor, "rule enumBody");
6214
6215         enter("enumSpecifier");
6216
6217         try {
6218             // Grammar/CTFParser.g:649:1: ( ENUMTOK ( ( enumName (
6219             // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
6220             // enumBody | enumBody ) ) -> ^( ENUM ( enumName )? (
6221             // enumContainerType )? ( enumBody )? ) )
6222             // Grammar/CTFParser.g:650:2: ENUMTOK ( ( enumName (
6223             // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
6224             // enumBody | enumBody ) )
6225             {
6226                 ENUMTOK104 = (Token) match(input, ENUMTOK,
6227                         FOLLOW_ENUMTOK_in_enumSpecifier2225);
6228                 if (state.failed) {
6229                     return retval;
6230                 }
6231                 if (state.backtracking == 0) {
6232                     stream_ENUMTOK.add(ENUMTOK104);
6233                 }
6234
6235                 // Grammar/CTFParser.g:651:2: ( ( enumName ( enumContainerType
6236                 // enumBody | enumBody | ) ) | ( enumContainerType enumBody |
6237                 // enumBody ) )
6238                 int alt34 = 2;
6239                 int LA34_0 = input.LA(1);
6240
6241                 if ((LA34_0 == IDENTIFIER)) {
6242                     alt34 = 1;
6243                 } else if (((LA34_0 == COLON) || (LA34_0 == LCURL))) {
6244                     alt34 = 2;
6245                 } else {
6246                     if (state.backtracking > 0) {
6247                         state.failed = true;
6248                         return retval;
6249                     }
6250                     NoViableAltException nvae = new NoViableAltException("",
6251                             34, 0, input);
6252
6253                     throw nvae;
6254                 }
6255                 switch (alt34) {
6256                 case 1:
6257                 // Grammar/CTFParser.g:653:3: ( enumName ( enumContainerType
6258                 // enumBody | enumBody | ) )
6259                 {
6260                     // Grammar/CTFParser.g:653:3: ( enumName ( enumContainerType
6261                     // enumBody | enumBody | ) )
6262                     // Grammar/CTFParser.g:654:4: enumName ( enumContainerType
6263                     // enumBody | enumBody | )
6264                     {
6265                         pushFollow(FOLLOW_enumName_in_enumSpecifier2240);
6266                         enumName105 = enumName();
6267
6268                         state._fsp--;
6269                         if (state.failed) {
6270                             return retval;
6271                         }
6272                         if (state.backtracking == 0) {
6273                             stream_enumName.add(enumName105.getTree());
6274                         }
6275                         // Grammar/CTFParser.g:655:4: ( enumContainerType
6276                         // enumBody | enumBody | )
6277                         int alt32 = 3;
6278                         alt32 = dfa32.predict(input);
6279                         switch (alt32) {
6280                         case 1:
6281                         // Grammar/CTFParser.g:656:5: enumContainerType enumBody
6282                         {
6283                             pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2251);
6284                             enumContainerType106 = enumContainerType();
6285
6286                             state._fsp--;
6287                             if (state.failed) {
6288                                 return retval;
6289                             }
6290                             if (state.backtracking == 0) {
6291                                 stream_enumContainerType
6292                                         .add(enumContainerType106.getTree());
6293                             }
6294                             pushFollow(FOLLOW_enumBody_in_enumSpecifier2253);
6295                             enumBody107 = enumBody();
6296
6297                             state._fsp--;
6298                             if (state.failed) {
6299                                 return retval;
6300                             }
6301                             if (state.backtracking == 0) {
6302                                 stream_enumBody.add(enumBody107.getTree());
6303                             }
6304
6305                         }
6306                             break;
6307                         case 2:
6308                         // Grammar/CTFParser.g:658:5: enumBody
6309                         {
6310                             pushFollow(FOLLOW_enumBody_in_enumSpecifier2265);
6311                             enumBody108 = enumBody();
6312
6313                             state._fsp--;
6314                             if (state.failed) {
6315                                 return retval;
6316                             }
6317                             if (state.backtracking == 0) {
6318                                 stream_enumBody.add(enumBody108.getTree());
6319                             }
6320
6321                         }
6322                             break;
6323                         case 3:
6324                             break;
6325                         }
6326                     }
6327                 }
6328                     break;
6329                 case 2:
6330                 // Grammar/CTFParser.g:665:3: ( enumContainerType enumBody |
6331                 // enumBody )
6332                 {
6333                     // Grammar/CTFParser.g:665:3: ( enumContainerType enumBody |
6334                     // enumBody )
6335                     int alt33 = 2;
6336                     int LA33_0 = input.LA(1);
6337
6338                     if ((LA33_0 == COLON)) {
6339                         alt33 = 1;
6340                     } else if ((LA33_0 == LCURL)) {
6341                         alt33 = 2;
6342                     } else {
6343                         if (state.backtracking > 0) {
6344                             state.failed = true;
6345                             return retval;
6346                         }
6347                         NoViableAltException nvae = new NoViableAltException(
6348                                 "", 33, 0, input);
6349
6350                         throw nvae;
6351                     }
6352                     switch (alt33) {
6353                     case 1:
6354                     // Grammar/CTFParser.g:666:4: enumContainerType enumBody
6355                     {
6356                         pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2300);
6357                         enumContainerType109 = enumContainerType();
6358
6359                         state._fsp--;
6360                         if (state.failed) {
6361                             return retval;
6362                         }
6363                         if (state.backtracking == 0) {
6364                             stream_enumContainerType.add(enumContainerType109
6365                                     .getTree());
6366                         }
6367                         pushFollow(FOLLOW_enumBody_in_enumSpecifier2302);
6368                         enumBody110 = enumBody();
6369
6370                         state._fsp--;
6371                         if (state.failed) {
6372                             return retval;
6373                         }
6374                         if (state.backtracking == 0) {
6375                             stream_enumBody.add(enumBody110.getTree());
6376                         }
6377
6378                     }
6379                         break;
6380                     case 2:
6381                     // Grammar/CTFParser.g:668:4: enumBody
6382                     {
6383                         pushFollow(FOLLOW_enumBody_in_enumSpecifier2311);
6384                         enumBody111 = enumBody();
6385
6386                         state._fsp--;
6387                         if (state.failed) {
6388                             return retval;
6389                         }
6390                         if (state.backtracking == 0) {
6391                             stream_enumBody.add(enumBody111.getTree());
6392                         }
6393
6394                     }
6395                         break;
6396
6397                     }
6398
6399                 }
6400                     break;
6401
6402                 }
6403
6404                 // AST REWRITE
6405                 // elements: enumContainerType, enumName, enumBody
6406                 // token labels:
6407                 // rule labels: retval
6408                 // token list labels:
6409                 // rule list labels:
6410                 // wildcard labels:
6411                 if (state.backtracking == 0) {
6412                     retval.tree = root_0;
6413 //                    RewriteRuleSubtreeStream stream_retval =
6414                             new RewriteRuleSubtreeStream(
6415                             adaptor, "rule retval",
6416                             retval != null ? retval.tree : null);
6417
6418                     root_0 = (CommonTree) adaptor.nil();
6419                     // 670:4: -> ^( ENUM ( enumName )? ( enumContainerType )? (
6420                     // enumBody )? )
6421                     {
6422                         // Grammar/CTFParser.g:670:7: ^( ENUM ( enumName )? (
6423                         // enumContainerType )? ( enumBody )? )
6424                         {
6425                             CommonTree root_1 = (CommonTree) adaptor.nil();
6426                             root_1 = (CommonTree) adaptor.becomeRoot(
6427                                     adaptor.create(ENUM, "ENUM"), root_1);
6428
6429                             // Grammar/CTFParser.g:670:14: ( enumName )?
6430                             if (stream_enumName.hasNext()) {
6431                                 adaptor.addChild(root_1,
6432                                         stream_enumName.nextTree());
6433
6434                             }
6435                             stream_enumName.reset();
6436                             // Grammar/CTFParser.g:670:24: ( enumContainerType
6437                             // )?
6438                             if (stream_enumContainerType.hasNext()) {
6439                                 adaptor.addChild(root_1,
6440                                         stream_enumContainerType.nextTree());
6441
6442                             }
6443                             stream_enumContainerType.reset();
6444                             // Grammar/CTFParser.g:670:43: ( enumBody )?
6445                             if (stream_enumBody.hasNext()) {
6446                                 adaptor.addChild(root_1,
6447                                         stream_enumBody.nextTree());
6448
6449                             }
6450                             stream_enumBody.reset();
6451
6452                             adaptor.addChild(root_0, root_1);
6453                         }
6454
6455                     }
6456
6457                     retval.tree = root_0;
6458                 }
6459             }
6460
6461             retval.stop = input.LT(-1);
6462
6463             if (state.backtracking == 0) {
6464
6465                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
6466                 adaptor.setTokenBoundaries(retval.tree, retval.start,
6467                         retval.stop);
6468             }
6469             if (state.backtracking == 0) {
6470
6471                 exit("enumSpecifier");
6472
6473             }
6474         }
6475
6476         catch (RecognitionException e) {
6477             throw e;
6478
6479         }
6480         return retval;
6481     }
6482
6483     // $ANTLR end "enumSpecifier"
6484
6485     public static class enumName_return extends ParserRuleReturnScope {
6486         CommonTree tree;
6487
6488         @Override
6489         public Object getTree() {
6490             return tree;
6491         }
6492     }
6493
6494     // $ANTLR start "enumName"
6495     // Grammar/CTFParser.g:673:1: enumName : IDENTIFIER -> ^( ENUM_NAME
6496     // IDENTIFIER ) ;
6497     public final CTFParser.enumName_return enumName()
6498             throws RecognitionException {
6499         CTFParser.enumName_return retval = new CTFParser.enumName_return();
6500         retval.start = input.LT(1);
6501
6502         CommonTree root_0 = null;
6503
6504         Token IDENTIFIER112 = null;
6505
6506         CommonTree IDENTIFIER112_tree = null;
6507         RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
6508                 adaptor, "token IDENTIFIER");
6509
6510         enter("enumName");
6511
6512         try {
6513             // Grammar/CTFParser.g:681:1: ( IDENTIFIER -> ^( ENUM_NAME
6514             // IDENTIFIER ) )
6515             // Grammar/CTFParser.g:682:3: IDENTIFIER
6516             {
6517                 IDENTIFIER112 = (Token) match(input, IDENTIFIER,
6518                         FOLLOW_IDENTIFIER_in_enumName2356);
6519                 if (state.failed) {
6520                     return retval;
6521                 }
6522                 if (state.backtracking == 0) {
6523                     stream_IDENTIFIER.add(IDENTIFIER112);
6524                 }
6525
6526                 // AST REWRITE
6527                 // elements: IDENTIFIER
6528                 // token labels:
6529                 // rule labels: retval
6530                 // token list labels:
6531                 // rule list labels:
6532                 // wildcard labels:
6533                 if (state.backtracking == 0) {
6534                     retval.tree = root_0;
6535 //                    RewriteRuleSubtreeStream stream_retval =
6536                             new RewriteRuleSubtreeStream(
6537                             adaptor, "rule retval",
6538                             retval != null ? retval.tree : null);
6539
6540                     root_0 = (CommonTree) adaptor.nil();
6541                     // 682:14: -> ^( ENUM_NAME IDENTIFIER )
6542                     {
6543                         // Grammar/CTFParser.g:682:17: ^( ENUM_NAME IDENTIFIER )
6544                         {
6545                             CommonTree root_1 = (CommonTree) adaptor.nil();
6546                             root_1 = (CommonTree) adaptor.becomeRoot(
6547                                     adaptor.create(ENUM_NAME, "ENUM_NAME"),
6548                                     root_1);
6549
6550                             adaptor.addChild(root_1,
6551                                     stream_IDENTIFIER.nextNode());
6552
6553                             adaptor.addChild(root_0, root_1);
6554                         }
6555
6556                     }
6557
6558                     retval.tree = root_0;
6559                 }
6560             }
6561
6562             retval.stop = input.LT(-1);
6563
6564             if (state.backtracking == 0) {
6565
6566                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
6567                 adaptor.setTokenBoundaries(retval.tree, retval.start,
6568                         retval.stop);
6569             }
6570             if (state.backtracking == 0) {
6571
6572                 debug_print(input.toString(retval.start, input.LT(-1)));
6573                 exit("enumName");
6574
6575             }
6576         }
6577
6578         catch (RecognitionException e) {
6579             throw e;
6580
6581         }
6582         return retval;
6583     }
6584
6585     // $ANTLR end "enumName"
6586
6587     public static class enumBody_return extends ParserRuleReturnScope {
6588         CommonTree tree;
6589
6590         @Override
6591         public Object getTree() {
6592             return tree;
6593         }
6594     }
6595
6596     // $ANTLR start "enumBody"
6597     // Grammar/CTFParser.g:685:1: enumBody : LCURL enumeratorList ( SEPARATOR
6598     // RCURL | RCURL ) -> ^( ENUM_BODY enumeratorList ) ;
6599     public final CTFParser.enumBody_return enumBody()
6600             throws RecognitionException {
6601         CTFParser.enumBody_return retval = new CTFParser.enumBody_return();
6602         retval.start = input.LT(1);
6603
6604         CommonTree root_0 = null;
6605
6606         Token LCURL113 = null;
6607         Token SEPARATOR115 = null;
6608         Token RCURL116 = null;
6609         Token RCURL117 = null;
6610         CTFParser.enumeratorList_return enumeratorList114 = null;
6611
6612         CommonTree LCURL113_tree = null;
6613         CommonTree SEPARATOR115_tree = null;
6614         CommonTree RCURL116_tree = null;
6615         CommonTree RCURL117_tree = null;
6616         RewriteRuleTokenStream stream_LCURL = new RewriteRuleTokenStream(
6617                 adaptor, "token LCURL");
6618         RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
6619                 adaptor, "token SEPARATOR");
6620         RewriteRuleTokenStream stream_RCURL = new RewriteRuleTokenStream(
6621                 adaptor, "token RCURL");
6622         RewriteRuleSubtreeStream stream_enumeratorList = new RewriteRuleSubtreeStream(
6623                 adaptor, "rule enumeratorList");
6624
6625         enter("enumBody");
6626
6627         try {
6628             // Grammar/CTFParser.g:692:1: ( LCURL enumeratorList ( SEPARATOR
6629             // RCURL | RCURL ) -> ^( ENUM_BODY enumeratorList ) )
6630             // Grammar/CTFParser.g:693:3: LCURL enumeratorList ( SEPARATOR RCURL
6631             // | RCURL )
6632             {
6633                 LCURL113 = (Token) match(input, LCURL,
6634                         FOLLOW_LCURL_in_enumBody2389);
6635                 if (state.failed) {
6636                     return retval;
6637                 }
6638                 if (state.backtracking == 0) {
6639                     stream_LCURL.add(LCURL113);
6640                 }
6641
6642                 pushFollow(FOLLOW_enumeratorList_in_enumBody2391);
6643                 enumeratorList114 = enumeratorList();
6644
6645                 state._fsp--;
6646                 if (state.failed) {
6647                     return retval;
6648                 }
6649                 if (state.backtracking == 0) {
6650                     stream_enumeratorList.add(enumeratorList114.getTree());
6651                 }
6652                 // Grammar/CTFParser.g:693:24: ( SEPARATOR RCURL | RCURL )
6653                 int alt35 = 2;
6654                 int LA35_0 = input.LA(1);
6655
6656                 if ((LA35_0 == SEPARATOR)) {
6657                     alt35 = 1;
6658                 } else if ((LA35_0 == RCURL)) {
6659                     alt35 = 2;
6660                 } else {
6661                     if (state.backtracking > 0) {
6662                         state.failed = true;
6663                         return retval;
6664                     }
6665                     NoViableAltException nvae = new NoViableAltException("",
6666                             35, 0, input);
6667
6668                     throw nvae;
6669                 }
6670                 switch (alt35) {
6671                 case 1:
6672                 // Grammar/CTFParser.g:693:25: SEPARATOR RCURL
6673                 {
6674                     SEPARATOR115 = (Token) match(input, SEPARATOR,
6675                             FOLLOW_SEPARATOR_in_enumBody2394);
6676                     if (state.failed) {
6677                         return retval;
6678                     }
6679                     if (state.backtracking == 0) {
6680                         stream_SEPARATOR.add(SEPARATOR115);
6681                     }
6682
6683                     RCURL116 = (Token) match(input, RCURL,
6684                             FOLLOW_RCURL_in_enumBody2396);
6685                     if (state.failed) {
6686                         return retval;
6687                     }
6688                     if (state.backtracking == 0) {
6689                         stream_RCURL.add(RCURL116);
6690                     }
6691
6692                 }
6693                     break;
6694                 case 2:
6695                 // Grammar/CTFParser.g:693:43: RCURL
6696                 {
6697                     RCURL117 = (Token) match(input, RCURL,
6698                             FOLLOW_RCURL_in_enumBody2400);
6699                     if (state.failed) {
6700                         return retval;
6701                     }
6702                     if (state.backtracking == 0) {
6703                         stream_RCURL.add(RCURL117);
6704                     }
6705
6706                 }
6707                     break;
6708
6709                 }
6710
6711                 // AST REWRITE
6712                 // elements: enumeratorList
6713                 // token labels:
6714                 // rule labels: retval
6715                 // token list labels:
6716                 // rule list labels:
6717                 // wildcard labels:
6718                 if (state.backtracking == 0) {
6719                     retval.tree = root_0;
6720 //                    RewriteRuleSubtreeStream stream_retval =
6721                             new RewriteRuleSubtreeStream(
6722                             adaptor, "rule retval",
6723                             retval != null ? retval.tree : null);
6724
6725                     root_0 = (CommonTree) adaptor.nil();
6726                     // 693:50: -> ^( ENUM_BODY enumeratorList )
6727                     {
6728                         // Grammar/CTFParser.g:693:53: ^( ENUM_BODY
6729                         // enumeratorList )
6730                         {
6731                             CommonTree root_1 = (CommonTree) adaptor.nil();
6732                             root_1 = (CommonTree) adaptor.becomeRoot(
6733                                     adaptor.create(ENUM_BODY, "ENUM_BODY"),
6734                                     root_1);
6735
6736                             adaptor.addChild(root_1,
6737                                     stream_enumeratorList.nextTree());
6738
6739                             adaptor.addChild(root_0, root_1);
6740                         }
6741
6742                     }
6743
6744                     retval.tree = root_0;
6745                 }
6746             }
6747
6748             retval.stop = input.LT(-1);
6749
6750             if (state.backtracking == 0) {
6751
6752                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
6753                 adaptor.setTokenBoundaries(retval.tree, retval.start,
6754                         retval.stop);
6755             }
6756             if (state.backtracking == 0) {
6757
6758                 exit("enumBody");
6759
6760             }
6761         }
6762
6763         catch (RecognitionException e) {
6764             throw e;
6765
6766         }
6767         return retval;
6768     }
6769
6770     // $ANTLR end "enumBody"
6771
6772     public static class enumContainerType_return extends ParserRuleReturnScope {
6773         CommonTree tree;
6774
6775         @Override
6776         public Object getTree() {
6777             return tree;
6778         }
6779     }
6780
6781     // $ANTLR start "enumContainerType"
6782     // Grammar/CTFParser.g:696:1: enumContainerType : COLON
6783     // declarationSpecifiers -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers ) ;
6784     public final CTFParser.enumContainerType_return enumContainerType()
6785             throws RecognitionException {
6786         CTFParser.enumContainerType_return retval = new CTFParser.enumContainerType_return();
6787         retval.start = input.LT(1);
6788
6789         CommonTree root_0 = null;
6790
6791         Token COLON118 = null;
6792         CTFParser.declarationSpecifiers_return declarationSpecifiers119 = null;
6793
6794         CommonTree COLON118_tree = null;
6795         RewriteRuleTokenStream stream_COLON = new RewriteRuleTokenStream(
6796                 adaptor, "token COLON");
6797         RewriteRuleSubtreeStream stream_declarationSpecifiers = new RewriteRuleSubtreeStream(
6798                 adaptor, "rule declarationSpecifiers");
6799
6800         enter("enumContainerType");
6801
6802         try {
6803             // Grammar/CTFParser.g:703:1: ( COLON declarationSpecifiers -> ^(
6804             // ENUM_CONTAINER_TYPE declarationSpecifiers ) )
6805             // Grammar/CTFParser.g:704:3: COLON declarationSpecifiers
6806             {
6807                 COLON118 = (Token) match(input, COLON,
6808                         FOLLOW_COLON_in_enumContainerType2432);
6809                 if (state.failed) {
6810                     return retval;
6811                 }
6812                 if (state.backtracking == 0) {
6813                     stream_COLON.add(COLON118);
6814                 }
6815
6816                 pushFollow(FOLLOW_declarationSpecifiers_in_enumContainerType2434);
6817                 declarationSpecifiers119 = declarationSpecifiers();
6818
6819                 state._fsp--;
6820                 if (state.failed) {
6821                     return retval;
6822                 }
6823                 if (state.backtracking == 0) {
6824                     stream_declarationSpecifiers.add(declarationSpecifiers119
6825                             .getTree());
6826                 }
6827
6828                 // AST REWRITE
6829                 // elements: declarationSpecifiers
6830                 // token labels:
6831                 // rule labels: retval
6832                 // token list labels:
6833                 // rule list labels:
6834                 // wildcard labels:
6835                 if (state.backtracking == 0) {
6836                     retval.tree = root_0;
6837 //                    RewriteRuleSubtreeStream stream_retval =
6838                             new RewriteRuleSubtreeStream(
6839                             adaptor, "rule retval",
6840                             retval != null ? retval.tree : null);
6841
6842                     root_0 = (CommonTree) adaptor.nil();
6843                     // 704:31: -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
6844                     {
6845                         // Grammar/CTFParser.g:704:34: ^( ENUM_CONTAINER_TYPE
6846                         // declarationSpecifiers )
6847                         {
6848                             CommonTree root_1 = (CommonTree) adaptor.nil();
6849                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
6850                                     .create(ENUM_CONTAINER_TYPE,
6851                                             "ENUM_CONTAINER_TYPE"), root_1);
6852
6853                             adaptor.addChild(root_1,
6854                                     stream_declarationSpecifiers.nextTree());
6855
6856                             adaptor.addChild(root_0, root_1);
6857                         }
6858
6859                     }
6860
6861                     retval.tree = root_0;
6862                 }
6863             }
6864
6865             retval.stop = input.LT(-1);
6866
6867             if (state.backtracking == 0) {
6868
6869                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
6870                 adaptor.setTokenBoundaries(retval.tree, retval.start,
6871                         retval.stop);
6872             }
6873             if (state.backtracking == 0) {
6874
6875                 exit("enumContainerType");
6876
6877             }
6878         }
6879
6880         catch (RecognitionException e) {
6881             throw e;
6882         }
6883         return retval;
6884     }
6885
6886     // $ANTLR end "enumContainerType"
6887
6888     public static class enumeratorList_return extends ParserRuleReturnScope {
6889         CommonTree tree;
6890
6891         @Override
6892         public Object getTree() {
6893             return tree;
6894         }
6895     }
6896
6897     // $ANTLR start "enumeratorList"
6898     // Grammar/CTFParser.g:707:1: enumeratorList : enumerator ( SEPARATOR
6899     // enumerator )* -> ( ^( ENUM_ENUMERATOR enumerator ) )+ ;
6900     public final CTFParser.enumeratorList_return enumeratorList()
6901             throws RecognitionException {
6902         CTFParser.enumeratorList_return retval = new CTFParser.enumeratorList_return();
6903         retval.start = input.LT(1);
6904
6905         CommonTree root_0 = null;
6906
6907         Token SEPARATOR121 = null;
6908         CTFParser.enumerator_return enumerator120 = null;
6909
6910         CTFParser.enumerator_return enumerator122 = null;
6911
6912         CommonTree SEPARATOR121_tree = null;
6913         RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
6914                 adaptor, "token SEPARATOR");
6915         RewriteRuleSubtreeStream stream_enumerator = new RewriteRuleSubtreeStream(
6916                 adaptor, "rule enumerator");
6917
6918         enter("enumeratorList");
6919
6920         try {
6921             // Grammar/CTFParser.g:714:1: ( enumerator ( SEPARATOR enumerator )*
6922             // -> ( ^( ENUM_ENUMERATOR enumerator ) )+ )
6923             // Grammar/CTFParser.g:715:3: enumerator ( SEPARATOR enumerator )*
6924             {
6925                 pushFollow(FOLLOW_enumerator_in_enumeratorList2465);
6926                 enumerator120 = enumerator();
6927
6928                 state._fsp--;
6929                 if (state.failed) {
6930                     return retval;
6931                 }
6932                 if (state.backtracking == 0) {
6933                     stream_enumerator.add(enumerator120.getTree());
6934                 }
6935                 // Grammar/CTFParser.g:715:14: ( SEPARATOR enumerator )*
6936                 loop36: do {
6937                     int alt36 = 2;
6938                     int LA36_0 = input.LA(1);
6939
6940                     if ((LA36_0 == SEPARATOR)) {
6941                         int LA36_1 = input.LA(2);
6942
6943                         if (((LA36_1 == ALIGNTOK) || (LA36_1 == EVENTTOK)
6944                                 || (LA36_1 == SIGNEDTOK)
6945                                 || (LA36_1 == STRINGTOK)
6946                                 || (LA36_1 == STRING_LITERAL) || (LA36_1 == IDENTIFIER))) {
6947                             alt36 = 1;
6948                         }
6949
6950                     }
6951
6952                     switch (alt36) {
6953                     case 1:
6954                     // Grammar/CTFParser.g:715:15: SEPARATOR enumerator
6955                     {
6956                         SEPARATOR121 = (Token) match(input, SEPARATOR,
6957                                 FOLLOW_SEPARATOR_in_enumeratorList2468);
6958                         if (state.failed) {
6959                             return retval;
6960                         }
6961                         if (state.backtracking == 0) {
6962                             stream_SEPARATOR.add(SEPARATOR121);
6963                         }
6964
6965                         pushFollow(FOLLOW_enumerator_in_enumeratorList2470);
6966                         enumerator122 = enumerator();
6967
6968                         state._fsp--;
6969                         if (state.failed) {
6970                             return retval;
6971                         }
6972                         if (state.backtracking == 0) {
6973                             stream_enumerator.add(enumerator122.getTree());
6974                         }
6975
6976                     }
6977                         break;
6978
6979                     default:
6980                         break loop36;
6981                     }
6982                 } while (true);
6983
6984                 // AST REWRITE
6985                 // elements: enumerator
6986                 // token labels:
6987                 // rule labels: retval
6988                 // token list labels:
6989                 // rule list labels:
6990                 // wildcard labels:
6991                 if (state.backtracking == 0) {
6992                     retval.tree = root_0;
6993 //                    RewriteRuleSubtreeStream stream_retval =
6994                             new RewriteRuleSubtreeStream(
6995                             adaptor, "rule retval",
6996                             retval != null ? retval.tree : null);
6997
6998                     root_0 = (CommonTree) adaptor.nil();
6999                     // 715:38: -> ( ^( ENUM_ENUMERATOR enumerator ) )+
7000                     {
7001                         if (!(stream_enumerator.hasNext())) {
7002                             throw new RewriteEarlyExitException();
7003                         }
7004                         while (stream_enumerator.hasNext()) {
7005                             // Grammar/CTFParser.g:715:42: ^( ENUM_ENUMERATOR
7006                             // enumerator )
7007                             {
7008                                 CommonTree root_1 = (CommonTree) adaptor.nil();
7009                                 root_1 = (CommonTree) adaptor.becomeRoot(
7010                                         adaptor.create(ENUM_ENUMERATOR,
7011                                                 "ENUM_ENUMERATOR"), root_1);
7012
7013                                 adaptor.addChild(root_1,
7014                                         stream_enumerator.nextTree());
7015
7016                                 adaptor.addChild(root_0, root_1);
7017                             }
7018
7019                         }
7020                         stream_enumerator.reset();
7021
7022                     }
7023
7024                     retval.tree = root_0;
7025                 }
7026             }
7027
7028             retval.stop = input.LT(-1);
7029
7030             if (state.backtracking == 0) {
7031
7032                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
7033                 adaptor.setTokenBoundaries(retval.tree, retval.start,
7034                         retval.stop);
7035             }
7036             if (state.backtracking == 0) {
7037
7038                 exit("enumeratorList");
7039
7040             }
7041         }
7042
7043         catch (RecognitionException e) {
7044             throw e;
7045
7046         }
7047         return retval;
7048     }
7049
7050     // $ANTLR end "enumeratorList"
7051
7052     public static class enumerator_return extends ParserRuleReturnScope {
7053         CommonTree tree;
7054
7055         @Override
7056         public Object getTree() {
7057             return tree;
7058         }
7059     }
7060
7061     // $ANTLR start "enumerator"
7062     // Grammar/CTFParser.g:718:1: enumerator : enumConstant ( enumeratorValue )?
7063     // ;
7064     public final CTFParser.enumerator_return enumerator()
7065             throws RecognitionException {
7066         CTFParser.enumerator_return retval = new CTFParser.enumerator_return();
7067         retval.start = input.LT(1);
7068
7069         CommonTree root_0 = null;
7070
7071         CTFParser.enumConstant_return enumConstant123 = null;
7072
7073         CTFParser.enumeratorValue_return enumeratorValue124 = null;
7074
7075         enter("enumerator");
7076
7077         try {
7078             // Grammar/CTFParser.g:725:1: ( enumConstant ( enumeratorValue )? )
7079             // Grammar/CTFParser.g:726:3: enumConstant ( enumeratorValue )?
7080             {
7081                 root_0 = (CommonTree) adaptor.nil();
7082
7083                 pushFollow(FOLLOW_enumConstant_in_enumerator2506);
7084                 enumConstant123 = enumConstant();
7085
7086                 state._fsp--;
7087                 if (state.failed) {
7088                     return retval;
7089                 }
7090                 if (state.backtracking == 0) {
7091                     adaptor.addChild(root_0, enumConstant123.getTree());
7092                 }
7093                 // Grammar/CTFParser.g:726:16: ( enumeratorValue )?
7094                 int alt37 = 2;
7095                 int LA37_0 = input.LA(1);
7096
7097                 if ((LA37_0 == ASSIGNMENT)) {
7098                     alt37 = 1;
7099                 }
7100                 switch (alt37) {
7101                 case 1:
7102                 // Grammar/CTFParser.g:726:16: enumeratorValue
7103                 {
7104                     pushFollow(FOLLOW_enumeratorValue_in_enumerator2508);
7105                     enumeratorValue124 = enumeratorValue();
7106
7107                     state._fsp--;
7108                     if (state.failed) {
7109                         return retval;
7110                     }
7111                     if (state.backtracking == 0) {
7112                         adaptor.addChild(root_0, enumeratorValue124.getTree());
7113                     }
7114
7115                 }
7116                     break;
7117
7118                 }
7119
7120             }
7121
7122             retval.stop = input.LT(-1);
7123
7124             if (state.backtracking == 0) {
7125
7126                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
7127                 adaptor.setTokenBoundaries(retval.tree, retval.start,
7128                         retval.stop);
7129             }
7130             if (state.backtracking == 0) {
7131
7132                 exit("enumerator");
7133
7134             }
7135         }
7136
7137         catch (RecognitionException e) {
7138             throw e;
7139
7140         }
7141         return retval;
7142     }
7143
7144     // $ANTLR end "enumerator"
7145
7146     public static class enumeratorValue_return extends ParserRuleReturnScope {
7147         CommonTree tree;
7148
7149         @Override
7150         public Object getTree() {
7151             return tree;
7152         }
7153     }
7154
7155     // $ANTLR start "enumeratorValue"
7156     // Grammar/CTFParser.g:729:1: enumeratorValue : ASSIGNMENT e1=
7157     // unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression ->
7158     // ^( ENUM_VALUE_RANGE $e1 $e2) ) ;
7159     public final CTFParser.enumeratorValue_return enumeratorValue()
7160             throws RecognitionException {
7161         CTFParser.enumeratorValue_return retval = new CTFParser.enumeratorValue_return();
7162         retval.start = input.LT(1);
7163
7164         CommonTree root_0 = null;
7165
7166         Token ASSIGNMENT125 = null;
7167         Token ELIPSES126 = null;
7168         CTFParser.unaryExpression_return e1 = null;
7169
7170         CTFParser.unaryExpression_return e2 = null;
7171
7172         CommonTree ASSIGNMENT125_tree = null;
7173         CommonTree ELIPSES126_tree = null;
7174         RewriteRuleTokenStream stream_ASSIGNMENT = new RewriteRuleTokenStream(
7175                 adaptor, "token ASSIGNMENT");
7176         RewriteRuleTokenStream stream_ELIPSES = new RewriteRuleTokenStream(
7177                 adaptor, "token ELIPSES");
7178         RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(
7179                 adaptor, "rule unaryExpression");
7180
7181         enter("enumeratorValue");
7182
7183         try {
7184             // Grammar/CTFParser.g:736:1: ( ASSIGNMENT e1= unaryExpression ( ->
7185             // ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^(
7186             // ENUM_VALUE_RANGE $e1 $e2) ) )
7187             // Grammar/CTFParser.g:737:3: ASSIGNMENT e1= unaryExpression ( -> ^(
7188             // ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^(
7189             // ENUM_VALUE_RANGE $e1 $e2) )
7190             {
7191                 ASSIGNMENT125 = (Token) match(input, ASSIGNMENT,
7192                         FOLLOW_ASSIGNMENT_in_enumeratorValue2532);
7193                 if (state.failed) {
7194                     return retval;
7195                 }
7196                 if (state.backtracking == 0) {
7197                     stream_ASSIGNMENT.add(ASSIGNMENT125);
7198                 }
7199
7200                 pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2536);
7201                 e1 = unaryExpression();
7202
7203                 state._fsp--;
7204                 if (state.failed) {
7205                     return retval;
7206                 }
7207                 if (state.backtracking == 0) {
7208                     stream_unaryExpression.add(e1.getTree());
7209                 }
7210                 // Grammar/CTFParser.g:738:3: ( -> ^( ENUM_VALUE $e1) | ELIPSES
7211                 // e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) )
7212                 int alt38 = 2;
7213                 int LA38_0 = input.LA(1);
7214
7215                 if (((LA38_0 == SEPARATOR) || (LA38_0 == RCURL))) {
7216                     alt38 = 1;
7217                 } else if ((LA38_0 == ELIPSES)) {
7218                     alt38 = 2;
7219                 } else {
7220                     if (state.backtracking > 0) {
7221                         state.failed = true;
7222                         return retval;
7223                     }
7224                     NoViableAltException nvae = new NoViableAltException("",
7225                             38, 0, input);
7226
7227                     throw nvae;
7228                 }
7229                 switch (alt38) {
7230                 case 1:
7231                 // Grammar/CTFParser.g:739:5:
7232                 {
7233
7234                     // AST REWRITE
7235                     // elements: e1
7236                     // token labels:
7237                     // rule labels: retval, e1
7238                     // token list labels:
7239                     // rule list labels:
7240                     // wildcard labels:
7241                     if (state.backtracking == 0) {
7242                         retval.tree = root_0;
7243 //                        RewriteRuleSubtreeStream stream_retval =
7244                                 new RewriteRuleSubtreeStream(
7245                                 adaptor, "rule retval",
7246                                 retval != null ? retval.tree : null);
7247                         RewriteRuleSubtreeStream stream_e1 = new RewriteRuleSubtreeStream(
7248                                 adaptor, "rule e1", e1 != null ? e1.tree : null);
7249
7250                         root_0 = (CommonTree) adaptor.nil();
7251                         // 739:5: -> ^( ENUM_VALUE $e1)
7252                         {
7253                             // Grammar/CTFParser.g:739:8: ^( ENUM_VALUE $e1)
7254                             {
7255                                 CommonTree root_1 = (CommonTree) adaptor.nil();
7256                                 root_1 = (CommonTree) adaptor
7257                                         .becomeRoot(adaptor.create(ENUM_VALUE,
7258                                                 "ENUM_VALUE"), root_1);
7259
7260                                 adaptor.addChild(root_1, stream_e1.nextTree());
7261
7262                                 adaptor.addChild(root_0, root_1);
7263                             }
7264
7265                         }
7266
7267                         retval.tree = root_0;
7268                     }
7269                 }
7270                     break;
7271                 case 2:
7272                 // Grammar/CTFParser.g:740:7: ELIPSES e2= unaryExpression
7273                 {
7274                     ELIPSES126 = (Token) match(input, ELIPSES,
7275                             FOLLOW_ELIPSES_in_enumeratorValue2562);
7276                     if (state.failed) {
7277                         return retval;
7278                     }
7279                     if (state.backtracking == 0) {
7280                         stream_ELIPSES.add(ELIPSES126);
7281                     }
7282
7283                     pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2566);
7284                     e2 = unaryExpression();
7285
7286                     state._fsp--;
7287                     if (state.failed) {
7288                         return retval;
7289                     }
7290                     if (state.backtracking == 0) {
7291                         stream_unaryExpression.add(e2.getTree());
7292                     }
7293
7294                     // AST REWRITE
7295                     // elements: e2, e1
7296                     // token labels:
7297                     // rule labels: retval, e1, e2
7298                     // token list labels:
7299                     // rule list labels:
7300                     // wildcard labels:
7301                     if (state.backtracking == 0) {
7302                         retval.tree = root_0;
7303 //                        RewriteRuleSubtreeStream stream_retval =
7304                                 new RewriteRuleSubtreeStream(
7305                                 adaptor, "rule retval",
7306                                 retval != null ? retval.tree : null);
7307                         RewriteRuleSubtreeStream stream_e1 = new RewriteRuleSubtreeStream(
7308                                 adaptor, "rule e1", e1 != null ? e1.tree : null);
7309                         RewriteRuleSubtreeStream stream_e2 = new RewriteRuleSubtreeStream(
7310                                 adaptor, "rule e2", e2 != null ? e2.tree : null);
7311
7312                         root_0 = (CommonTree) adaptor.nil();
7313                         // 740:34: -> ^( ENUM_VALUE_RANGE $e1 $e2)
7314                         {
7315                             // Grammar/CTFParser.g:740:37: ^( ENUM_VALUE_RANGE
7316                             // $e1 $e2)
7317                             {
7318                                 CommonTree root_1 = (CommonTree) adaptor.nil();
7319                                 root_1 = (CommonTree) adaptor.becomeRoot(
7320                                         adaptor.create(ENUM_VALUE_RANGE,
7321                                                 "ENUM_VALUE_RANGE"), root_1);
7322
7323                                 adaptor.addChild(root_1, stream_e1.nextTree());
7324                                 adaptor.addChild(root_1, stream_e2.nextTree());
7325
7326                                 adaptor.addChild(root_0, root_1);
7327                             }
7328
7329                         }
7330
7331                         retval.tree = root_0;
7332                     }
7333                 }
7334                     break;
7335
7336                 }
7337
7338             }
7339
7340             retval.stop = input.LT(-1);
7341
7342             if (state.backtracking == 0) {
7343
7344                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
7345                 adaptor.setTokenBoundaries(retval.tree, retval.start,
7346                         retval.stop);
7347             }
7348             if (state.backtracking == 0) {
7349
7350                 exit("enumeratorValue");
7351
7352             }
7353         }
7354
7355         catch (RecognitionException e) {
7356             throw e;
7357
7358         }
7359         return retval;
7360     }
7361
7362     // $ANTLR end "enumeratorValue"
7363
7364     public static class declarator_return extends ParserRuleReturnScope {
7365         CommonTree tree;
7366
7367         @Override
7368         public Object getTree() {
7369             return tree;
7370         }
7371     }
7372
7373     // $ANTLR start "declarator"
7374     // Grammar/CTFParser.g:745:1: declarator : ( pointer )* directDeclarator ->
7375     // ^( TYPE_DECLARATOR ( pointer )* directDeclarator ) ;
7376     public final CTFParser.declarator_return declarator()
7377             throws RecognitionException {
7378         CTFParser.declarator_return retval = new CTFParser.declarator_return();
7379         retval.start = input.LT(1);
7380
7381         CommonTree root_0 = null;
7382
7383         CTFParser.pointer_return pointer127 = null;
7384
7385         CTFParser.directDeclarator_return directDeclarator128 = null;
7386
7387         RewriteRuleSubtreeStream stream_directDeclarator = new RewriteRuleSubtreeStream(
7388                 adaptor, "rule directDeclarator");
7389         RewriteRuleSubtreeStream stream_pointer = new RewriteRuleSubtreeStream(
7390                 adaptor, "rule pointer");
7391
7392         enter("declarator");
7393
7394         try {
7395             // Grammar/CTFParser.g:752:1: ( ( pointer )* directDeclarator -> ^(
7396             // TYPE_DECLARATOR ( pointer )* directDeclarator ) )
7397             // Grammar/CTFParser.g:753:3: ( pointer )* directDeclarator
7398             {
7399                 // Grammar/CTFParser.g:753:3: ( pointer )*
7400                 loop39: do {
7401                     int alt39 = 2;
7402                     int LA39_0 = input.LA(1);
7403
7404                     if ((LA39_0 == POINTER)) {
7405                         alt39 = 1;
7406                     }
7407
7408                     switch (alt39) {
7409                     case 1:
7410                     // Grammar/CTFParser.g:753:3: pointer
7411                     {
7412                         pushFollow(FOLLOW_pointer_in_declarator2608);
7413                         pointer127 = pointer();
7414
7415                         state._fsp--;
7416                         if (state.failed) {
7417                             return retval;
7418                         }
7419                         if (state.backtracking == 0) {
7420                             stream_pointer.add(pointer127.getTree());
7421                         }
7422
7423                     }
7424                         break;
7425
7426                     default:
7427                         break loop39;
7428                     }
7429                 } while (true);
7430
7431                 pushFollow(FOLLOW_directDeclarator_in_declarator2611);
7432                 directDeclarator128 = directDeclarator();
7433
7434                 state._fsp--;
7435                 if (state.failed) {
7436                     return retval;
7437                 }
7438                 if (state.backtracking == 0) {
7439                     stream_directDeclarator.add(directDeclarator128.getTree());
7440                 }
7441
7442                 // AST REWRITE
7443                 // elements: directDeclarator, pointer
7444                 // token labels:
7445                 // rule labels: retval
7446                 // token list labels:
7447                 // rule list labels:
7448                 // wildcard labels:
7449                 if (state.backtracking == 0) {
7450                     retval.tree = root_0;
7451 //                    RewriteRuleSubtreeStream stream_retval =
7452                             new RewriteRuleSubtreeStream(
7453                             adaptor, "rule retval",
7454                             retval != null ? retval.tree : null);
7455
7456                     root_0 = (CommonTree) adaptor.nil();
7457                     // 753:29: -> ^( TYPE_DECLARATOR ( pointer )*
7458                     // directDeclarator )
7459                     {
7460                         // Grammar/CTFParser.g:753:32: ^( TYPE_DECLARATOR (
7461                         // pointer )* directDeclarator )
7462                         {
7463                             CommonTree root_1 = (CommonTree) adaptor.nil();
7464                             root_1 = (CommonTree) adaptor.becomeRoot(
7465                                     adaptor.create(TYPE_DECLARATOR,
7466                                             "TYPE_DECLARATOR"), root_1);
7467
7468                             // Grammar/CTFParser.g:753:50: ( pointer )*
7469                             while (stream_pointer.hasNext()) {
7470                                 adaptor.addChild(root_1,
7471                                         stream_pointer.nextTree());
7472
7473                             }
7474                             stream_pointer.reset();
7475                             adaptor.addChild(root_1,
7476                                     stream_directDeclarator.nextTree());
7477
7478                             adaptor.addChild(root_0, root_1);
7479                         }
7480
7481                     }
7482
7483                     retval.tree = root_0;
7484                 }
7485             }
7486
7487             retval.stop = input.LT(-1);
7488
7489             if (state.backtracking == 0) {
7490
7491                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
7492                 adaptor.setTokenBoundaries(retval.tree, retval.start,
7493                         retval.stop);
7494             }
7495             if (state.backtracking == 0) {
7496
7497                 exit("declarator");
7498
7499             }
7500         }
7501
7502         catch (RecognitionException e) {
7503             throw e;
7504
7505         }
7506         return retval;
7507     }
7508
7509     // $ANTLR end "declarator"
7510
7511     public static class directDeclarator_return extends ParserRuleReturnScope {
7512         CommonTree tree;
7513
7514         @Override
7515         public Object getTree() {
7516             return tree;
7517         }
7518     }
7519
7520     // $ANTLR start "directDeclarator"
7521     // Grammar/CTFParser.g:756:1: directDeclarator : ( IDENTIFIER ) (
7522     // directDeclaratorSuffix )* ;
7523     public final CTFParser.directDeclarator_return directDeclarator()
7524             throws RecognitionException {
7525         CTFParser.directDeclarator_return retval = new CTFParser.directDeclarator_return();
7526         retval.start = input.LT(1);
7527
7528         CommonTree root_0 = null;
7529
7530         Token IDENTIFIER129 = null;
7531         CTFParser.directDeclaratorSuffix_return directDeclaratorSuffix130 = null;
7532
7533         CommonTree IDENTIFIER129_tree = null;
7534
7535         enter("directDeclarator");
7536
7537         try {
7538             // Grammar/CTFParser.g:763:1: ( ( IDENTIFIER ) (
7539             // directDeclaratorSuffix )* )
7540             // Grammar/CTFParser.g:764:3: ( IDENTIFIER ) (
7541             // directDeclaratorSuffix )*
7542             {
7543                 root_0 = (CommonTree) adaptor.nil();
7544
7545                 // Grammar/CTFParser.g:764:3: ( IDENTIFIER )
7546                 // Grammar/CTFParser.g:765:6: IDENTIFIER
7547                 {
7548                     IDENTIFIER129 = (Token) match(input, IDENTIFIER,
7549                             FOLLOW_IDENTIFIER_in_directDeclarator2655);
7550                     if (state.failed) {
7551                         return retval;
7552                     }
7553                     if (state.backtracking == 0) {
7554                         IDENTIFIER129_tree = (CommonTree) adaptor
7555                                 .create(IDENTIFIER129);
7556                         adaptor.addChild(root_0, IDENTIFIER129_tree);
7557                     }
7558                     if (state.backtracking == 0) {
7559                         if (inTypedef()) {
7560                             addTypeName((IDENTIFIER129 != null ? IDENTIFIER129
7561                                     .getText() : null));
7562                         }
7563                     }
7564                     if (state.backtracking == 0) {
7565                         debug_print((IDENTIFIER129 != null ? IDENTIFIER129
7566                                 .getText() : null));
7567                     }
7568
7569                 }
7570
7571                 // Grammar/CTFParser.g:768:2: ( directDeclaratorSuffix )*
7572                 loop40: do {
7573                     int alt40 = 2;
7574                     int LA40_0 = input.LA(1);
7575
7576                     if ((LA40_0 == OPENBRAC)) {
7577                         alt40 = 1;
7578                     }
7579
7580                     switch (alt40) {
7581                     case 1:
7582                     // Grammar/CTFParser.g:768:2: directDeclaratorSuffix
7583                     {
7584                         pushFollow(FOLLOW_directDeclaratorSuffix_in_directDeclarator2673);
7585                         directDeclaratorSuffix130 = directDeclaratorSuffix();
7586
7587                         state._fsp--;
7588                         if (state.failed) {
7589                             return retval;
7590                         }
7591                         if (state.backtracking == 0) {
7592                             adaptor.addChild(root_0,
7593                                     directDeclaratorSuffix130.getTree());
7594                         }
7595
7596                     }
7597                         break;
7598
7599                     default:
7600                         break loop40;
7601                     }
7602                 } while (true);
7603
7604             }
7605
7606             retval.stop = input.LT(-1);
7607
7608             if (state.backtracking == 0) {
7609
7610                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
7611                 adaptor.setTokenBoundaries(retval.tree, retval.start,
7612                         retval.stop);
7613             }
7614             if (state.backtracking == 0) {
7615
7616                 exit("directDeclarator");
7617
7618             }
7619         }
7620
7621         catch (RecognitionException e) {
7622             throw e;
7623
7624         }
7625         return retval;
7626     }
7627
7628     // $ANTLR end "directDeclarator"
7629
7630     public static class directDeclaratorSuffix_return extends
7631             ParserRuleReturnScope {
7632         CommonTree tree;
7633
7634         @Override
7635         public Object getTree() {
7636             return tree;
7637         }
7638     }
7639
7640     // $ANTLR start "directDeclaratorSuffix"
7641     // Grammar/CTFParser.g:771:1: directDeclaratorSuffix : OPENBRAC
7642     // directDeclaratorLength CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) ;
7643     public final CTFParser.directDeclaratorSuffix_return directDeclaratorSuffix()
7644             throws RecognitionException {
7645         CTFParser.directDeclaratorSuffix_return retval = new CTFParser.directDeclaratorSuffix_return();
7646         retval.start = input.LT(1);
7647
7648         CommonTree root_0 = null;
7649
7650         Token OPENBRAC131 = null;
7651         Token CLOSEBRAC133 = null;
7652         CTFParser.directDeclaratorLength_return directDeclaratorLength132 = null;
7653
7654         CommonTree OPENBRAC131_tree = null;
7655         CommonTree CLOSEBRAC133_tree = null;
7656         RewriteRuleTokenStream stream_OPENBRAC = new RewriteRuleTokenStream(
7657                 adaptor, "token OPENBRAC");
7658         RewriteRuleTokenStream stream_CLOSEBRAC = new RewriteRuleTokenStream(
7659                 adaptor, "token CLOSEBRAC");
7660         RewriteRuleSubtreeStream stream_directDeclaratorLength = new RewriteRuleSubtreeStream(
7661                 adaptor, "rule directDeclaratorLength");
7662         try {
7663             // Grammar/CTFParser.g:771:23: ( OPENBRAC directDeclaratorLength
7664             // CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) )
7665             // Grammar/CTFParser.g:772:3: OPENBRAC directDeclaratorLength
7666             // CLOSEBRAC
7667             {
7668                 OPENBRAC131 = (Token) match(input, OPENBRAC,
7669                         FOLLOW_OPENBRAC_in_directDeclaratorSuffix2686);
7670                 if (state.failed) {
7671                     return retval;
7672                 }
7673                 if (state.backtracking == 0) {
7674                     stream_OPENBRAC.add(OPENBRAC131);
7675                 }
7676
7677                 pushFollow(FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2688);
7678                 directDeclaratorLength132 = directDeclaratorLength();
7679
7680                 state._fsp--;
7681                 if (state.failed) {
7682                     return retval;
7683                 }
7684                 if (state.backtracking == 0) {
7685                     stream_directDeclaratorLength.add(directDeclaratorLength132
7686                             .getTree());
7687                 }
7688                 CLOSEBRAC133 = (Token) match(input, CLOSEBRAC,
7689                         FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2690);
7690                 if (state.failed) {
7691                     return retval;
7692                 }
7693                 if (state.backtracking == 0) {
7694                     stream_CLOSEBRAC.add(CLOSEBRAC133);
7695                 }
7696
7697                 // AST REWRITE
7698                 // elements: directDeclaratorLength
7699                 // token labels:
7700                 // rule labels: retval
7701                 // token list labels:
7702                 // rule list labels:
7703                 // wildcard labels:
7704                 if (state.backtracking == 0) {
7705                     retval.tree = root_0;
7706 //                    RewriteRuleSubtreeStream stream_retval =
7707                             new RewriteRuleSubtreeStream(
7708                             adaptor, "rule retval",
7709                             retval != null ? retval.tree : null);
7710
7711                     root_0 = (CommonTree) adaptor.nil();
7712                     // 772:45: -> ^( LENGTH directDeclaratorLength )
7713                     {
7714                         // Grammar/CTFParser.g:772:48: ^( LENGTH
7715                         // directDeclaratorLength )
7716                         {
7717                             CommonTree root_1 = (CommonTree) adaptor.nil();
7718                             root_1 = (CommonTree) adaptor.becomeRoot(
7719                                     adaptor.create(LENGTH, "LENGTH"), root_1);
7720
7721                             adaptor.addChild(root_1,
7722                                     stream_directDeclaratorLength.nextTree());
7723
7724                             adaptor.addChild(root_0, root_1);
7725                         }
7726
7727                     }
7728
7729                     retval.tree = root_0;
7730                 }
7731             }
7732
7733             retval.stop = input.LT(-1);
7734
7735             if (state.backtracking == 0) {
7736
7737                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
7738                 adaptor.setTokenBoundaries(retval.tree, retval.start,
7739                         retval.stop);
7740             }
7741         }
7742
7743         catch (RecognitionException e) {
7744             throw e;
7745
7746         }
7747         return retval;
7748     }
7749
7750     // $ANTLR end "directDeclaratorSuffix"
7751
7752     public static class directDeclaratorLength_return extends
7753             ParserRuleReturnScope {
7754         CommonTree tree;
7755
7756         @Override
7757         public Object getTree() {
7758             return tree;
7759         }
7760     }
7761
7762     // $ANTLR start "directDeclaratorLength"
7763     // Grammar/CTFParser.g:775:1: directDeclaratorLength : unaryExpression ;
7764     public final CTFParser.directDeclaratorLength_return directDeclaratorLength()
7765             throws RecognitionException {
7766         CTFParser.directDeclaratorLength_return retval = new CTFParser.directDeclaratorLength_return();
7767         retval.start = input.LT(1);
7768
7769         CommonTree root_0 = null;
7770
7771         CTFParser.unaryExpression_return unaryExpression134 = null;
7772
7773         try {
7774             // Grammar/CTFParser.g:775:24: ( unaryExpression )
7775             // Grammar/CTFParser.g:776:3: unaryExpression
7776             {
7777                 root_0 = (CommonTree) adaptor.nil();
7778
7779                 pushFollow(FOLLOW_unaryExpression_in_directDeclaratorLength2711);
7780                 unaryExpression134 = unaryExpression();
7781
7782                 state._fsp--;
7783                 if (state.failed) {
7784                     return retval;
7785                 }
7786                 if (state.backtracking == 0) {
7787                     adaptor.addChild(root_0, unaryExpression134.getTree());
7788                 }
7789
7790             }
7791
7792             retval.stop = input.LT(-1);
7793
7794             if (state.backtracking == 0) {
7795
7796                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
7797                 adaptor.setTokenBoundaries(retval.tree, retval.start,
7798                         retval.stop);
7799             }
7800         }
7801
7802         catch (RecognitionException e) {
7803             throw e;
7804
7805         }
7806         return retval;
7807     }
7808
7809     // $ANTLR end "directDeclaratorLength"
7810
7811     public static class abstractDeclarator_return extends ParserRuleReturnScope {
7812         CommonTree tree;
7813
7814         @Override
7815         public Object getTree() {
7816             return tree;
7817         }
7818     }
7819
7820     // $ANTLR start "abstractDeclarator"
7821     // Grammar/CTFParser.g:780:1: abstractDeclarator : ( ( ( pointer )+ (
7822     // directAbstractDeclarator )? ) -> ^( TYPE_DECLARATOR ( pointer )+ (
7823     // directAbstractDeclarator )? ) | directAbstractDeclarator -> ^(
7824     // TYPE_DECLARATOR directAbstractDeclarator ) );
7825     public final CTFParser.abstractDeclarator_return abstractDeclarator()
7826             throws RecognitionException {
7827         CTFParser.abstractDeclarator_return retval = new CTFParser.abstractDeclarator_return();
7828         retval.start = input.LT(1);
7829
7830         CommonTree root_0 = null;
7831
7832         CTFParser.pointer_return pointer135 = null;
7833
7834         CTFParser.directAbstractDeclarator_return directAbstractDeclarator136 = null;
7835
7836         CTFParser.directAbstractDeclarator_return directAbstractDeclarator137 = null;
7837
7838         RewriteRuleSubtreeStream stream_pointer = new RewriteRuleSubtreeStream(
7839                 adaptor, "rule pointer");
7840         RewriteRuleSubtreeStream stream_directAbstractDeclarator = new RewriteRuleSubtreeStream(
7841                 adaptor, "rule directAbstractDeclarator");
7842
7843         enter("abstractDeclarator");
7844
7845         try {
7846             // Grammar/CTFParser.g:787:1: ( ( ( pointer )+ (
7847             // directAbstractDeclarator )? ) -> ^( TYPE_DECLARATOR ( pointer )+
7848             // ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^(
7849             // TYPE_DECLARATOR directAbstractDeclarator ) )
7850             int alt43 = 2;
7851             int LA43_0 = input.LA(1);
7852
7853             if ((LA43_0 == POINTER)) {
7854                 alt43 = 1;
7855             } else if (((LA43_0 == LPAREN) || (LA43_0 == IDENTIFIER))) {
7856                 alt43 = 2;
7857             } else {
7858                 if (state.backtracking > 0) {
7859                     state.failed = true;
7860                     return retval;
7861                 }
7862                 NoViableAltException nvae = new NoViableAltException("", 43, 0,
7863                         input);
7864
7865                 throw nvae;
7866             }
7867             switch (alt43) {
7868             case 1:
7869             // Grammar/CTFParser.g:788:5: ( ( pointer )+ (
7870             // directAbstractDeclarator )? )
7871             {
7872                 // Grammar/CTFParser.g:788:5: ( ( pointer )+ (
7873                 // directAbstractDeclarator )? )
7874                 // Grammar/CTFParser.g:788:6: ( pointer )+ (
7875                 // directAbstractDeclarator )?
7876                 {
7877                     // Grammar/CTFParser.g:788:6: ( pointer )+
7878                     int cnt41 = 0;
7879                     loop41: do {
7880                         int alt41 = 2;
7881                         int LA41_0 = input.LA(1);
7882
7883                         if ((LA41_0 == POINTER)) {
7884                             alt41 = 1;
7885                         }
7886
7887                         switch (alt41) {
7888                         case 1:
7889                         // Grammar/CTFParser.g:788:6: pointer
7890                         {
7891                             pushFollow(FOLLOW_pointer_in_abstractDeclarator2742);
7892                             pointer135 = pointer();
7893
7894                             state._fsp--;
7895                             if (state.failed) {
7896                                 return retval;
7897                             }
7898                             if (state.backtracking == 0) {
7899                                 stream_pointer.add(pointer135.getTree());
7900                             }
7901
7902                         }
7903                             break;
7904
7905                         default:
7906                             if (cnt41 >= 1) {
7907                                 break loop41;
7908                             }
7909                             if (state.backtracking > 0) {
7910                                 state.failed = true;
7911                                 return retval;
7912                             }
7913                             EarlyExitException eee = new EarlyExitException(41,
7914                                     input);
7915                             throw eee;
7916                         }
7917                         cnt41++;
7918                     } while (true);
7919
7920                     // Grammar/CTFParser.g:788:15: ( directAbstractDeclarator )?
7921                     int alt42 = 2;
7922                     int LA42_0 = input.LA(1);
7923
7924                     if (((LA42_0 == LPAREN) || (LA42_0 == IDENTIFIER))) {
7925                         alt42 = 1;
7926                     }
7927                     switch (alt42) {
7928                     case 1:
7929                     // Grammar/CTFParser.g:788:15: directAbstractDeclarator
7930                     {
7931                         pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2745);
7932                         directAbstractDeclarator136 = directAbstractDeclarator();
7933
7934                         state._fsp--;
7935                         if (state.failed) {
7936                             return retval;
7937                         }
7938                         if (state.backtracking == 0) {
7939                             stream_directAbstractDeclarator
7940                                     .add(directAbstractDeclarator136.getTree());
7941                         }
7942
7943                     }
7944                         break;
7945
7946                     }
7947
7948                 }
7949
7950                 // AST REWRITE
7951                 // elements: pointer, directAbstractDeclarator
7952                 // token labels:
7953                 // rule labels: retval
7954                 // token list labels:
7955                 // rule list labels:
7956                 // wildcard labels:
7957                 if (state.backtracking == 0) {
7958                     retval.tree = root_0;
7959 //                    RewriteRuleSubtreeStream stream_retval =
7960                             new RewriteRuleSubtreeStream(
7961                             adaptor, "rule retval",
7962                             retval != null ? retval.tree : null);
7963
7964                     root_0 = (CommonTree) adaptor.nil();
7965                     // 788:42: -> ^( TYPE_DECLARATOR ( pointer )+ (
7966                     // directAbstractDeclarator )? )
7967                     {
7968                         // Grammar/CTFParser.g:788:45: ^( TYPE_DECLARATOR (
7969                         // pointer )+ ( directAbstractDeclarator )? )
7970                         {
7971                             CommonTree root_1 = (CommonTree) adaptor.nil();
7972                             root_1 = (CommonTree) adaptor.becomeRoot(
7973                                     adaptor.create(TYPE_DECLARATOR,
7974                                             "TYPE_DECLARATOR"), root_1);
7975
7976                             if (!(stream_pointer.hasNext())) {
7977                                 throw new RewriteEarlyExitException();
7978                             }
7979                             while (stream_pointer.hasNext()) {
7980                                 adaptor.addChild(root_1,
7981                                         stream_pointer.nextTree());
7982
7983                             }
7984                             stream_pointer.reset();
7985                             // Grammar/CTFParser.g:788:72: (
7986                             // directAbstractDeclarator )?
7987                             if (stream_directAbstractDeclarator.hasNext()) {
7988                                 adaptor.addChild(root_1,
7989                                         stream_directAbstractDeclarator
7990                                                 .nextTree());
7991
7992                             }
7993                             stream_directAbstractDeclarator.reset();
7994
7995                             adaptor.addChild(root_0, root_1);
7996                         }
7997
7998                     }
7999
8000                     retval.tree = root_0;
8001                 }
8002             }
8003                 break;
8004             case 2:
8005             // Grammar/CTFParser.g:789:5: directAbstractDeclarator
8006             {
8007                 pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2765);
8008                 directAbstractDeclarator137 = directAbstractDeclarator();
8009
8010                 state._fsp--;
8011                 if (state.failed) {
8012                     return retval;
8013                 }
8014                 if (state.backtracking == 0) {
8015                     stream_directAbstractDeclarator
8016                             .add(directAbstractDeclarator137.getTree());
8017                 }
8018
8019                 // AST REWRITE
8020                 // elements: directAbstractDeclarator
8021                 // token labels:
8022                 // rule labels: retval
8023                 // token list labels:
8024                 // rule list labels:
8025                 // wildcard labels:
8026                 if (state.backtracking == 0) {
8027                     retval.tree = root_0;
8028 //                    RewriteRuleSubtreeStream stream_retval =
8029                             new RewriteRuleSubtreeStream(
8030                             adaptor, "rule retval",
8031                             retval != null ? retval.tree : null);
8032
8033                     root_0 = (CommonTree) adaptor.nil();
8034                     // 789:30: -> ^( TYPE_DECLARATOR directAbstractDeclarator )
8035                     {
8036                         // Grammar/CTFParser.g:789:33: ^( TYPE_DECLARATOR
8037                         // directAbstractDeclarator )
8038                         {
8039                             CommonTree root_1 = (CommonTree) adaptor.nil();
8040                             root_1 = (CommonTree) adaptor.becomeRoot(
8041                                     adaptor.create(TYPE_DECLARATOR,
8042                                             "TYPE_DECLARATOR"), root_1);
8043
8044                             adaptor.addChild(root_1,
8045                                     stream_directAbstractDeclarator.nextTree());
8046
8047                             adaptor.addChild(root_0, root_1);
8048                         }
8049
8050                     }
8051
8052                     retval.tree = root_0;
8053                 }
8054             }
8055                 break;
8056
8057             }
8058             retval.stop = input.LT(-1);
8059
8060             if (state.backtracking == 0) {
8061
8062                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
8063                 adaptor.setTokenBoundaries(retval.tree, retval.start,
8064                         retval.stop);
8065             }
8066             if (state.backtracking == 0) {
8067
8068                 exit("abstractDeclarator");
8069
8070             }
8071         }
8072
8073         catch (RecognitionException e) {
8074             throw e;
8075
8076         }
8077         return retval;
8078     }
8079
8080     // $ANTLR end "abstractDeclarator"
8081
8082     public static class directAbstractDeclarator_return extends
8083             ParserRuleReturnScope {
8084         CommonTree tree;
8085
8086         @Override
8087         public Object getTree() {
8088             return tree;
8089         }
8090     }
8091
8092     // $ANTLR start "directAbstractDeclarator"
8093     // Grammar/CTFParser.g:796:1: directAbstractDeclarator : ( IDENTIFIER | (
8094     // LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
8095     // CLOSEBRAC )? ;
8096     public final CTFParser.directAbstractDeclarator_return directAbstractDeclarator()
8097             throws RecognitionException {
8098         CTFParser.directAbstractDeclarator_return retval = new CTFParser.directAbstractDeclarator_return();
8099         retval.start = input.LT(1);
8100
8101         CommonTree root_0 = null;
8102
8103         Token IDENTIFIER138 = null;
8104         Token LPAREN139 = null;
8105         Token RPAREN141 = null;
8106         Token OPENBRAC142 = null;
8107         Token CLOSEBRAC144 = null;
8108         CTFParser.abstractDeclarator_return abstractDeclarator140 = null;
8109
8110         CTFParser.unaryExpression_return unaryExpression143 = null;
8111
8112         CommonTree IDENTIFIER138_tree = null;
8113         CommonTree LPAREN139_tree = null;
8114         CommonTree RPAREN141_tree = null;
8115         CommonTree OPENBRAC142_tree = null;
8116         CommonTree CLOSEBRAC144_tree = null;
8117
8118         enter("directAbstractDeclarator");
8119
8120         try {
8121             // Grammar/CTFParser.g:804:1: ( ( IDENTIFIER | ( LPAREN
8122             // abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
8123             // CLOSEBRAC )? )
8124             // Grammar/CTFParser.g:805:3: ( IDENTIFIER | ( LPAREN
8125             // abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
8126             // CLOSEBRAC )?
8127             {
8128                 root_0 = (CommonTree) adaptor.nil();
8129
8130                 // Grammar/CTFParser.g:805:3: ( IDENTIFIER | ( LPAREN
8131                 // abstractDeclarator RPAREN ) )
8132                 int alt44 = 2;
8133                 int LA44_0 = input.LA(1);
8134
8135                 if ((LA44_0 == IDENTIFIER)) {
8136                     alt44 = 1;
8137                 } else if ((LA44_0 == LPAREN)) {
8138                     alt44 = 2;
8139                 } else {
8140                     if (state.backtracking > 0) {
8141                         state.failed = true;
8142                         return retval;
8143                     }
8144                     NoViableAltException nvae = new NoViableAltException("",
8145                             44, 0, input);
8146
8147                     throw nvae;
8148                 }
8149                 switch (alt44) {
8150                 case 1:
8151                 // Grammar/CTFParser.g:806:6: IDENTIFIER
8152                 {
8153                     IDENTIFIER138 = (Token) match(input, IDENTIFIER,
8154                             FOLLOW_IDENTIFIER_in_directAbstractDeclarator2805);
8155                     if (state.failed) {
8156                         return retval;
8157                     }
8158                     if (state.backtracking == 0) {
8159                         IDENTIFIER138_tree = (CommonTree) adaptor
8160                                 .create(IDENTIFIER138);
8161                         adaptor.addChild(root_0, IDENTIFIER138_tree);
8162                     }
8163
8164                 }
8165                     break;
8166                 case 2:
8167                 // Grammar/CTFParser.g:807:7: ( LPAREN abstractDeclarator RPAREN
8168                 // )
8169                 {
8170                     // Grammar/CTFParser.g:807:7: ( LPAREN abstractDeclarator
8171                     // RPAREN )
8172                     // Grammar/CTFParser.g:807:8: LPAREN abstractDeclarator
8173                     // RPAREN
8174                     {
8175                         LPAREN139 = (Token) match(input, LPAREN,
8176                                 FOLLOW_LPAREN_in_directAbstractDeclarator2814);
8177                         if (state.failed) {
8178                             return retval;
8179                         }
8180                         if (state.backtracking == 0) {
8181                             LPAREN139_tree = (CommonTree) adaptor
8182                                     .create(LPAREN139);
8183                             adaptor.addChild(root_0, LPAREN139_tree);
8184                         }
8185                         pushFollow(FOLLOW_abstractDeclarator_in_directAbstractDeclarator2816);
8186                         abstractDeclarator140 = abstractDeclarator();
8187
8188                         state._fsp--;
8189                         if (state.failed) {
8190                             return retval;
8191                         }
8192                         if (state.backtracking == 0) {
8193                             adaptor.addChild(root_0,
8194                                     abstractDeclarator140.getTree());
8195                         }
8196                         RPAREN141 = (Token) match(input, RPAREN,
8197                                 FOLLOW_RPAREN_in_directAbstractDeclarator2818);
8198                         if (state.failed) {
8199                             return retval;
8200                         }
8201                         if (state.backtracking == 0) {
8202                             RPAREN141_tree = (CommonTree) adaptor
8203                                     .create(RPAREN141);
8204                             adaptor.addChild(root_0, RPAREN141_tree);
8205                         }
8206
8207                     }
8208
8209                 }
8210                     break;
8211
8212                 }
8213
8214                 // Grammar/CTFParser.g:809:3: ( OPENBRAC ( unaryExpression )?
8215                 // CLOSEBRAC )?
8216                 int alt46 = 2;
8217                 int LA46_0 = input.LA(1);
8218
8219                 if ((LA46_0 == OPENBRAC)) {
8220                     alt46 = 1;
8221                 }
8222                 switch (alt46) {
8223                 case 1:
8224                 // Grammar/CTFParser.g:810:5: OPENBRAC ( unaryExpression )?
8225                 // CLOSEBRAC
8226                 {
8227                     OPENBRAC142 = (Token) match(input, OPENBRAC,
8228                             FOLLOW_OPENBRAC_in_directAbstractDeclarator2833);
8229                     if (state.failed) {
8230                         return retval;
8231                     }
8232                     if (state.backtracking == 0) {
8233                         OPENBRAC142_tree = (CommonTree) adaptor
8234                                 .create(OPENBRAC142);
8235                         adaptor.addChild(root_0, OPENBRAC142_tree);
8236                     }
8237                     // Grammar/CTFParser.g:810:14: ( unaryExpression )?
8238                     int alt45 = 2;
8239                     int LA45_0 = input.LA(1);
8240
8241                     if (((LA45_0 == ALIGNTOK) || (LA45_0 == EVENTTOK)
8242                             || ((LA45_0 >= SIGNEDTOK) && (LA45_0 <= STRINGTOK))
8243                             || (LA45_0 == TRACETOK)
8244                             || ((LA45_0 >= ENVTOK) && (LA45_0 <= CLOCKTOK))
8245                             || (LA45_0 == SIGN) || (LA45_0 == OCTAL_LITERAL)
8246                             || (LA45_0 == DECIMAL_LITERAL)
8247                             || (LA45_0 == HEX_LITERAL)
8248                             || (LA45_0 == CHARACTER_LITERAL)
8249                             || (LA45_0 == STRING_LITERAL) || (LA45_0 == IDENTIFIER))) {
8250                         alt45 = 1;
8251                     }
8252                     switch (alt45) {
8253                     case 1:
8254                     // Grammar/CTFParser.g:810:14: unaryExpression
8255                     {
8256                         pushFollow(FOLLOW_unaryExpression_in_directAbstractDeclarator2835);
8257                         unaryExpression143 = unaryExpression();
8258
8259                         state._fsp--;
8260                         if (state.failed) {
8261                             return retval;
8262                         }
8263                         if (state.backtracking == 0) {
8264                             adaptor.addChild(root_0,
8265                                     unaryExpression143.getTree());
8266                         }
8267
8268                     }
8269                         break;
8270
8271                     }
8272
8273                     CLOSEBRAC144 = (Token) match(input, CLOSEBRAC,
8274                             FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2838);
8275                     if (state.failed) {
8276                         return retval;
8277                     }
8278                     if (state.backtracking == 0) {
8279                         CLOSEBRAC144_tree = (CommonTree) adaptor
8280                                 .create(CLOSEBRAC144);
8281                         adaptor.addChild(root_0, CLOSEBRAC144_tree);
8282                     }
8283
8284                 }
8285                     break;
8286
8287                 }
8288
8289             }
8290
8291             retval.stop = input.LT(-1);
8292
8293             if (state.backtracking == 0) {
8294
8295                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
8296                 adaptor.setTokenBoundaries(retval.tree, retval.start,
8297                         retval.stop);
8298             }
8299             if (state.backtracking == 0) {
8300
8301                 debug_print(input.toString(retval.start, input.LT(-1)));
8302                 exit("directAbstractDeclarator");
8303
8304             }
8305         }
8306
8307         catch (RecognitionException e) {
8308             throw e;
8309
8310         }
8311         return retval;
8312     }
8313
8314     // $ANTLR end "directAbstractDeclarator"
8315
8316     public static class pointer_return extends ParserRuleReturnScope {
8317         CommonTree tree;
8318
8319         @Override
8320         public Object getTree() {
8321             return tree;
8322         }
8323     }
8324
8325     // $ANTLR start "pointer"
8326     // Grammar/CTFParser.g:814:1: pointer : POINTER ( typeQualifierList )? -> ^(
8327     // POINTER ( typeQualifierList )? ) ;
8328     public final CTFParser.pointer_return pointer() throws RecognitionException {
8329         CTFParser.pointer_return retval = new CTFParser.pointer_return();
8330         retval.start = input.LT(1);
8331
8332         CommonTree root_0 = null;
8333
8334         Token POINTER145 = null;
8335         CTFParser.typeQualifierList_return typeQualifierList146 = null;
8336
8337         CommonTree POINTER145_tree = null;
8338         RewriteRuleTokenStream stream_POINTER = new RewriteRuleTokenStream(
8339                 adaptor, "token POINTER");
8340         RewriteRuleSubtreeStream stream_typeQualifierList = new RewriteRuleSubtreeStream(
8341                 adaptor, "rule typeQualifierList");
8342
8343         enter("pointer");
8344
8345         try {
8346             // Grammar/CTFParser.g:822:1: ( POINTER ( typeQualifierList )? -> ^(
8347             // POINTER ( typeQualifierList )? ) )
8348             // Grammar/CTFParser.g:823:3: POINTER ( typeQualifierList )?
8349             {
8350                 POINTER145 = (Token) match(input, POINTER,
8351                         FOLLOW_POINTER_in_pointer2866);
8352                 if (state.failed) {
8353                     return retval;
8354                 }
8355                 if (state.backtracking == 0) {
8356                     stream_POINTER.add(POINTER145);
8357                 }
8358
8359                 // Grammar/CTFParser.g:823:11: ( typeQualifierList )?
8360                 int alt47 = 2;
8361                 int LA47_0 = input.LA(1);
8362
8363                 if ((LA47_0 == CONSTTOK)) {
8364                     alt47 = 1;
8365                 }
8366                 switch (alt47) {
8367                 case 1:
8368                 // Grammar/CTFParser.g:823:11: typeQualifierList
8369                 {
8370                     pushFollow(FOLLOW_typeQualifierList_in_pointer2868);
8371                     typeQualifierList146 = typeQualifierList();
8372
8373                     state._fsp--;
8374                     if (state.failed) {
8375                         return retval;
8376                     }
8377                     if (state.backtracking == 0) {
8378                         stream_typeQualifierList.add(typeQualifierList146
8379                                 .getTree());
8380                     }
8381
8382                 }
8383                     break;
8384
8385                 }
8386
8387                 // AST REWRITE
8388                 // elements: typeQualifierList, POINTER
8389                 // token labels:
8390                 // rule labels: retval
8391                 // token list labels:
8392                 // rule list labels:
8393                 // wildcard labels:
8394                 if (state.backtracking == 0) {
8395                     retval.tree = root_0;
8396 //                    RewriteRuleSubtreeStream stream_retval =
8397                             new RewriteRuleSubtreeStream(
8398                             adaptor, "rule retval",
8399                             retval != null ? retval.tree : null);
8400
8401                     root_0 = (CommonTree) adaptor.nil();
8402                     // 823:30: -> ^( POINTER ( typeQualifierList )? )
8403                     {
8404                         // Grammar/CTFParser.g:823:33: ^( POINTER (
8405                         // typeQualifierList )? )
8406                         {
8407                             CommonTree root_1 = (CommonTree) adaptor.nil();
8408                             root_1 = (CommonTree) adaptor.becomeRoot(
8409                                     stream_POINTER.nextNode(), root_1);
8410
8411                             // Grammar/CTFParser.g:823:43: ( typeQualifierList
8412                             // )?
8413                             if (stream_typeQualifierList.hasNext()) {
8414                                 adaptor.addChild(root_1,
8415                                         stream_typeQualifierList.nextTree());
8416
8417                             }
8418                             stream_typeQualifierList.reset();
8419
8420                             adaptor.addChild(root_0, root_1);
8421                         }
8422
8423                     }
8424
8425                     retval.tree = root_0;
8426                 }
8427             }
8428
8429             retval.stop = input.LT(-1);
8430
8431             if (state.backtracking == 0) {
8432
8433                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
8434                 adaptor.setTokenBoundaries(retval.tree, retval.start,
8435                         retval.stop);
8436             }
8437             if (state.backtracking == 0) {
8438
8439                 debug_print(input.toString(retval.start, input.LT(-1)));
8440                 exit("pointer");
8441
8442             }
8443         }
8444
8445         catch (RecognitionException e) {
8446             throw e;
8447
8448         }
8449         return retval;
8450     }
8451
8452     // $ANTLR end "pointer"
8453
8454     public static class typeQualifierList_return extends ParserRuleReturnScope {
8455         CommonTree tree;
8456
8457         @Override
8458         public Object getTree() {
8459             return tree;
8460         }
8461     }
8462
8463     // $ANTLR start "typeQualifierList"
8464     // Grammar/CTFParser.g:826:1: typeQualifierList : ( typeQualifier )+ ;
8465     public final CTFParser.typeQualifierList_return typeQualifierList()
8466             throws RecognitionException {
8467         CTFParser.typeQualifierList_return retval = new CTFParser.typeQualifierList_return();
8468         retval.start = input.LT(1);
8469
8470         CommonTree root_0 = null;
8471
8472         CTFParser.typeQualifier_return typeQualifier147 = null;
8473
8474         try {
8475             // Grammar/CTFParser.g:826:19: ( ( typeQualifier )+ )
8476             // Grammar/CTFParser.g:827:3: ( typeQualifier )+
8477             {
8478                 root_0 = (CommonTree) adaptor.nil();
8479
8480                 // Grammar/CTFParser.g:827:3: ( typeQualifier )+
8481                 int cnt48 = 0;
8482                 loop48: do {
8483                     int alt48 = 2;
8484                     int LA48_0 = input.LA(1);
8485
8486                     if ((LA48_0 == CONSTTOK)) {
8487                         alt48 = 1;
8488                     }
8489
8490                     switch (alt48) {
8491                     case 1:
8492                     // Grammar/CTFParser.g:827:3: typeQualifier
8493                     {
8494                         pushFollow(FOLLOW_typeQualifier_in_typeQualifierList2891);
8495                         typeQualifier147 = typeQualifier();
8496
8497                         state._fsp--;
8498                         if (state.failed) {
8499                             return retval;
8500                         }
8501                         if (state.backtracking == 0) {
8502                             adaptor.addChild(root_0, typeQualifier147.getTree());
8503                         }
8504
8505                     }
8506                         break;
8507
8508                     default:
8509                         if (cnt48 >= 1) {
8510                             break loop48;
8511                         }
8512                         if (state.backtracking > 0) {
8513                             state.failed = true;
8514                             return retval;
8515                         }
8516                         EarlyExitException eee = new EarlyExitException(48,
8517                                 input);
8518                         throw eee;
8519                     }
8520                     cnt48++;
8521                 } while (true);
8522
8523             }
8524
8525             retval.stop = input.LT(-1);
8526
8527             if (state.backtracking == 0) {
8528
8529                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
8530                 adaptor.setTokenBoundaries(retval.tree, retval.start,
8531                         retval.stop);
8532             }
8533         }
8534
8535         catch (RecognitionException e) {
8536             throw e;
8537
8538         }
8539         return retval;
8540     }
8541
8542     // $ANTLR end "typeQualifierList"
8543
8544     public static class typedefName_return extends ParserRuleReturnScope {
8545         CommonTree tree;
8546
8547         @Override
8548         public Object getTree() {
8549             return tree;
8550         }
8551     }
8552
8553     // $ANTLR start "typedefName"
8554     // Grammar/CTFParser.g:830:1: typedefName : {...}? IDENTIFIER ;
8555     public final CTFParser.typedefName_return typedefName()
8556             throws RecognitionException {
8557         CTFParser.typedefName_return retval = new CTFParser.typedefName_return();
8558         retval.start = input.LT(1);
8559
8560         CommonTree root_0 = null;
8561
8562         Token IDENTIFIER148 = null;
8563
8564         CommonTree IDENTIFIER148_tree = null;
8565
8566         enter("typedefName");
8567
8568         try {
8569             // Grammar/CTFParser.g:838:1: ({...}? IDENTIFIER )
8570             // Grammar/CTFParser.g:839:3: {...}? IDENTIFIER
8571             {
8572                 root_0 = (CommonTree) adaptor.nil();
8573
8574                 if (!((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
8575                     if (state.backtracking > 0) {
8576                         state.failed = true;
8577                         return retval;
8578                     }
8579                     throw new FailedPredicateException(input, "typedefName",
8580                             "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
8581                 }
8582                 IDENTIFIER148 = (Token) match(input, IDENTIFIER,
8583                         FOLLOW_IDENTIFIER_in_typedefName2917);
8584                 if (state.failed) {
8585                     return retval;
8586                 }
8587                 if (state.backtracking == 0) {
8588                     IDENTIFIER148_tree = (CommonTree) adaptor
8589                             .create(IDENTIFIER148);
8590                     adaptor.addChild(root_0, IDENTIFIER148_tree);
8591                 }
8592                 if (state.backtracking == 0) {
8593                     if ((inTypedef() || inTypealiasAlias())
8594                             && !isTypeName((IDENTIFIER148 != null ? IDENTIFIER148
8595                                     .getText() : null))) {
8596                         addTypeName((IDENTIFIER148 != null ? IDENTIFIER148
8597                                 .getText() : null));
8598                     }
8599                 }
8600
8601             }
8602
8603             retval.stop = input.LT(-1);
8604
8605             if (state.backtracking == 0) {
8606
8607                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
8608                 adaptor.setTokenBoundaries(retval.tree, retval.start,
8609                         retval.stop);
8610             }
8611             if (state.backtracking == 0) {
8612
8613                 debug_print("typedefName: "
8614                         + input.toString(retval.start, input.LT(-1)));
8615                 exit("typedefName");
8616
8617             }
8618         }
8619
8620         catch (RecognitionException e) {
8621             throw e;
8622
8623         }
8624         return retval;
8625     }
8626
8627     // $ANTLR end "typedefName"
8628
8629     public static class typealiasTarget_return extends ParserRuleReturnScope {
8630         CommonTree tree;
8631
8632         @Override
8633         public Object getTree() {
8634             return tree;
8635         }
8636     }
8637
8638     // $ANTLR start "typealiasTarget"
8639     // Grammar/CTFParser.g:842:1: typealiasTarget : declarationSpecifiers (
8640     // abstractDeclaratorList )? ;
8641     public final CTFParser.typealiasTarget_return typealiasTarget()
8642             throws RecognitionException {
8643         CTFParser.typealiasTarget_return retval = new CTFParser.typealiasTarget_return();
8644         retval.start = input.LT(1);
8645
8646         CommonTree root_0 = null;
8647
8648         CTFParser.declarationSpecifiers_return declarationSpecifiers149 = null;
8649
8650         CTFParser.abstractDeclaratorList_return abstractDeclaratorList150 = null;
8651
8652         enter("typealiasTarget");
8653
8654         try {
8655             // Grammar/CTFParser.g:855:1: ( declarationSpecifiers (
8656             // abstractDeclaratorList )? )
8657             // Grammar/CTFParser.g:856:3: declarationSpecifiers (
8658             // abstractDeclaratorList )?
8659             {
8660                 root_0 = (CommonTree) adaptor.nil();
8661
8662                 pushFollow(FOLLOW_declarationSpecifiers_in_typealiasTarget2945);
8663                 declarationSpecifiers149 = declarationSpecifiers();
8664
8665                 state._fsp--;
8666                 if (state.failed) {
8667                     return retval;
8668                 }
8669                 if (state.backtracking == 0) {
8670                     adaptor.addChild(root_0, declarationSpecifiers149.getTree());
8671                 }
8672                 // Grammar/CTFParser.g:856:25: ( abstractDeclaratorList )?
8673                 int alt49 = 2;
8674                 int LA49_0 = input.LA(1);
8675
8676                 if (((LA49_0 == LPAREN) || (LA49_0 == POINTER) || (LA49_0 == IDENTIFIER))) {
8677                     alt49 = 1;
8678                 }
8679                 switch (alt49) {
8680                 case 1:
8681                 // Grammar/CTFParser.g:856:25: abstractDeclaratorList
8682                 {
8683                     pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasTarget2947);
8684                     abstractDeclaratorList150 = abstractDeclaratorList();
8685
8686                     state._fsp--;
8687                     if (state.failed) {
8688                         return retval;
8689                     }
8690                     if (state.backtracking == 0) {
8691                         adaptor.addChild(root_0,
8692                                 abstractDeclaratorList150.getTree());
8693                     }
8694
8695                 }
8696                     break;
8697
8698                 }
8699
8700             }
8701
8702             retval.stop = input.LT(-1);
8703
8704             if (state.backtracking == 0) {
8705
8706                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
8707                 adaptor.setTokenBoundaries(retval.tree, retval.start,
8708                         retval.stop);
8709             }
8710             if (state.backtracking == 0) {
8711
8712                 exit("typealiasTarget");
8713
8714             }
8715         }
8716
8717         catch (RecognitionException e) {
8718             throw e;
8719
8720         }
8721         return retval;
8722     }
8723
8724     // $ANTLR end "typealiasTarget"
8725
8726     public static class typealiasAlias_return extends ParserRuleReturnScope {
8727         CommonTree tree;
8728
8729         @Override
8730         public Object getTree() {
8731             return tree;
8732         }
8733     }
8734
8735     // $ANTLR start "typealiasAlias"
8736     // Grammar/CTFParser.g:859:1: typealiasAlias : ( abstractDeclaratorList | (
8737     // declarationSpecifiers ( abstractDeclaratorList )? ) ) ;
8738     public final CTFParser.typealiasAlias_return typealiasAlias()
8739             throws RecognitionException {
8740         CTFParser.typealiasAlias_return retval = new CTFParser.typealiasAlias_return();
8741         retval.start = input.LT(1);
8742
8743         CommonTree root_0 = null;
8744
8745         CTFParser.abstractDeclaratorList_return abstractDeclaratorList151 = null;
8746
8747         CTFParser.declarationSpecifiers_return declarationSpecifiers152 = null;
8748
8749         CTFParser.abstractDeclaratorList_return abstractDeclaratorList153 = null;
8750
8751         enter("typealiasAlias");
8752         typealiasAliasOn();
8753
8754         try {
8755             // Grammar/CTFParser.g:874:1: ( ( abstractDeclaratorList | (
8756             // declarationSpecifiers ( abstractDeclaratorList )? ) ) )
8757             // Grammar/CTFParser.g:875:3: ( abstractDeclaratorList | (
8758             // declarationSpecifiers ( abstractDeclaratorList )? ) )
8759             {
8760                 root_0 = (CommonTree) adaptor.nil();
8761
8762                 // Grammar/CTFParser.g:875:3: ( abstractDeclaratorList | (
8763                 // declarationSpecifiers ( abstractDeclaratorList )? ) )
8764                 int alt51 = 2;
8765                 switch (input.LA(1)) {
8766                 case LPAREN:
8767                 case POINTER: {
8768                     alt51 = 1;
8769                 }
8770                     break;
8771                 case IDENTIFIER: {
8772                     int LA51_2 = input.LA(2);
8773
8774                     if ((!(((inTypealiasAlias() || isTypeName(input.LT(1)
8775                             .getText())))))) {
8776                         alt51 = 1;
8777                     } else if (((inTypealiasAlias() || isTypeName(input.LT(1)
8778                             .getText())))) {
8779                         alt51 = 2;
8780                     } else {
8781                         if (state.backtracking > 0) {
8782                             state.failed = true;
8783                             return retval;
8784                         }
8785                         NoViableAltException nvae = new NoViableAltException(
8786                                 "", 51, 2, input);
8787
8788                         throw nvae;
8789                     }
8790                 }
8791                     break;
8792                 case CONSTTOK:
8793                 case CHARTOK:
8794                 case DOUBLETOK:
8795                 case ENUMTOK:
8796                 case FLOATINGPOINTTOK:
8797                 case FLOATTOK:
8798                 case INTEGERTOK:
8799                 case INTTOK:
8800                 case LONGTOK:
8801                 case SHORTTOK:
8802                 case SIGNEDTOK:
8803                 case STRINGTOK:
8804                 case STRUCTTOK:
8805                 case TYPEDEFTOK:
8806                 case UNSIGNEDTOK:
8807                 case VARIANTTOK:
8808                 case VOIDTOK:
8809                 case BOOLTOK:
8810                 case COMPLEXTOK:
8811                 case IMAGINARYTOK: {
8812                     alt51 = 2;
8813                 }
8814                     break;
8815                 default:
8816                     if (state.backtracking > 0) {
8817                         state.failed = true;
8818                         return retval;
8819                     }
8820                     NoViableAltException nvae = new NoViableAltException("",
8821                             51, 0, input);
8822
8823                     throw nvae;
8824                 }
8825
8826                 switch (alt51) {
8827                 case 1:
8828                 // Grammar/CTFParser.g:876:3: abstractDeclaratorList
8829                 {
8830                     pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias2980);
8831                     abstractDeclaratorList151 = abstractDeclaratorList();
8832
8833                     state._fsp--;
8834                     if (state.failed) {
8835                         return retval;
8836                     }
8837                     if (state.backtracking == 0) {
8838                         adaptor.addChild(root_0,
8839                                 abstractDeclaratorList151.getTree());
8840                     }
8841
8842                 }
8843                     break;
8844                 case 2:
8845                 // Grammar/CTFParser.g:878:3: ( declarationSpecifiers (
8846                 // abstractDeclaratorList )? )
8847                 {
8848                     // Grammar/CTFParser.g:878:3: ( declarationSpecifiers (
8849                     // abstractDeclaratorList )? )
8850                     // Grammar/CTFParser.g:878:4: declarationSpecifiers (
8851                     // abstractDeclaratorList )?
8852                     {
8853                         pushFollow(FOLLOW_declarationSpecifiers_in_typealiasAlias2989);
8854                         declarationSpecifiers152 = declarationSpecifiers();
8855
8856                         state._fsp--;
8857                         if (state.failed) {
8858                             return retval;
8859                         }
8860                         if (state.backtracking == 0) {
8861                             adaptor.addChild(root_0,
8862                                     declarationSpecifiers152.getTree());
8863                         }
8864                         // Grammar/CTFParser.g:878:26: ( abstractDeclaratorList
8865                         // )?
8866                         int alt50 = 2;
8867                         int LA50_0 = input.LA(1);
8868
8869                         if (((LA50_0 == LPAREN) || (LA50_0 == POINTER) || (LA50_0 == IDENTIFIER))) {
8870                             alt50 = 1;
8871                         }
8872                         switch (alt50) {
8873                         case 1:
8874                         // Grammar/CTFParser.g:878:26: abstractDeclaratorList
8875                         {
8876                             pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias2991);
8877                             abstractDeclaratorList153 = abstractDeclaratorList();
8878
8879                             state._fsp--;
8880                             if (state.failed) {
8881                                 return retval;
8882                             }
8883                             if (state.backtracking == 0) {
8884                                 adaptor.addChild(root_0,
8885                                         abstractDeclaratorList153.getTree());
8886                             }
8887
8888                         }
8889                             break;
8890
8891                         }
8892
8893                     }
8894
8895                 }
8896                     break;
8897
8898                 }
8899
8900             }
8901
8902             retval.stop = input.LT(-1);
8903
8904             if (state.backtracking == 0) {
8905
8906                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
8907                 adaptor.setTokenBoundaries(retval.tree, retval.start,
8908                         retval.stop);
8909             }
8910             if (state.backtracking == 0) {
8911
8912                 exit("typealiasAlias");
8913                 typealiasAliasOff();
8914
8915             }
8916         }
8917
8918         catch (RecognitionException e) {
8919             throw e;
8920
8921         }
8922         return retval;
8923     }
8924
8925     // $ANTLR end "typealiasAlias"
8926
8927     public static class typealiasDecl_return extends ParserRuleReturnScope {
8928         CommonTree tree;
8929
8930         @Override
8931         public Object getTree() {
8932             return tree;
8933         }
8934     }
8935
8936     // $ANTLR start "typealiasDecl"
8937     // Grammar/CTFParser.g:882:1: typealiasDecl : TYPEALIASTOK typealiasTarget
8938     // TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^( TYPEALIAS_TARGET
8939     // typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) ) ;
8940     public final CTFParser.typealiasDecl_return typealiasDecl()
8941             throws RecognitionException {
8942         CTFParser.typealiasDecl_return retval = new CTFParser.typealiasDecl_return();
8943         retval.start = input.LT(1);
8944
8945         CommonTree root_0 = null;
8946
8947         Token TYPEALIASTOK154 = null;
8948         Token TYPE_ASSIGNMENT156 = null;
8949         CTFParser.typealiasTarget_return typealiasTarget155 = null;
8950
8951         CTFParser.typealiasAlias_return typealiasAlias157 = null;
8952
8953         CommonTree TYPEALIASTOK154_tree = null;
8954         CommonTree TYPE_ASSIGNMENT156_tree = null;
8955         RewriteRuleTokenStream stream_TYPE_ASSIGNMENT = new RewriteRuleTokenStream(
8956                 adaptor, "token TYPE_ASSIGNMENT");
8957         RewriteRuleTokenStream stream_TYPEALIASTOK = new RewriteRuleTokenStream(
8958                 adaptor, "token TYPEALIASTOK");
8959         RewriteRuleSubtreeStream stream_typealiasAlias = new RewriteRuleSubtreeStream(
8960                 adaptor, "rule typealiasAlias");
8961         RewriteRuleSubtreeStream stream_typealiasTarget = new RewriteRuleSubtreeStream(
8962                 adaptor, "rule typealiasTarget");
8963
8964         enter("typealiasDecl");
8965
8966         try {
8967             // Grammar/CTFParser.g:889:1: ( TYPEALIASTOK typealiasTarget
8968             // TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^(
8969             // TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS
8970             // typealiasAlias ) ) )
8971             // Grammar/CTFParser.g:890:3: TYPEALIASTOK typealiasTarget
8972             // TYPE_ASSIGNMENT typealiasAlias
8973             {
8974                 TYPEALIASTOK154 = (Token) match(input, TYPEALIASTOK,
8975                         FOLLOW_TYPEALIASTOK_in_typealiasDecl3023);
8976                 if (state.failed) {
8977                     return retval;
8978                 }
8979                 if (state.backtracking == 0) {
8980                     stream_TYPEALIASTOK.add(TYPEALIASTOK154);
8981                 }
8982
8983                 pushFollow(FOLLOW_typealiasTarget_in_typealiasDecl3025);
8984                 typealiasTarget155 = typealiasTarget();
8985
8986                 state._fsp--;
8987                 if (state.failed) {
8988                     return retval;
8989                 }
8990                 if (state.backtracking == 0) {
8991                     stream_typealiasTarget.add(typealiasTarget155.getTree());
8992                 }
8993                 TYPE_ASSIGNMENT156 = (Token) match(input, TYPE_ASSIGNMENT,
8994                         FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3027);
8995                 if (state.failed) {
8996                     return retval;
8997                 }
8998                 if (state.backtracking == 0) {
8999                     stream_TYPE_ASSIGNMENT.add(TYPE_ASSIGNMENT156);
9000                 }
9001
9002                 pushFollow(FOLLOW_typealiasAlias_in_typealiasDecl3029);
9003                 typealiasAlias157 = typealiasAlias();
9004
9005                 state._fsp--;
9006                 if (state.failed) {
9007                     return retval;
9008                 }
9009                 if (state.backtracking == 0) {
9010                     stream_typealiasAlias.add(typealiasAlias157.getTree());
9011                 }
9012
9013                 // AST REWRITE
9014                 // elements: typealiasTarget, typealiasAlias
9015                 // token labels:
9016                 // rule labels: retval
9017                 // token list labels:
9018                 // rule list labels:
9019                 // wildcard labels:
9020                 if (state.backtracking == 0) {
9021                     retval.tree = root_0;
9022 //                    RewriteRuleSubtreeStream stream_retval =
9023                             new RewriteRuleSubtreeStream(
9024                             adaptor, "rule retval",
9025                             retval != null ? retval.tree : null);
9026
9027                     root_0 = (CommonTree) adaptor.nil();
9028                     // 891:3: -> ^( TYPEALIAS ^( TYPEALIAS_TARGET
9029                     // typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
9030                     {
9031                         // Grammar/CTFParser.g:891:6: ^( TYPEALIAS ^(
9032                         // TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS
9033                         // typealiasAlias ) )
9034                         {
9035                             CommonTree root_1 = (CommonTree) adaptor.nil();
9036                             root_1 = (CommonTree) adaptor.becomeRoot(
9037                                     adaptor.create(TYPEALIAS, "TYPEALIAS"),
9038                                     root_1);
9039
9040                             // Grammar/CTFParser.g:891:18: ^( TYPEALIAS_TARGET
9041                             // typealiasTarget )
9042                             {
9043                                 CommonTree root_2 = (CommonTree) adaptor.nil();
9044                                 root_2 = (CommonTree) adaptor.becomeRoot(
9045                                         adaptor.create(TYPEALIAS_TARGET,
9046                                                 "TYPEALIAS_TARGET"), root_2);
9047
9048                                 adaptor.addChild(root_2,
9049                                         stream_typealiasTarget.nextTree());
9050
9051                                 adaptor.addChild(root_1, root_2);
9052                             }
9053                             // Grammar/CTFParser.g:891:54: ^( TYPEALIAS_ALIAS
9054                             // typealiasAlias )
9055                             {
9056                                 CommonTree root_2 = (CommonTree) adaptor.nil();
9057                                 root_2 = (CommonTree) adaptor.becomeRoot(
9058                                         adaptor.create(TYPEALIAS_ALIAS,
9059                                                 "TYPEALIAS_ALIAS"), root_2);
9060
9061                                 adaptor.addChild(root_2,
9062                                         stream_typealiasAlias.nextTree());
9063
9064                                 adaptor.addChild(root_1, root_2);
9065                             }
9066
9067                             adaptor.addChild(root_0, root_1);
9068                         }
9069
9070                     }
9071
9072                     retval.tree = root_0;
9073                 }
9074             }
9075
9076             retval.stop = input.LT(-1);
9077
9078             if (state.backtracking == 0) {
9079
9080                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
9081                 adaptor.setTokenBoundaries(retval.tree, retval.start,
9082                         retval.stop);
9083             }
9084             if (state.backtracking == 0) {
9085
9086                 exit("typealiasDecl");
9087
9088             }
9089         }
9090
9091         catch (RecognitionException e) {
9092             throw e;
9093
9094         }
9095         return retval;
9096     }
9097
9098     // $ANTLR end "typealiasDecl"
9099
9100     public static class ctfKeyword_return extends ParserRuleReturnScope {
9101         CommonTree tree;
9102
9103         @Override
9104         public Object getTree() {
9105             return tree;
9106         }
9107     }
9108
9109     // $ANTLR start "ctfKeyword"
9110     // Grammar/CTFParser.g:897:1: ctfKeyword : ( ALIGNTOK | EVENTTOK | SIGNEDTOK
9111     // | STRINGTOK );
9112     public final CTFParser.ctfKeyword_return ctfKeyword()
9113             throws RecognitionException {
9114         CTFParser.ctfKeyword_return retval = new CTFParser.ctfKeyword_return();
9115         retval.start = input.LT(1);
9116
9117         CommonTree root_0 = null;
9118
9119         Token set158 = null;
9120
9121         CommonTree set158_tree = null;
9122
9123         enter("ctfKeyword");
9124
9125         try {
9126             // Grammar/CTFParser.g:905:1: ( ALIGNTOK | EVENTTOK | SIGNEDTOK |
9127             // STRINGTOK )
9128             // Grammar/CTFParser.g:
9129             {
9130                 root_0 = (CommonTree) adaptor.nil();
9131
9132                 set158 = input.LT(1);
9133                 if ((input.LA(1) == ALIGNTOK) || (input.LA(1) == EVENTTOK)
9134                         || (input.LA(1) == SIGNEDTOK)
9135                         || (input.LA(1) == STRINGTOK)) {
9136                     input.consume();
9137                     if (state.backtracking == 0) {
9138                         adaptor.addChild(root_0, adaptor.create(set158));
9139                     }
9140                     state.errorRecovery = false;
9141                     state.failed = false;
9142                 } else {
9143                     if (state.backtracking > 0) {
9144                         state.failed = true;
9145                         return retval;
9146                     }
9147                     MismatchedSetException mse = new MismatchedSetException(
9148                             null, input);
9149                     throw mse;
9150                 }
9151
9152             }
9153
9154             retval.stop = input.LT(-1);
9155
9156             if (state.backtracking == 0) {
9157
9158                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
9159                 adaptor.setTokenBoundaries(retval.tree, retval.start,
9160                         retval.stop);
9161             }
9162             if (state.backtracking == 0) {
9163
9164                 debug_print(input.toString(retval.start, input.LT(-1)));
9165                 exit("ctfKeyword");
9166
9167             }
9168         }
9169
9170         catch (RecognitionException e) {
9171             throw e;
9172
9173         }
9174         return retval;
9175     }
9176
9177     // $ANTLR end "ctfKeyword"
9178
9179     public static class ctfSpecifier_return extends ParserRuleReturnScope {
9180         CommonTree tree;
9181
9182         @Override
9183         public Object getTree() {
9184             return tree;
9185         }
9186     }
9187
9188     // $ANTLR start "ctfSpecifier"
9189     // Grammar/CTFParser.g:912:1: ctfSpecifier : ( ctfSpecifierHead ctfBody ->
9190     // ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION
9191     // typealiasDecl ) );
9192     public final CTFParser.ctfSpecifier_return ctfSpecifier()
9193             throws RecognitionException {
9194         CTFParser.ctfSpecifier_return retval = new CTFParser.ctfSpecifier_return();
9195         retval.start = input.LT(1);
9196
9197         CommonTree root_0 = null;
9198
9199         CTFParser.ctfSpecifierHead_return ctfSpecifierHead159 = null;
9200
9201         CTFParser.ctfBody_return ctfBody160 = null;
9202
9203         CTFParser.typealiasDecl_return typealiasDecl161 = null;
9204
9205         RewriteRuleSubtreeStream stream_ctfSpecifierHead = new RewriteRuleSubtreeStream(
9206                 adaptor, "rule ctfSpecifierHead");
9207         RewriteRuleSubtreeStream stream_typealiasDecl = new RewriteRuleSubtreeStream(
9208                 adaptor, "rule typealiasDecl");
9209         RewriteRuleSubtreeStream stream_ctfBody = new RewriteRuleSubtreeStream(
9210                 adaptor, "rule ctfBody");
9211
9212         enter("ctfSpecifier");
9213
9214         try {
9215             // Grammar/CTFParser.g:919:3: ( ctfSpecifierHead ctfBody -> ^(
9216             // ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION
9217             // typealiasDecl ) )
9218             int alt52 = 2;
9219             int LA52_0 = input.LA(1);
9220
9221             if (((LA52_0 == EVENTTOK) || (LA52_0 == STREAMTOK)
9222                     || (LA52_0 == TRACETOK) || ((LA52_0 >= ENVTOK) && (LA52_0 <= CLOCKTOK)))) {
9223                 alt52 = 1;
9224             } else if ((LA52_0 == TYPEALIASTOK)) {
9225                 alt52 = 2;
9226             } else {
9227                 if (state.backtracking > 0) {
9228                     state.failed = true;
9229                     return retval;
9230                 }
9231                 NoViableAltException nvae = new NoViableAltException("", 52, 0,
9232                         input);
9233
9234                 throw nvae;
9235             }
9236             switch (alt52) {
9237             case 1:
9238             // Grammar/CTFParser.g:921:3: ctfSpecifierHead ctfBody
9239             {
9240                 pushFollow(FOLLOW_ctfSpecifierHead_in_ctfSpecifier3123);
9241                 ctfSpecifierHead159 = ctfSpecifierHead();
9242
9243                 state._fsp--;
9244                 if (state.failed) {
9245                     return retval;
9246                 }
9247                 if (state.backtracking == 0) {
9248                     stream_ctfSpecifierHead.add(ctfSpecifierHead159.getTree());
9249                 }
9250                 pushFollow(FOLLOW_ctfBody_in_ctfSpecifier3125);
9251                 ctfBody160 = ctfBody();
9252
9253                 state._fsp--;
9254                 if (state.failed) {
9255                     return retval;
9256                 }
9257                 if (state.backtracking == 0) {
9258                     stream_ctfBody.add(ctfBody160.getTree());
9259                 }
9260
9261                 // AST REWRITE
9262                 // elements: ctfBody, ctfSpecifierHead
9263                 // token labels:
9264                 // rule labels: retval
9265                 // token list labels:
9266                 // rule list labels:
9267                 // wildcard labels:
9268                 if (state.backtracking == 0) {
9269                     retval.tree = root_0;
9270 //                    RewriteRuleSubtreeStream stream_retval =
9271                             new RewriteRuleSubtreeStream(
9272                             adaptor, "rule retval",
9273                             retval != null ? retval.tree : null);
9274
9275                     root_0 = (CommonTree) adaptor.nil();
9276                     // 921:28: -> ^( ctfSpecifierHead ctfBody )
9277                     {
9278                         // Grammar/CTFParser.g:921:31: ^( ctfSpecifierHead
9279                         // ctfBody )
9280                         {
9281                             CommonTree root_1 = (CommonTree) adaptor.nil();
9282                             root_1 = (CommonTree) adaptor.becomeRoot(
9283                                     stream_ctfSpecifierHead.nextNode(), root_1);
9284
9285                             adaptor.addChild(root_1, stream_ctfBody.nextTree());
9286
9287                             adaptor.addChild(root_0, root_1);
9288                         }
9289
9290                     }
9291
9292                     retval.tree = root_0;
9293                 }
9294             }
9295                 break;
9296             case 2:
9297             // Grammar/CTFParser.g:924:3: typealiasDecl
9298             {
9299                 pushFollow(FOLLOW_typealiasDecl_in_ctfSpecifier3144);
9300                 typealiasDecl161 = typealiasDecl();
9301
9302                 state._fsp--;
9303                 if (state.failed) {
9304                     return retval;
9305                 }
9306                 if (state.backtracking == 0) {
9307                     stream_typealiasDecl.add(typealiasDecl161.getTree());
9308                 }
9309
9310                 // AST REWRITE
9311                 // elements: typealiasDecl
9312                 // token labels:
9313                 // rule labels: retval
9314                 // token list labels:
9315                 // rule list labels:
9316                 // wildcard labels:
9317                 if (state.backtracking == 0) {
9318                     retval.tree = root_0;
9319 //                    RewriteRuleSubtreeStream stream_retval =
9320                             new RewriteRuleSubtreeStream(
9321                             adaptor, "rule retval",
9322                             retval != null ? retval.tree : null);
9323
9324                     root_0 = (CommonTree) adaptor.nil();
9325                     // 924:17: -> ^( DECLARATION typealiasDecl )
9326                     {
9327                         // Grammar/CTFParser.g:924:20: ^( DECLARATION
9328                         // typealiasDecl )
9329                         {
9330                             CommonTree root_1 = (CommonTree) adaptor.nil();
9331                             root_1 = (CommonTree) adaptor.becomeRoot(
9332                                     adaptor.create(DECLARATION, "DECLARATION"),
9333                                     root_1);
9334
9335                             adaptor.addChild(root_1,
9336                                     stream_typealiasDecl.nextTree());
9337
9338                             adaptor.addChild(root_0, root_1);
9339                         }
9340
9341                     }
9342
9343                     retval.tree = root_0;
9344                 }
9345             }
9346                 break;
9347
9348             }
9349             retval.stop = input.LT(-1);
9350
9351             if (state.backtracking == 0) {
9352
9353                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
9354                 adaptor.setTokenBoundaries(retval.tree, retval.start,
9355                         retval.stop);
9356             }
9357             if (state.backtracking == 0) {
9358
9359                 exit("ctfSpecifier");
9360
9361             }
9362         }
9363
9364         catch (RecognitionException e) {
9365             throw e;
9366
9367         }
9368         return retval;
9369     }
9370
9371     // $ANTLR end "ctfSpecifier"
9372
9373     public static class ctfSpecifierHead_return extends ParserRuleReturnScope {
9374         CommonTree tree;
9375
9376         @Override
9377         public Object getTree() {
9378             return tree;
9379         }
9380     }
9381
9382     // $ANTLR start "ctfSpecifierHead"
9383     // Grammar/CTFParser.g:927:1: ctfSpecifierHead : ( EVENTTOK -> EVENT |
9384     // STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK ->
9385     // CLOCK );
9386     public final CTFParser.ctfSpecifierHead_return ctfSpecifierHead()
9387             throws RecognitionException {
9388         CTFParser.ctfSpecifierHead_return retval = new CTFParser.ctfSpecifierHead_return();
9389         retval.start = input.LT(1);
9390
9391         CommonTree root_0 = null;
9392
9393         Token EVENTTOK162 = null;
9394         Token STREAMTOK163 = null;
9395         Token TRACETOK164 = null;
9396         Token ENVTOK165 = null;
9397         Token CLOCKTOK166 = null;
9398
9399         CommonTree EVENTTOK162_tree = null;
9400         CommonTree STREAMTOK163_tree = null;
9401         CommonTree TRACETOK164_tree = null;
9402         CommonTree ENVTOK165_tree = null;
9403         CommonTree CLOCKTOK166_tree = null;
9404         RewriteRuleTokenStream stream_EVENTTOK = new RewriteRuleTokenStream(
9405                 adaptor, "token EVENTTOK");
9406         RewriteRuleTokenStream stream_STREAMTOK = new RewriteRuleTokenStream(
9407                 adaptor, "token STREAMTOK");
9408         RewriteRuleTokenStream stream_ENVTOK = new RewriteRuleTokenStream(
9409                 adaptor, "token ENVTOK");
9410         RewriteRuleTokenStream stream_CLOCKTOK = new RewriteRuleTokenStream(
9411                 adaptor, "token CLOCKTOK");
9412         RewriteRuleTokenStream stream_TRACETOK = new RewriteRuleTokenStream(
9413                 adaptor, "token TRACETOK");
9414
9415         enter("ctfSpecifierHead");
9416
9417         try {
9418             // Grammar/CTFParser.g:935:1: ( EVENTTOK -> EVENT | STREAMTOK ->
9419             // STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK )
9420             int alt53 = 5;
9421             switch (input.LA(1)) {
9422             case EVENTTOK: {
9423                 alt53 = 1;
9424             }
9425                 break;
9426             case STREAMTOK: {
9427                 alt53 = 2;
9428             }
9429                 break;
9430             case TRACETOK: {
9431                 alt53 = 3;
9432             }
9433                 break;
9434             case ENVTOK: {
9435                 alt53 = 4;
9436             }
9437                 break;
9438             case CLOCKTOK: {
9439                 alt53 = 5;
9440             }
9441                 break;
9442             default:
9443                 if (state.backtracking > 0) {
9444                     state.failed = true;
9445                     return retval;
9446                 }
9447                 NoViableAltException nvae = new NoViableAltException("", 53, 0,
9448                         input);
9449
9450                 throw nvae;
9451             }
9452
9453             switch (alt53) {
9454             case 1:
9455             // Grammar/CTFParser.g:936:4: EVENTTOK
9456             {
9457                 EVENTTOK162 = (Token) match(input, EVENTTOK,
9458                         FOLLOW_EVENTTOK_in_ctfSpecifierHead3176);
9459                 if (state.failed) {
9460                     return retval;
9461                 }
9462                 if (state.backtracking == 0) {
9463                     stream_EVENTTOK.add(EVENTTOK162);
9464                 }
9465
9466                 // AST REWRITE
9467                 // elements:
9468                 // token labels:
9469                 // rule labels: retval
9470                 // token list labels:
9471                 // rule list labels:
9472                 // wildcard labels:
9473                 if (state.backtracking == 0) {
9474                     retval.tree = root_0;
9475                     RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
9476                             adaptor, "rule retval",
9477                             retval != null ? retval.tree : null);
9478
9479                     root_0 = (CommonTree) adaptor.nil();
9480                     // 936:13: -> EVENT
9481                     {
9482                         adaptor.addChild(root_0, adaptor.create(EVENT, "EVENT"));
9483
9484                     }
9485
9486                     retval.tree = root_0;
9487                 }
9488             }
9489                 break;
9490             case 2:
9491             // Grammar/CTFParser.g:937:4: STREAMTOK
9492             {
9493                 STREAMTOK163 = (Token) match(input, STREAMTOK,
9494                         FOLLOW_STREAMTOK_in_ctfSpecifierHead3185);
9495                 if (state.failed) {
9496                     return retval;
9497                 }
9498                 if (state.backtracking == 0) {
9499                     stream_STREAMTOK.add(STREAMTOK163);
9500                 }
9501
9502                 // AST REWRITE
9503                 // elements:
9504                 // token labels:
9505                 // rule labels: retval
9506                 // token list labels:
9507                 // rule list labels:
9508                 // wildcard labels:
9509                 if (state.backtracking == 0) {
9510                     retval.tree = root_0;
9511                     RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
9512                             adaptor, "rule retval",
9513                             retval != null ? retval.tree : null);
9514
9515                     root_0 = (CommonTree) adaptor.nil();
9516                     // 937:14: -> STREAM
9517                     {
9518                         adaptor.addChild(root_0,
9519                                 adaptor.create(STREAM, "STREAM"));
9520
9521                     }
9522
9523                     retval.tree = root_0;
9524                 }
9525             }
9526                 break;
9527             case 3:
9528             // Grammar/CTFParser.g:938:4: TRACETOK
9529             {
9530                 TRACETOK164 = (Token) match(input, TRACETOK,
9531                         FOLLOW_TRACETOK_in_ctfSpecifierHead3194);
9532                 if (state.failed) {
9533                     return retval;
9534                 }
9535                 if (state.backtracking == 0) {
9536                     stream_TRACETOK.add(TRACETOK164);
9537                 }
9538
9539                 // AST REWRITE
9540                 // elements:
9541                 // token labels:
9542                 // rule labels: retval
9543                 // token list labels:
9544                 // rule list labels:
9545                 // wildcard labels:
9546                 if (state.backtracking == 0) {
9547                     retval.tree = root_0;
9548 //                    RewriteRuleSubtreeStream stream_retval =
9549                             new RewriteRuleSubtreeStream(
9550                             adaptor, "rule retval",
9551                             retval != null ? retval.tree : null);
9552
9553                     root_0 = (CommonTree) adaptor.nil();
9554                     // 938:13: -> TRACE
9555                     {
9556                         adaptor.addChild(root_0, adaptor.create(TRACE, "TRACE"));
9557
9558                     }
9559
9560                     retval.tree = root_0;
9561                 }
9562             }
9563                 break;
9564             case 4:
9565             // Grammar/CTFParser.g:939:4: ENVTOK
9566             {
9567                 ENVTOK165 = (Token) match(input, ENVTOK,
9568                         FOLLOW_ENVTOK_in_ctfSpecifierHead3203);
9569                 if (state.failed) {
9570                     return retval;
9571                 }
9572                 if (state.backtracking == 0) {
9573                     stream_ENVTOK.add(ENVTOK165);
9574                 }
9575
9576                 // AST REWRITE
9577                 // elements:
9578                 // token labels:
9579                 // rule labels: retval
9580                 // token list labels:
9581                 // rule list labels:
9582                 // wildcard labels:
9583                 if (state.backtracking == 0) {
9584                     retval.tree = root_0;
9585 //                    RewriteRuleSubtreeStream stream_retval =
9586                             new RewriteRuleSubtreeStream(
9587                             adaptor, "rule retval",
9588                             retval != null ? retval.tree : null);
9589
9590                     root_0 = (CommonTree) adaptor.nil();
9591                     // 939:11: -> ENV
9592                     {
9593                         adaptor.addChild(root_0, adaptor.create(ENV, "ENV"));
9594
9595                     }
9596
9597                     retval.tree = root_0;
9598                 }
9599             }
9600                 break;
9601             case 5:
9602             // Grammar/CTFParser.g:940:4: CLOCKTOK
9603             {
9604                 CLOCKTOK166 = (Token) match(input, CLOCKTOK,
9605                         FOLLOW_CLOCKTOK_in_ctfSpecifierHead3212);
9606                 if (state.failed) {
9607                     return retval;
9608                 }
9609                 if (state.backtracking == 0) {
9610                     stream_CLOCKTOK.add(CLOCKTOK166);
9611                 }
9612
9613                 // AST REWRITE
9614                 // elements:
9615                 // token labels:
9616                 // rule labels: retval
9617                 // token list labels:
9618                 // rule list labels:
9619                 // wildcard labels:
9620                 if (state.backtracking == 0) {
9621                     retval.tree = root_0;
9622 //                    RewriteRuleSubtreeStream stream_retval =
9623                             new RewriteRuleSubtreeStream(
9624                             adaptor, "rule retval",
9625                             retval != null ? retval.tree : null);
9626
9627                     root_0 = (CommonTree) adaptor.nil();
9628                     // 940:13: -> CLOCK
9629                     {
9630                         adaptor.addChild(root_0, adaptor.create(CLOCK, "CLOCK"));
9631
9632                     }
9633
9634                     retval.tree = root_0;
9635                 }
9636             }
9637                 break;
9638
9639             }
9640             retval.stop = input.LT(-1);
9641
9642             if (state.backtracking == 0) {
9643
9644                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
9645                 adaptor.setTokenBoundaries(retval.tree, retval.start,
9646                         retval.stop);
9647             }
9648             if (state.backtracking == 0) {
9649
9650                 debug_print(input.toString(retval.start, input.LT(-1)));
9651                 exit("ctfSpecifierHead");
9652
9653             }
9654         }
9655
9656         catch (RecognitionException e) {
9657             throw e;
9658
9659         }
9660         return retval;
9661     }
9662
9663     // $ANTLR end "ctfSpecifierHead"
9664
9665     public static class ctfTypeSpecifier_return extends ParserRuleReturnScope {
9666         CommonTree tree;
9667
9668         @Override
9669         public Object getTree() {
9670             return tree;
9671         }
9672     }
9673
9674     // $ANTLR start "ctfTypeSpecifier"
9675     // Grammar/CTFParser.g:943:1: ctfTypeSpecifier : ( FLOATINGPOINTTOK ctfBody
9676     // -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER (
9677     // ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) );
9678     public final CTFParser.ctfTypeSpecifier_return ctfTypeSpecifier()
9679             throws RecognitionException {
9680         CTFParser.ctfTypeSpecifier_return retval = new CTFParser.ctfTypeSpecifier_return();
9681         retval.start = input.LT(1);
9682
9683         CommonTree root_0 = null;
9684
9685         Token FLOATINGPOINTTOK167 = null;
9686         Token INTEGERTOK169 = null;
9687         Token STRINGTOK171 = null;
9688         CTFParser.ctfBody_return ctfBody168 = null;
9689
9690         CTFParser.ctfBody_return ctfBody170 = null;
9691
9692         CTFParser.ctfBody_return ctfBody172 = null;
9693
9694         CommonTree FLOATINGPOINTTOK167_tree = null;
9695         CommonTree INTEGERTOK169_tree = null;
9696         CommonTree STRINGTOK171_tree = null;
9697         RewriteRuleTokenStream stream_FLOATINGPOINTTOK = new RewriteRuleTokenStream(
9698                 adaptor, "token FLOATINGPOINTTOK");
9699         RewriteRuleTokenStream stream_STRINGTOK = new RewriteRuleTokenStream(
9700                 adaptor, "token STRINGTOK");
9701         RewriteRuleTokenStream stream_INTEGERTOK = new RewriteRuleTokenStream(
9702                 adaptor, "token INTEGERTOK");
9703         RewriteRuleSubtreeStream stream_ctfBody = new RewriteRuleSubtreeStream(
9704                 adaptor, "rule ctfBody");
9705
9706         enter("ctfTypeSpecifier");
9707
9708         try {
9709             // Grammar/CTFParser.g:950:1: ( FLOATINGPOINTTOK ctfBody -> ^(
9710             // FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER
9711             // ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )?
9712             // ) )
9713             int alt55 = 3;
9714             switch (input.LA(1)) {
9715             case FLOATINGPOINTTOK: {
9716                 alt55 = 1;
9717             }
9718                 break;
9719             case INTEGERTOK: {
9720                 alt55 = 2;
9721             }
9722                 break;
9723             case STRINGTOK: {
9724                 alt55 = 3;
9725             }
9726                 break;
9727             default:
9728                 if (state.backtracking > 0) {
9729                     state.failed = true;
9730                     return retval;
9731                 }
9732                 NoViableAltException nvae = new NoViableAltException("", 55, 0,
9733                         input);
9734
9735                 throw nvae;
9736             }
9737
9738             switch (alt55) {
9739             case 1:
9740             // Grammar/CTFParser.g:952:5: FLOATINGPOINTTOK ctfBody
9741             {
9742                 FLOATINGPOINTTOK167 = (Token) match(input, FLOATINGPOINTTOK,
9743                         FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3246);
9744                 if (state.failed) {
9745                     return retval;
9746                 }
9747                 if (state.backtracking == 0) {
9748                     stream_FLOATINGPOINTTOK.add(FLOATINGPOINTTOK167);
9749                 }
9750
9751                 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3248);
9752                 ctfBody168 = ctfBody();
9753
9754                 state._fsp--;
9755                 if (state.failed) {
9756                     return retval;
9757                 }
9758                 if (state.backtracking == 0) {
9759                     stream_ctfBody.add(ctfBody168.getTree());
9760                 }
9761
9762                 // AST REWRITE
9763                 // elements: ctfBody
9764                 // token labels:
9765                 // rule labels: retval
9766                 // token list labels:
9767                 // rule list labels:
9768                 // wildcard labels:
9769                 if (state.backtracking == 0) {
9770                     retval.tree = root_0;
9771 //                    RewriteRuleSubtreeStream stream_retval =
9772                             new RewriteRuleSubtreeStream(
9773                             adaptor, "rule retval",
9774                             retval != null ? retval.tree : null);
9775
9776                     root_0 = (CommonTree) adaptor.nil();
9777                     // 952:30: -> ^( FLOATING_POINT ( ctfBody )? )
9778                     {
9779                         // Grammar/CTFParser.g:952:33: ^( FLOATING_POINT (
9780                         // ctfBody )? )
9781                         {
9782                             CommonTree root_1 = (CommonTree) adaptor.nil();
9783                             root_1 = (CommonTree) adaptor.becomeRoot(adaptor
9784                                     .create(FLOATING_POINT, "FLOATING_POINT"),
9785                                     root_1);
9786
9787                             // Grammar/CTFParser.g:952:50: ( ctfBody )?
9788                             if (stream_ctfBody.hasNext()) {
9789                                 adaptor.addChild(root_1,
9790                                         stream_ctfBody.nextTree());
9791
9792                             }
9793                             stream_ctfBody.reset();
9794
9795                             adaptor.addChild(root_0, root_1);
9796                         }
9797
9798                     }
9799
9800                     retval.tree = root_0;
9801                 }
9802             }
9803                 break;
9804             case 2:
9805             // Grammar/CTFParser.g:953:5: INTEGERTOK ctfBody
9806             {
9807                 INTEGERTOK169 = (Token) match(input, INTEGERTOK,
9808                         FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3263);
9809                 if (state.failed) {
9810                     return retval;
9811                 }
9812                 if (state.backtracking == 0) {
9813                     stream_INTEGERTOK.add(INTEGERTOK169);
9814                 }
9815
9816                 pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3265);
9817                 ctfBody170 = ctfBody();
9818
9819                 state._fsp--;
9820                 if (state.failed) {
9821                     return retval;
9822                 }
9823                 if (state.backtracking == 0) {
9824                     stream_ctfBody.add(ctfBody170.getTree());
9825                 }
9826
9827                 // AST REWRITE
9828                 // elements: ctfBody
9829                 // token labels:
9830                 // rule labels: retval
9831                 // token list labels:
9832                 // rule list labels:
9833                 // wildcard labels:
9834                 if (state.backtracking == 0) {
9835                     retval.tree = root_0;
9836 //                    RewriteRuleSubtreeStream stream_retval =
9837                             new RewriteRuleSubtreeStream(
9838                             adaptor, "rule retval",
9839                             retval != null ? retval.tree : null);
9840
9841                     root_0 = (CommonTree) adaptor.nil();
9842                     // 953:24: -> ^( INTEGER ( ctfBody )? )
9843                     {
9844                         // Grammar/CTFParser.g:953:27: ^( INTEGER ( ctfBody )? )
9845                         {
9846                             CommonTree root_1 = (CommonTree) adaptor.nil();
9847                             root_1 = (CommonTree) adaptor.becomeRoot(
9848                                     adaptor.create(INTEGER, "INTEGER"), root_1);
9849
9850                             // Grammar/CTFParser.g:953:37: ( ctfBody )?
9851                             if (stream_ctfBody.hasNext()) {
9852                                 adaptor.addChild(root_1,
9853                                         stream_ctfBody.nextTree());
9854
9855                             }
9856                             stream_ctfBody.reset();
9857
9858                             adaptor.addChild(root_0, root_1);
9859                         }
9860
9861                     }
9862
9863                     retval.tree = root_0;
9864                 }
9865             }
9866                 break;
9867             case 3:
9868             // Grammar/CTFParser.g:954:5: STRINGTOK ( ctfBody )?
9869             {
9870                 STRINGTOK171 = (Token) match(input, STRINGTOK,
9871                         FOLLOW_STRINGTOK_in_ctfTypeSpecifier3280);
9872                 if (state.failed) {
9873                     return retval;
9874                 }
9875                 if (state.backtracking == 0) {
9876                     stream_STRINGTOK.add(STRINGTOK171);
9877                 }
9878
9879                 // Grammar/CTFParser.g:954:15: ( ctfBody )?
9880                 int alt54 = 2;
9881                 alt54 = dfa54.predict(input);
9882                 switch (alt54) {
9883                 case 1:
9884                 // Grammar/CTFParser.g:954:15: ctfBody
9885                 {
9886                     pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3282);
9887                     ctfBody172 = ctfBody();
9888
9889                     state._fsp--;
9890                     if (state.failed) {
9891                         return retval;
9892                     }
9893                     if (state.backtracking == 0) {
9894                         stream_ctfBody.add(ctfBody172.getTree());
9895                     }
9896
9897                 }
9898                     break;
9899
9900                 }
9901
9902                 // AST REWRITE
9903                 // elements: ctfBody
9904                 // token labels:
9905                 // rule labels: retval
9906                 // token list labels:
9907                 // rule list labels:
9908                 // wildcard labels:
9909                 if (state.backtracking == 0) {
9910                     retval.tree = root_0;
9911 //                    RewriteRuleSubtreeStream stream_retval =
9912                             new RewriteRuleSubtreeStream(
9913                             adaptor, "rule retval",
9914                             retval != null ? retval.tree : null);
9915
9916                     root_0 = (CommonTree) adaptor.nil();
9917                     // 954:24: -> ^( STRING ( ctfBody )? )
9918                     {
9919                         // Grammar/CTFParser.g:954:27: ^( STRING ( ctfBody )? )
9920                         {
9921                             CommonTree root_1 = (CommonTree) adaptor.nil();
9922                             root_1 = (CommonTree) adaptor.becomeRoot(
9923                                     adaptor.create(STRING, "STRING"), root_1);
9924
9925                             // Grammar/CTFParser.g:954:36: ( ctfBody )?
9926                             if (stream_ctfBody.hasNext()) {
9927                                 adaptor.addChild(root_1,
9928                                         stream_ctfBody.nextTree());
9929
9930                             }
9931                             stream_ctfBody.reset();
9932
9933                             adaptor.addChild(root_0, root_1);
9934                         }
9935
9936                     }
9937
9938                     retval.tree = root_0;
9939                 }
9940             }
9941                 break;
9942
9943             }
9944             retval.stop = input.LT(-1);
9945
9946             if (state.backtracking == 0) {
9947
9948                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
9949                 adaptor.setTokenBoundaries(retval.tree, retval.start,
9950                         retval.stop);
9951             }
9952             if (state.backtracking == 0) {
9953
9954                 exit("ctfTypeSpecifier");
9955
9956             }
9957         }
9958
9959         catch (RecognitionException e) {
9960             throw e;
9961
9962         }
9963         return retval;
9964     }
9965
9966     // $ANTLR end "ctfTypeSpecifier"
9967
9968     public static class ctfBody_return extends ParserRuleReturnScope {
9969         CommonTree tree;
9970
9971         @Override
9972         public Object getTree() {
9973             return tree;
9974         }
9975     }
9976
9977     // $ANTLR start "ctfBody"
9978     // Grammar/CTFParser.g:957:1: ctfBody : LCURL ( ctfAssignmentExpressionList
9979     // )? RCURL -> ( ctfAssignmentExpressionList )? ;
9980     public final CTFParser.ctfBody_return ctfBody() throws RecognitionException {
9981         Symbols_stack.push(new Symbols_scope());
9982
9983         CTFParser.ctfBody_return retval = new CTFParser.ctfBody_return();
9984         retval.start = input.LT(1);
9985
9986         CommonTree root_0 = null;
9987
9988         Token LCURL173 = null;
9989         Token RCURL175 = null;
9990         CTFParser.ctfAssignmentExpressionList_return ctfAssignmentExpressionList174 = null;
9991
9992         CommonTree LCURL173_tree = null;
9993         CommonTree RCURL175_tree = null;
9994         RewriteRuleTokenStream stream_LCURL = new RewriteRuleTokenStream(
9995                 adaptor, "token LCURL");
9996         RewriteRuleTokenStream stream_RCURL = new RewriteRuleTokenStream(
9997                 adaptor, "token RCURL");
9998         RewriteRuleSubtreeStream stream_ctfAssignmentExpressionList = new RewriteRuleSubtreeStream(
9999                 adaptor, "rule ctfAssignmentExpressionList");
10000
10001         enter("ctfBody");
10002         debug_print("Scope push " + +Symbols_stack.size());
10003         ((Symbols_scope) Symbols_stack.peek()).types = new HashSet<String>();
10004
10005         try {
10006             // Grammar/CTFParser.g:968:1: ( LCURL ( ctfAssignmentExpressionList
10007             // )? RCURL -> ( ctfAssignmentExpressionList )? )
10008             // Grammar/CTFParser.g:969:3: LCURL ( ctfAssignmentExpressionList )?
10009             // RCURL
10010             {
10011                 LCURL173 = (Token) match(input, LCURL,
10012                         FOLLOW_LCURL_in_ctfBody3320);
10013                 if (state.failed) {
10014                     return retval;
10015                 }
10016                 if (state.backtracking == 0) {
10017                     stream_LCURL.add(LCURL173);
10018                 }
10019
10020                 // Grammar/CTFParser.g:969:9: ( ctfAssignmentExpressionList )?
10021                 int alt56 = 2;
10022                 int LA56_0 = input.LA(1);
10023
10024                 if ((((LA56_0 >= ALIGNTOK) && (LA56_0 <= CLOCKTOK))
10025                         || (LA56_0 == SIGN) || (LA56_0 == OCTAL_LITERAL)
10026                         || (LA56_0 == DECIMAL_LITERAL)
10027                         || (LA56_0 == HEX_LITERAL)
10028                         || (LA56_0 == CHARACTER_LITERAL)
10029                         || (LA56_0 == STRING_LITERAL) || (LA56_0 == IDENTIFIER))) {
10030                     alt56 = 1;
10031                 }
10032                 switch (alt56) {
10033                 case 1:
10034                 // Grammar/CTFParser.g:969:9: ctfAssignmentExpressionList
10035                 {
10036                     pushFollow(FOLLOW_ctfAssignmentExpressionList_in_ctfBody3322);
10037                     ctfAssignmentExpressionList174 = ctfAssignmentExpressionList();
10038
10039                     state._fsp--;
10040                     if (state.failed) {
10041                         return retval;
10042                     }
10043                     if (state.backtracking == 0) {
10044                         stream_ctfAssignmentExpressionList
10045                                 .add(ctfAssignmentExpressionList174.getTree());
10046                     }
10047
10048                 }
10049                     break;
10050
10051                 }
10052
10053                 RCURL175 = (Token) match(input, RCURL,
10054                         FOLLOW_RCURL_in_ctfBody3325);
10055                 if (state.failed) {
10056                     return retval;
10057                 }
10058                 if (state.backtracking == 0) {
10059                     stream_RCURL.add(RCURL175);
10060                 }
10061
10062                 // AST REWRITE
10063                 // elements: ctfAssignmentExpressionList
10064                 // token labels:
10065                 // rule labels: retval
10066                 // token list labels:
10067                 // rule list labels:
10068                 // wildcard labels:
10069                 if (state.backtracking == 0) {
10070                     retval.tree = root_0;
10071 //                    RewriteRuleSubtreeStream stream_retval =
10072                             new RewriteRuleSubtreeStream(
10073                             adaptor, "rule retval",
10074                             retval != null ? retval.tree : null);
10075
10076                     root_0 = (CommonTree) adaptor.nil();
10077                     // 969:44: -> ( ctfAssignmentExpressionList )?
10078                     {
10079                         // Grammar/CTFParser.g:969:47: (
10080                         // ctfAssignmentExpressionList )?
10081                         if (stream_ctfAssignmentExpressionList.hasNext()) {
10082                             adaptor.addChild(root_0,
10083                                     stream_ctfAssignmentExpressionList
10084                                             .nextTree());
10085
10086                         }
10087                         stream_ctfAssignmentExpressionList.reset();
10088
10089                     }
10090
10091                     retval.tree = root_0;
10092                 }
10093             }
10094
10095             retval.stop = input.LT(-1);
10096
10097             if (state.backtracking == 0) {
10098
10099                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
10100                 adaptor.setTokenBoundaries(retval.tree, retval.start,
10101                         retval.stop);
10102             }
10103             if (state.backtracking == 0) {
10104
10105                 debug_print("Scope pop " + +Symbols_stack.size());
10106                 exit("ctfBody");
10107
10108             }
10109         }
10110
10111         catch (RecognitionException e) {
10112             throw e;
10113         } finally {
10114             Symbols_stack.pop();
10115
10116         }
10117         return retval;
10118     }
10119
10120     // $ANTLR end "ctfBody"
10121
10122     public static class ctfAssignmentExpressionList_return extends
10123             ParserRuleReturnScope {
10124         CommonTree tree;
10125
10126         @Override
10127         public Object getTree() {
10128             return tree;
10129         }
10130     }
10131
10132     // $ANTLR start "ctfAssignmentExpressionList"
10133     // Grammar/CTFParser.g:972:1: ctfAssignmentExpressionList : (
10134     // ctfAssignmentExpression TERM )+ ;
10135     public final CTFParser.ctfAssignmentExpressionList_return ctfAssignmentExpressionList()
10136             throws RecognitionException {
10137         CTFParser.ctfAssignmentExpressionList_return retval = new CTFParser.ctfAssignmentExpressionList_return();
10138         retval.start = input.LT(1);
10139
10140         CommonTree root_0 = null;
10141
10142         Token TERM177 = null;
10143         CTFParser.ctfAssignmentExpression_return ctfAssignmentExpression176 = null;
10144
10145         CommonTree TERM177_tree = null;
10146
10147         try {
10148             // Grammar/CTFParser.g:972:29: ( ( ctfAssignmentExpression TERM )+ )
10149             // Grammar/CTFParser.g:973:3: ( ctfAssignmentExpression TERM )+
10150             {
10151                 root_0 = (CommonTree) adaptor.nil();
10152
10153                 // Grammar/CTFParser.g:973:3: ( ctfAssignmentExpression TERM )+
10154                 int cnt57 = 0;
10155                 loop57: do {
10156                     int alt57 = 2;
10157                     int LA57_0 = input.LA(1);
10158
10159                     if ((((LA57_0 >= ALIGNTOK) && (LA57_0 <= CLOCKTOK))
10160                             || (LA57_0 == SIGN) || (LA57_0 == OCTAL_LITERAL)
10161                             || (LA57_0 == DECIMAL_LITERAL)
10162                             || (LA57_0 == HEX_LITERAL)
10163                             || (LA57_0 == CHARACTER_LITERAL)
10164                             || (LA57_0 == STRING_LITERAL) || (LA57_0 == IDENTIFIER))) {
10165                         alt57 = 1;
10166                     }
10167
10168                     switch (alt57) {
10169                     case 1:
10170                     // Grammar/CTFParser.g:973:4: ctfAssignmentExpression TERM
10171                     {
10172                         pushFollow(FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3344);
10173                         ctfAssignmentExpression176 = ctfAssignmentExpression();
10174
10175                         state._fsp--;
10176                         if (state.failed) {
10177                             return retval;
10178                         }
10179                         if (state.backtracking == 0) {
10180                             adaptor.addChild(root_0,
10181                                     ctfAssignmentExpression176.getTree());
10182                         }
10183                         TERM177 = (Token) match(input, TERM,
10184                                 FOLLOW_TERM_in_ctfAssignmentExpressionList3346);
10185                         if (state.failed) {
10186                             return retval;
10187                         }
10188
10189                     }
10190                         break;
10191
10192                     default:
10193                         if (cnt57 >= 1) {
10194                             break loop57;
10195                         }
10196                         if (state.backtracking > 0) {
10197                             state.failed = true;
10198                             return retval;
10199                         }
10200                         EarlyExitException eee = new EarlyExitException(57,
10201                                 input);
10202                         throw eee;
10203                     }
10204                     cnt57++;
10205                 } while (true);
10206
10207             }
10208
10209             retval.stop = input.LT(-1);
10210
10211             if (state.backtracking == 0) {
10212
10213                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
10214                 adaptor.setTokenBoundaries(retval.tree, retval.start,
10215                         retval.stop);
10216             }
10217         }
10218
10219         catch (RecognitionException e) {
10220             throw e;
10221
10222         }
10223         return retval;
10224     }
10225
10226     // $ANTLR end "ctfAssignmentExpressionList"
10227
10228     public static class ctfAssignmentExpression_return extends
10229             ParserRuleReturnScope {
10230         CommonTree tree;
10231
10232         @Override
10233         public Object getTree() {
10234             return tree;
10235         }
10236     }
10237
10238     // $ANTLR start "ctfAssignmentExpression"
10239     // Grammar/CTFParser.g:977:1: ctfAssignmentExpression : ( (left=
10240     // unaryExpression ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
10241     // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
10242     // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^(
10243     // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
10244     // TYPE_SPECIFIER_LIST $right2) ) ) ) ) | ( declarationSpecifiers {...}?
10245     // declaratorList ) -> ^( TYPEDEF declaratorList declarationSpecifiers ) |
10246     // typealiasDecl );
10247     public final CTFParser.ctfAssignmentExpression_return ctfAssignmentExpression()
10248             throws RecognitionException {
10249         CTFParser.ctfAssignmentExpression_return retval = new CTFParser.ctfAssignmentExpression_return();
10250         retval.start = input.LT(1);
10251
10252         CommonTree root_0 = null;
10253
10254         Token assignment = null;
10255         Token type_assignment = null;
10256         CTFParser.unaryExpression_return left = null;
10257
10258         CTFParser.unaryExpression_return right1 = null;
10259
10260         CTFParser.typeSpecifier_return right2 = null;
10261
10262         CTFParser.declarationSpecifiers_return declarationSpecifiers178 = null;
10263
10264         CTFParser.declaratorList_return declaratorList179 = null;
10265
10266         CTFParser.typealiasDecl_return typealiasDecl180 = null;
10267
10268         CommonTree assignment_tree = null;
10269         CommonTree type_assignment_tree = null;
10270         RewriteRuleTokenStream stream_ASSIGNMENT = new RewriteRuleTokenStream(
10271                 adaptor, "token ASSIGNMENT");
10272         RewriteRuleTokenStream stream_TYPE_ASSIGNMENT = new RewriteRuleTokenStream(
10273                 adaptor, "token TYPE_ASSIGNMENT");
10274         RewriteRuleSubtreeStream stream_declaratorList = new RewriteRuleSubtreeStream(
10275                 adaptor, "rule declaratorList");
10276         RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(
10277                 adaptor, "rule unaryExpression");
10278         RewriteRuleSubtreeStream stream_declarationSpecifiers = new RewriteRuleSubtreeStream(
10279                 adaptor, "rule declarationSpecifiers");
10280         RewriteRuleSubtreeStream stream_typeSpecifier = new RewriteRuleSubtreeStream(
10281                 adaptor, "rule typeSpecifier");
10282
10283         enter("ctfAssignmentExpression");
10284
10285         try {
10286             // Grammar/CTFParser.g:987:1: ( (left= unaryExpression (
10287             // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
10288             // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
10289             // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^(
10290             // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
10291             // TYPE_SPECIFIER_LIST $right2) ) ) ) ) | ( declarationSpecifiers
10292             // {...}? declaratorList ) -> ^( TYPEDEF declaratorList
10293             // declarationSpecifiers ) | typealiasDecl )
10294             int alt59 = 3;
10295             switch (input.LA(1)) {
10296             case IDENTIFIER: {
10297                 int LA59_1 = input.LA(2);
10298
10299                 if ((((LA59_1 >= CONSTTOK) && (LA59_1 <= ENUMTOK))
10300                         || ((LA59_1 >= FLOATINGPOINTTOK) && (LA59_1 <= SIGNEDTOK))
10301                         || ((LA59_1 >= STRINGTOK) && (LA59_1 <= STRUCTTOK))
10302                         || ((LA59_1 >= TYPEDEFTOK) && (LA59_1 <= IMAGINARYTOK))
10303                         || (LA59_1 == POINTER) || (LA59_1 == IDENTIFIER))
10304                         && ((inTypealiasAlias() || isTypeName(input.LT(1)
10305                                 .getText())))) {
10306                     alt59 = 2;
10307                 } else if ((((LA59_1 >= ASSIGNMENT) && (LA59_1 <= TYPE_ASSIGNMENT))
10308                         || (LA59_1 == OPENBRAC) || ((LA59_1 >= ARROW) && (LA59_1 <= DOT)))) {
10309                     alt59 = 1;
10310                 } else {
10311                     if (state.backtracking > 0) {
10312                         state.failed = true;
10313                         return retval;
10314                     }
10315                     NoViableAltException nvae = new NoViableAltException("",
10316                             59, 1, input);
10317
10318                     throw nvae;
10319                 }
10320             }
10321                 break;
10322             case ALIGNTOK:
10323             case EVENTTOK:
10324             case STREAMTOK:
10325             case TRACETOK:
10326             case ENVTOK:
10327             case CLOCKTOK:
10328             case SIGN:
10329             case OCTAL_LITERAL:
10330             case DECIMAL_LITERAL:
10331             case HEX_LITERAL:
10332             case CHARACTER_LITERAL:
10333             case STRING_LITERAL: {
10334                 alt59 = 1;
10335             }
10336                 break;
10337             case SIGNEDTOK: {
10338                 switch (input.LA(2)) {
10339                 case ASSIGNMENT:
10340                 case TYPE_ASSIGNMENT:
10341                 case OPENBRAC:
10342                 case ARROW:
10343                 case DOT: {
10344                     alt59 = 1;
10345                 }
10346                     break;
10347                 case CONSTTOK:
10348                 case CHARTOK:
10349                 case DOUBLETOK:
10350                 case ENUMTOK:
10351                 case FLOATINGPOINTTOK:
10352                 case FLOATTOK:
10353                 case INTEGERTOK:
10354                 case INTTOK:
10355                 case LONGTOK:
10356                 case SHORTTOK:
10357                 case SIGNEDTOK:
10358                 case STRINGTOK:
10359                 case STRUCTTOK:
10360                 case UNSIGNEDTOK:
10361                 case VARIANTTOK:
10362                 case VOIDTOK:
10363                 case BOOLTOK:
10364                 case COMPLEXTOK:
10365                 case IMAGINARYTOK:
10366                 case POINTER:
10367                 case IDENTIFIER: {
10368                     alt59 = 2;
10369                 }
10370                     break;
10371                 case TYPEDEFTOK: {
10372                     alt59 = 2;
10373                 }
10374                     break;
10375                 default:
10376                     if (state.backtracking > 0) {
10377                         state.failed = true;
10378                         return retval;
10379                     }
10380                     NoViableAltException nvae = new NoViableAltException("",
10381                             59, 3, input);
10382
10383                     throw nvae;
10384                 }
10385
10386             }
10387                 break;
10388             case CONSTTOK:
10389             case CHARTOK:
10390             case DOUBLETOK:
10391             case ENUMTOK:
10392             case FLOATINGPOINTTOK:
10393             case FLOATTOK:
10394             case INTEGERTOK:
10395             case INTTOK:
10396             case LONGTOK:
10397             case SHORTTOK:
10398             case STRUCTTOK:
10399             case TYPEDEFTOK:
10400             case UNSIGNEDTOK:
10401             case VARIANTTOK:
10402             case VOIDTOK:
10403             case BOOLTOK:
10404             case COMPLEXTOK:
10405             case IMAGINARYTOK: {
10406                 alt59 = 2;
10407             }
10408                 break;
10409             case STRINGTOK: {
10410                 switch (input.LA(2)) {
10411                 case ASSIGNMENT:
10412                 case TYPE_ASSIGNMENT:
10413                 case OPENBRAC:
10414                 case ARROW:
10415                 case DOT: {
10416                     alt59 = 1;
10417                 }
10418                     break;
10419                 case CONSTTOK:
10420                 case CHARTOK:
10421                 case DOUBLETOK:
10422                 case ENUMTOK:
10423                 case FLOATINGPOINTTOK:
10424                 case FLOATTOK:
10425                 case INTEGERTOK:
10426                 case INTTOK:
10427                 case LONGTOK:
10428                 case SHORTTOK:
10429                 case SIGNEDTOK:
10430                 case STRINGTOK:
10431                 case STRUCTTOK:
10432                 case UNSIGNEDTOK:
10433                 case VARIANTTOK:
10434                 case VOIDTOK:
10435                 case BOOLTOK:
10436                 case COMPLEXTOK:
10437                 case IMAGINARYTOK:
10438                 case LCURL:
10439                 case POINTER:
10440                 case IDENTIFIER: {
10441                     alt59 = 2;
10442                 }
10443                     break;
10444                 case TYPEDEFTOK: {
10445                     alt59 = 2;
10446                 }
10447                     break;
10448                 default:
10449                     if (state.backtracking > 0) {
10450                         state.failed = true;
10451                         return retval;
10452                     }
10453                     NoViableAltException nvae = new NoViableAltException("",
10454                             59, 5, input);
10455
10456                     throw nvae;
10457                 }
10458
10459             }
10460                 break;
10461             case TYPEALIASTOK: {
10462                 alt59 = 3;
10463             }
10464                 break;
10465             default:
10466                 if (state.backtracking > 0) {
10467                     state.failed = true;
10468                     return retval;
10469                 }
10470                 NoViableAltException nvae = new NoViableAltException("", 59, 0,
10471                         input);
10472
10473                 throw nvae;
10474             }
10475
10476             switch (alt59) {
10477             case 1:
10478             // Grammar/CTFParser.g:988:3: (left= unaryExpression ( (assignment=
10479             // ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^(
10480             // CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment=
10481             // TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE
10482             // ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) )
10483             // ) ) )
10484             {
10485                 // Grammar/CTFParser.g:988:3: (left= unaryExpression (
10486                 // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
10487                 // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
10488                 // | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
10489                 // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
10490                 // TYPE_SPECIFIER_LIST $right2) ) ) ) )
10491                 // Grammar/CTFParser.g:989:5: left= unaryExpression (
10492                 // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
10493                 // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
10494                 // | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
10495                 // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
10496                 // TYPE_SPECIFIER_LIST $right2) ) ) )
10497                 {
10498                     pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3381);
10499                     left = unaryExpression();
10500
10501                     state._fsp--;
10502                     if (state.failed) {
10503                         return retval;
10504                     }
10505                     if (state.backtracking == 0) {
10506                         stream_unaryExpression.add(left.getTree());
10507                     }
10508                     // Grammar/CTFParser.g:990:5: ( (assignment= ASSIGNMENT
10509                     // right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^(
10510                     // CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
10511                     // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
10512                     // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT
10513                     // ^( TYPE_SPECIFIER_LIST $right2) ) ) )
10514                     int alt58 = 2;
10515                     int LA58_0 = input.LA(1);
10516
10517                     if ((LA58_0 == ASSIGNMENT)) {
10518                         alt58 = 1;
10519                     } else if ((LA58_0 == TYPE_ASSIGNMENT)) {
10520                         alt58 = 2;
10521                     } else {
10522                         if (state.backtracking > 0) {
10523                             state.failed = true;
10524                             return retval;
10525                         }
10526                         NoViableAltException nvae = new NoViableAltException(
10527                                 "", 58, 0, input);
10528
10529                         throw nvae;
10530                     }
10531                     switch (alt58) {
10532                     case 1:
10533                     // Grammar/CTFParser.g:991:9: (assignment= ASSIGNMENT
10534                     // right1= unaryExpression )
10535                     {
10536                         // Grammar/CTFParser.g:991:9: (assignment= ASSIGNMENT
10537                         // right1= unaryExpression )
10538                         // Grammar/CTFParser.g:991:10: assignment= ASSIGNMENT
10539                         // right1= unaryExpression
10540                         {
10541                             assignment = (Token) match(input, ASSIGNMENT,
10542                                     FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3400);
10543                             if (state.failed) {
10544                                 return retval;
10545                             }
10546                             if (state.backtracking == 0) {
10547                                 stream_ASSIGNMENT.add(assignment);
10548                             }
10549
10550                             pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3404);
10551                             right1 = unaryExpression();
10552
10553                             state._fsp--;
10554                             if (state.failed) {
10555                                 return retval;
10556                             }
10557                             if (state.backtracking == 0) {
10558                                 stream_unaryExpression.add(right1.getTree());
10559                             }
10560
10561                         }
10562
10563                         // AST REWRITE
10564                         // elements: right1, left
10565                         // token labels:
10566                         // rule labels: retval, left, right1
10567                         // token list labels:
10568                         // rule list labels:
10569                         // wildcard labels:
10570                         if (state.backtracking == 0) {
10571                             retval.tree = root_0;
10572                             RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
10573                                     adaptor, "rule retval",
10574                                     retval != null ? retval.tree : null);
10575                             RewriteRuleSubtreeStream stream_left = new RewriteRuleSubtreeStream(
10576                                     adaptor, "rule left",
10577                                     left != null ? left.tree : null);
10578                             RewriteRuleSubtreeStream stream_right1 = new RewriteRuleSubtreeStream(
10579                                     adaptor, "rule right1",
10580                                     right1 != null ? right1.tree : null);
10581
10582                             root_0 = (CommonTree) adaptor.nil();
10583                             // 991:56: -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT
10584                             // $left) ^( CTF_RIGHT $right1) )
10585                             {
10586                                 // Grammar/CTFParser.g:991:59: ^(
10587                                 // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^(
10588                                 // CTF_RIGHT $right1) )
10589                                 {
10590                                     CommonTree root_1 = (CommonTree) adaptor
10591                                             .nil();
10592                                     root_1 = (CommonTree) adaptor.becomeRoot(
10593                                             adaptor.create(CTF_EXPRESSION_VAL,
10594                                                     "CTF_EXPRESSION_VAL"),
10595                                             root_1);
10596
10597                                     // Grammar/CTFParser.g:991:80: ^( CTF_LEFT
10598                                     // $left)
10599                                     {
10600                                         CommonTree root_2 = (CommonTree) adaptor
10601                                                 .nil();
10602                                         root_2 = (CommonTree) adaptor
10603                                                 .becomeRoot(adaptor.create(
10604                                                         CTF_LEFT, "CTF_LEFT"),
10605                                                         root_2);
10606
10607                                         adaptor.addChild(root_2,
10608                                                 stream_left.nextTree());
10609
10610                                         adaptor.addChild(root_1, root_2);
10611                                     }
10612                                     // Grammar/CTFParser.g:991:98: ^( CTF_RIGHT
10613                                     // $right1)
10614                                     {
10615                                         CommonTree root_2 = (CommonTree) adaptor
10616                                                 .nil();
10617                                         root_2 = (CommonTree) adaptor
10618                                                 .becomeRoot(
10619                                                         adaptor.create(
10620                                                                 CTF_RIGHT,
10621                                                                 "CTF_RIGHT"),
10622                                                         root_2);
10623
10624                                         adaptor.addChild(root_2,
10625                                                 stream_right1.nextTree());
10626
10627                                         adaptor.addChild(root_1, root_2);
10628                                     }
10629
10630                                     adaptor.addChild(root_0, root_1);
10631                                 }
10632
10633                             }
10634
10635                             retval.tree = root_0;
10636                         }
10637                     }
10638                         break;
10639                     case 2:
10640                     // Grammar/CTFParser.g:992:9: (type_assignment=
10641                     // TYPE_ASSIGNMENT right2= typeSpecifier )
10642                     {
10643                         // Grammar/CTFParser.g:992:9: (type_assignment=
10644                         // TYPE_ASSIGNMENT right2= typeSpecifier )
10645                         // Grammar/CTFParser.g:992:10: type_assignment=
10646                         // TYPE_ASSIGNMENT right2= typeSpecifier
10647                         {
10648                             type_assignment = (Token) match(input,
10649                                     TYPE_ASSIGNMENT,
10650                                     FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3438);
10651                             if (state.failed) {
10652                                 return retval;
10653                             }
10654                             if (state.backtracking == 0) {
10655                                 stream_TYPE_ASSIGNMENT.add(type_assignment);
10656                             }
10657
10658                             pushFollow(FOLLOW_typeSpecifier_in_ctfAssignmentExpression3443);
10659                             right2 = typeSpecifier();
10660
10661                             state._fsp--;
10662                             if (state.failed) {
10663                                 return retval;
10664                             }
10665                             if (state.backtracking == 0) {
10666                                 stream_typeSpecifier.add(right2.getTree());
10667                             }
10668
10669                         }
10670
10671                         // AST REWRITE
10672                         // elements: left, right2
10673                         // token labels:
10674                         // rule labels: retval, left, right2
10675                         // token list labels:
10676                         // rule list labels:
10677                         // wildcard labels:
10678                         if (state.backtracking == 0) {
10679                             retval.tree = root_0;
10680                             RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
10681                                     adaptor, "rule retval",
10682                                     retval != null ? retval.tree : null);
10683                             RewriteRuleSubtreeStream stream_left = new RewriteRuleSubtreeStream(
10684                                     adaptor, "rule left",
10685                                     left != null ? left.tree : null);
10686                             RewriteRuleSubtreeStream stream_right2 = new RewriteRuleSubtreeStream(
10687                                     adaptor, "rule right2",
10688                                     right2 != null ? right2.tree : null);
10689
10690                             root_0 = (CommonTree) adaptor.nil();
10691                             // 992:65: -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT
10692                             // $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST
10693                             // $right2) ) )
10694                             {
10695                                 // Grammar/CTFParser.g:992:68: ^(
10696                                 // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^(
10697                                 // CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
10698                                 {
10699                                     CommonTree root_1 = (CommonTree) adaptor
10700                                             .nil();
10701                                     root_1 = (CommonTree) adaptor.becomeRoot(
10702                                             adaptor.create(CTF_EXPRESSION_TYPE,
10703                                                     "CTF_EXPRESSION_TYPE"),
10704                                             root_1);
10705
10706                                     // Grammar/CTFParser.g:992:90: ^( CTF_LEFT
10707                                     // $left)
10708                                     {
10709                                         CommonTree root_2 = (CommonTree) adaptor
10710                                                 .nil();
10711                                         root_2 = (CommonTree) adaptor
10712                                                 .becomeRoot(adaptor.create(
10713                                                         CTF_LEFT, "CTF_LEFT"),
10714                                                         root_2);
10715
10716                                         adaptor.addChild(root_2,
10717                                                 stream_left.nextTree());
10718
10719                                         adaptor.addChild(root_1, root_2);
10720                                     }
10721                                     // Grammar/CTFParser.g:992:108: ^( CTF_RIGHT
10722                                     // ^( TYPE_SPECIFIER_LIST $right2) )
10723                                     {
10724                                         CommonTree root_2 = (CommonTree) adaptor
10725                                                 .nil();
10726                                         root_2 = (CommonTree) adaptor
10727                                                 .becomeRoot(
10728                                                         adaptor.create(
10729                                                                 CTF_RIGHT,
10730                                                                 "CTF_RIGHT"),
10731                                                         root_2);
10732
10733                                         // Grammar/CTFParser.g:992:120: ^(
10734                                         // TYPE_SPECIFIER_LIST $right2)
10735                                         {
10736                                             CommonTree root_3 = (CommonTree) adaptor
10737                                                     .nil();
10738                                             root_3 = (CommonTree) adaptor
10739                                                     .becomeRoot(
10740                                                             adaptor.create(
10741                                                                     TYPE_SPECIFIER_LIST,
10742                                                                     "TYPE_SPECIFIER_LIST"),
10743                                                             root_3);
10744
10745                                             adaptor.addChild(root_3,
10746                                                     stream_right2.nextTree());
10747
10748                                             adaptor.addChild(root_2, root_3);
10749                                         }
10750
10751                                         adaptor.addChild(root_1, root_2);
10752                                     }
10753
10754                                     adaptor.addChild(root_0, root_1);
10755                                 }
10756
10757                             }
10758
10759                             retval.tree = root_0;
10760                         }
10761                     }
10762                         break;
10763
10764                     }
10765
10766                 }
10767
10768             }
10769                 break;
10770             case 2:
10771             // Grammar/CTFParser.g:998:5: ( declarationSpecifiers {...}?
10772             // declaratorList )
10773             {
10774                 // Grammar/CTFParser.g:998:5: ( declarationSpecifiers {...}?
10775                 // declaratorList )
10776                 // Grammar/CTFParser.g:998:6: declarationSpecifiers {...}?
10777                 // declaratorList
10778                 {
10779                     pushFollow(FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3493);
10780                     declarationSpecifiers178 = declarationSpecifiers();
10781
10782                     state._fsp--;
10783                     if (state.failed) {
10784                         return retval;
10785                     }
10786                     if (state.backtracking == 0) {
10787                         stream_declarationSpecifiers
10788                                 .add(declarationSpecifiers178.getTree());
10789                     }
10790                     if (!((inTypedef()))) {
10791                         if (state.backtracking > 0) {
10792                             state.failed = true;
10793                             return retval;
10794                         }
10795                         throw new FailedPredicateException(input,
10796                                 "ctfAssignmentExpression", "inTypedef()");
10797                     }
10798                     pushFollow(FOLLOW_declaratorList_in_ctfAssignmentExpression3497);
10799                     declaratorList179 = declaratorList();
10800
10801                     state._fsp--;
10802                     if (state.failed) {
10803                         return retval;
10804                     }
10805                     if (state.backtracking == 0) {
10806                         stream_declaratorList.add(declaratorList179.getTree());
10807                     }
10808
10809                 }
10810
10811                 // AST REWRITE
10812                 // elements: declaratorList, declarationSpecifiers
10813                 // token labels:
10814                 // rule labels: retval
10815                 // token list labels:
10816                 // rule list labels:
10817                 // wildcard labels:
10818                 if (state.backtracking == 0) {
10819                     retval.tree = root_0;
10820                     RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
10821                             adaptor, "rule retval",
10822                             retval != null ? retval.tree : null);
10823
10824                     root_0 = (CommonTree) adaptor.nil();
10825                     // 999:5: -> ^( TYPEDEF declaratorList declarationSpecifiers
10826                     // )
10827                     {
10828                         // Grammar/CTFParser.g:999:8: ^( TYPEDEF declaratorList
10829                         // declarationSpecifiers )
10830                         {
10831                             CommonTree root_1 = (CommonTree) adaptor.nil();
10832                             root_1 = (CommonTree) adaptor.becomeRoot(
10833                                     adaptor.create(TYPEDEF, "TYPEDEF"), root_1);
10834
10835                             adaptor.addChild(root_1,
10836                                     stream_declaratorList.nextTree());
10837                             adaptor.addChild(root_1,
10838                                     stream_declarationSpecifiers.nextTree());
10839
10840                             adaptor.addChild(root_0, root_1);
10841                         }
10842
10843                     }
10844
10845                     retval.tree = root_0;
10846                 }
10847             }
10848                 break;
10849             case 3:
10850             // Grammar/CTFParser.g:1002:5: typealiasDecl
10851             {
10852                 root_0 = (CommonTree) adaptor.nil();
10853
10854                 pushFollow(FOLLOW_typealiasDecl_in_ctfAssignmentExpression3525);
10855                 typealiasDecl180 = typealiasDecl();
10856
10857                 state._fsp--;
10858                 if (state.failed) {
10859                     return retval;
10860                 }
10861                 if (state.backtracking == 0) {
10862                     adaptor.addChild(root_0, typealiasDecl180.getTree());
10863                 }
10864
10865             }
10866                 break;
10867
10868             }
10869             retval.stop = input.LT(-1);
10870
10871             if (state.backtracking == 0) {
10872
10873                 retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
10874                 adaptor.setTokenBoundaries(retval.tree, retval.start,
10875                         retval.stop);
10876             }
10877             if (state.backtracking == 0) {
10878
10879                 if (inTypedef()) {
10880                     typedefOff();
10881                 }
10882                 exit("ctfAssignmentExpression");
10883
10884             }
10885         }
10886
10887         catch (RecognitionException e) {
10888             throw e;
10889
10890         }
10891         return retval;
10892     }
10893
10894     // $ANTLR end "ctfAssignmentExpression"
10895
10896     // $ANTLR start synpred1_CTFParser
10897     public final void synpred1_CTFParser_fragment() throws RecognitionException {
10898         // Grammar/CTFParser.g:250:5: ( IDENTIFIER )
10899         // Grammar/CTFParser.g:250:6: IDENTIFIER
10900         {
10901             match(input, IDENTIFIER, FOLLOW_IDENTIFIER_in_synpred1_CTFParser470);
10902             if (state.failed) {
10903                 return;
10904             }
10905
10906         }
10907     }
10908
10909     // $ANTLR end synpred1_CTFParser
10910
10911     // $ANTLR start synpred2_CTFParser
10912     public final void synpred2_CTFParser_fragment() throws RecognitionException {
10913         // Grammar/CTFParser.g:251:5: ( ctfKeyword )
10914         // Grammar/CTFParser.g:251:6: ctfKeyword
10915         {
10916             pushFollow(FOLLOW_ctfKeyword_in_synpred2_CTFParser492);
10917             ctfKeyword();
10918
10919             state._fsp--;
10920             if (state.failed) {
10921                 return;
10922             }
10923
10924         }
10925     }
10926
10927     // $ANTLR end synpred2_CTFParser
10928
10929     // $ANTLR start synpred3_CTFParser
10930     public final void synpred3_CTFParser_fragment() throws RecognitionException {
10931         // Grammar/CTFParser.g:252:5: ( STRING_LITERAL )
10932         // Grammar/CTFParser.g:252:6: STRING_LITERAL
10933         {
10934             match(input, STRING_LITERAL,
10935                     FOLLOW_STRING_LITERAL_in_synpred3_CTFParser512);
10936             if (state.failed) {
10937                 return;
10938             }
10939
10940         }
10941     }
10942
10943     // $ANTLR end synpred3_CTFParser
10944
10945     // Delegated rules
10946
10947     public final boolean synpred2_CTFParser() {
10948         state.backtracking++;
10949         int start = input.mark();
10950         try {
10951             synpred2_CTFParser_fragment(); // can never throw exception
10952         } catch (RecognitionException re) {
10953             if(System.err != null) {//findbugs
10954                 System.err.println("impossible: " + re);
10955             }
10956         }
10957         boolean success = !state.failed;
10958         input.rewind(start);
10959         state.backtracking--;
10960         state.failed = false;
10961         return success;
10962     }
10963
10964     public final boolean synpred1_CTFParser() {
10965         state.backtracking++;
10966         int start = input.mark();
10967         try {
10968             synpred1_CTFParser_fragment(); // can never throw exception
10969         } catch (RecognitionException re) {
10970             if( System.err != null ) {//findbugs
10971                 System.err.println("impossible: " + re);
10972             }
10973         }
10974         boolean success = !state.failed;
10975         input.rewind(start);
10976         state.backtracking--;
10977         state.failed = false;
10978         return success;
10979     }
10980
10981     public final boolean synpred3_CTFParser() {
10982         state.backtracking++;
10983         int start = input.mark();
10984         try {
10985             synpred3_CTFParser_fragment(); // can never throw exception
10986         } catch (RecognitionException re) {
10987             if( System.err != null ) { //findbugs
10988                 System.err.println("impossible: " + re);
10989             }
10990         }
10991         boolean success = !state.failed;
10992         input.rewind(start);
10993         state.backtracking--;
10994         state.failed = false;
10995         return success;
10996     }
10997
10998     protected DFA10 dfa10 = new DFA10(this);
10999     protected DFA17 dfa17 = new DFA17(this);
11000     protected DFA24 dfa24 = new DFA24(this);
11001     protected DFA32 dfa32 = new DFA32(this);
11002     protected DFA54 dfa54 = new DFA54(this);
11003     static final String DFA10_eotS = "\16\uffff";
11004     static final String DFA10_eofS = "\16\uffff";
11005     static final String DFA10_minS = "\1\4\15\uffff";
11006     static final String DFA10_maxS = "\1\116\15\uffff";
11007     static final String DFA10_acceptS = "\1\uffff\2\1\7\uffff\1\2\3\uffff";
11008     static final String DFA10_specialS = "\16\uffff}>";
11009     static final String[] DFA10_transitionS = {
11010             "\1\1\4\uffff\1\2\6\uffff\1\1\1\12\1\1\1\uffff\1\12\10\uffff"
11011                     + "\2\12\22\uffff\1\1\4\uffff\1\1\1\uffff\1\1\2\uffff\1\1\10\uffff"
11012                     + "\1\1\2\uffff\1\1\6\uffff\1\1", "", "", "", "", "", "",
11013             "", "", "", "", "", "", "" };
11014
11015     static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
11016     static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
11017     static final char[] DFA10_min = DFA
11018             .unpackEncodedStringToUnsignedChars(DFA10_minS);
11019     static final char[] DFA10_max = DFA
11020             .unpackEncodedStringToUnsignedChars(DFA10_maxS);
11021     static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
11022     static final short[] DFA10_special = DFA
11023             .unpackEncodedString(DFA10_specialS);
11024     static final short[][] DFA10_transition;
11025
11026     static {
11027         int numStates = DFA10_transitionS.length;
11028         DFA10_transition = new short[numStates][];
11029         for (int i = 0; i < numStates; i++) {
11030             DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
11031         }
11032     }
11033
11034     static class DFA10 extends DFA {
11035
11036         public DFA10(BaseRecognizer recognizer) {
11037             this.recognizer = recognizer;
11038             this.decisionNumber = 10;
11039             this.eot = DFA10_eot;
11040             this.eof = DFA10_eof;
11041             this.min = DFA10_min;
11042             this.max = DFA10_max;
11043             this.accept = DFA10_accept;
11044             this.special = DFA10_special;
11045             this.transition = DFA10_transition;
11046         }
11047
11048         @Override
11049         public String getDescription() {
11050             return "281:1: postfixExpression : ( ( primaryExpression ) ( postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) ( postfixExpressionSuffix )+ ) );";
11051         }
11052     }
11053
11054     static final String DFA17_eotS = "\22\uffff";
11055     static final String DFA17_eofS = "\22\uffff";
11056     static final String DFA17_minS = "\1\6\21\uffff";
11057     static final String DFA17_maxS = "\1\116\21\uffff";
11058     static final String DFA17_acceptS = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"
11059             + "\15\1\16\1\17\1\20\1\21";
11060     static final String DFA17_specialS = "\1\0\21\uffff}>";
11061     static final String[] DFA17_transitionS = {
11062             "\1\7\1\10\1\17\1\uffff\1\20\1\1\1\20\1\2\1\3\1\4\1\5\1\uffff"
11063                     + "\1\20\1\15\3\uffff\1\6\1\16\1\11\1\12\1\13\1\14\61\uffff\1\21",
11064             "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" };
11065
11066     static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
11067     static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
11068     static final char[] DFA17_min = DFA
11069             .unpackEncodedStringToUnsignedChars(DFA17_minS);
11070     static final char[] DFA17_max = DFA
11071             .unpackEncodedStringToUnsignedChars(DFA17_maxS);
11072     static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
11073     static final short[] DFA17_special = DFA
11074             .unpackEncodedString(DFA17_specialS);
11075     static final short[][] DFA17_transition;
11076
11077     static {
11078         int numStates = DFA17_transitionS.length;
11079         DFA17_transition = new short[numStates][];
11080         for (int i = 0; i < numStates; i++) {
11081             DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
11082         }
11083     }
11084
11085     class DFA17 extends DFA {
11086
11087         public DFA17(BaseRecognizer recognizer) {
11088             this.recognizer = recognizer;
11089             this.decisionNumber = 17;
11090             this.eot = DFA17_eot;
11091             this.eof = DFA17_eof;
11092             this.min = DFA17_min;
11093             this.max = DFA17_max;
11094             this.accept = DFA17_accept;
11095             this.special = DFA17_special;
11096             this.transition = DFA17_transition;
11097         }
11098
11099         @Override
11100         public String getDescription() {
11101             return "384:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName );";
11102         }
11103
11104         @SuppressWarnings({ "synthetic-access" })
11105         @Override
11106         public int specialStateTransition(final int inputS, IntStream _input)
11107                 throws NoViableAltException {
11108             TokenStream input = (TokenStream) _input;
11109             int _s = inputS;
11110             int s = inputS;
11111             switch (s) {
11112             case 0:
11113                 int LA17_0 = input.LA(1);
11114
11115                 int index17_0 = input.index();
11116                 input.rewind();
11117                 s = -1;
11118                 if ((LA17_0 == FLOATTOK)) {
11119                     s = 1;
11120                 }
11121
11122                 else if ((LA17_0 == INTTOK)) {
11123                     s = 2;
11124                 }
11125
11126                 else if ((LA17_0 == LONGTOK)) {
11127                     s = 3;
11128                 }
11129
11130                 else if ((LA17_0 == SHORTTOK)) {
11131                     s = 4;
11132                 }
11133
11134                 else if ((LA17_0 == SIGNEDTOK)) {
11135                     s = 5;
11136                 }
11137
11138                 else if ((LA17_0 == UNSIGNEDTOK)) {
11139                     s = 6;
11140                 }
11141
11142                 else if ((LA17_0 == CHARTOK)) {
11143                     s = 7;
11144                 }
11145
11146                 else if ((LA17_0 == DOUBLETOK)) {
11147                     s = 8;
11148                 }
11149
11150                 else if ((LA17_0 == VOIDTOK)) {
11151                     s = 9;
11152                 }
11153
11154                 else if ((LA17_0 == BOOLTOK)) {
11155                     s = 10;
11156                 }
11157
11158                 else if ((LA17_0 == COMPLEXTOK)) {
11159                     s = 11;
11160                 }
11161
11162                 else if ((LA17_0 == IMAGINARYTOK)) {
11163                     s = 12;
11164                 }
11165
11166                 else if ((LA17_0 == STRUCTTOK)) {
11167                     s = 13;
11168                 }
11169
11170                 else if ((LA17_0 == VARIANTTOK)) {
11171                     s = 14;
11172                 }
11173
11174                 else if ((LA17_0 == ENUMTOK)) {
11175                     s = 15;
11176                 }
11177
11178                 else if (((LA17_0 == FLOATINGPOINTTOK)
11179                         || (LA17_0 == INTEGERTOK) || (LA17_0 == STRINGTOK))) {
11180                     s = 16;
11181                 }
11182
11183                 else if ((LA17_0 == IDENTIFIER)
11184                         && ((inTypealiasAlias() || isTypeName(input.LT(1)
11185                                 .getText())))) {
11186                     s = 17;
11187                 }
11188
11189                 input.seek(index17_0);
11190                 if (s >= 0) {
11191                     return s;
11192                 }
11193                 break;
11194             }
11195             if (state.backtracking > 0) {
11196                 state.failed = true;
11197                 return -1;
11198             }
11199             NoViableAltException nvae = new NoViableAltException(
11200                     getDescription(), 17, _s, input);
11201             error(nvae);
11202             throw nvae;
11203         }
11204     }
11205
11206     static final String DFA24_eotS = "\6\uffff";
11207     static final String DFA24_eofS = "\6\uffff";
11208     static final String DFA24_minS = "\1\60\1\5\1\0\1\5\2\uffff";
11209     static final String DFA24_maxS = "\2\116\1\0\1\116\2\uffff";
11210     static final String DFA24_acceptS = "\4\uffff\1\1\1\2";
11211     static final String DFA24_specialS = "\2\uffff\1\0\3\uffff}>";
11212     static final String[] DFA24_transitionS = { "\1\1\35\uffff\1\2",
11213             "\1\3\52\uffff\1\1\35\uffff\1\2", "\1\uffff",
11214             "\1\3\52\uffff\1\1\35\uffff\1\2", "", "" };
11215
11216     static final short[] DFA24_eot = DFA.unpackEncodedString(DFA24_eotS);
11217     static final short[] DFA24_eof = DFA.unpackEncodedString(DFA24_eofS);
11218     static final char[] DFA24_min = DFA
11219             .unpackEncodedStringToUnsignedChars(DFA24_minS);
11220     static final char[] DFA24_max = DFA
11221             .unpackEncodedStringToUnsignedChars(DFA24_maxS);
11222     static final short[] DFA24_accept = DFA.unpackEncodedString(DFA24_acceptS);
11223     static final short[] DFA24_special = DFA
11224             .unpackEncodedString(DFA24_specialS);
11225     static final short[][] DFA24_transition;
11226
11227     static {
11228         int numStates = DFA24_transitionS.length;
11229         DFA24_transition = new short[numStates][];
11230         for (int i = 0; i < numStates; i++) {
11231             DFA24_transition[i] = DFA.unpackEncodedString(DFA24_transitionS[i]);
11232         }
11233     }
11234
11235     class DFA24 extends DFA {
11236
11237         public DFA24(BaseRecognizer recognizer) {
11238             this.recognizer = recognizer;
11239             this.decisionNumber = 24;
11240             this.eot = DFA24_eot;
11241             this.eof = DFA24_eof;
11242             this.min = DFA24_min;
11243             this.max = DFA24_max;
11244             this.accept = DFA24_accept;
11245             this.special = DFA24_special;
11246             this.transition = DFA24_transition;
11247         }
11248
11249         @Override
11250         public String getDescription() {
11251             return "521:7: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )";
11252         }
11253
11254         @Override
11255         public int specialStateTransition(int s, IntStream _input)
11256                 throws NoViableAltException {
11257             TokenStream input = (TokenStream) _input;
11258             int _s = s;
11259             switch (s) {
11260             case 0:
11261                 int LA24_2 = input.LA(1);
11262
11263                 int index24_2 = input.index();
11264                 input.rewind();
11265                 s = -1;
11266                 if (((inTypedef()))) {
11267                     s = 4;
11268                 }
11269
11270                 else if ((true)) {
11271                     s = 5;
11272                 }
11273
11274                 input.seek(index24_2);
11275                 if (s >= 0) {
11276                     return s;
11277                 }
11278                 break;
11279             }
11280             if (state.backtracking > 0) {
11281                 state.failed = true;
11282                 return -1;
11283             }
11284             NoViableAltException nvae = new NoViableAltException(
11285                     getDescription(), 24, _s, input);
11286             error(nvae);
11287             throw nvae;
11288         }
11289     }
11290
11291     static final String DFA32_eotS = "\35\uffff";
11292     static final String DFA32_eofS = "\1\3\34\uffff";
11293     static final String DFA32_minS = "\1\5\34\uffff";
11294     static final String DFA32_maxS = "\1\116\34\uffff";
11295     static final String DFA32_acceptS = "\1\uffff\1\1\1\2\1\3\31\uffff";
11296     static final String DFA32_specialS = "\35\uffff}>";
11297     static final String[] DFA32_transitionS = {
11298             "\4\3\1\uffff\7\3\1\uffff\2\3\2\uffff\7\3\6\uffff\1\1\2\uffff"
11299                     + "\1\3\4\uffff\1\3\1\uffff\1\2\1\uffff\2\3\35\uffff\1\3",
11300             "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
11301             "", "", "", "", "", "", "", "", "", "", "" };
11302
11303     static final short[] DFA32_eot = DFA.unpackEncodedString(DFA32_eotS);
11304     static final short[] DFA32_eof = DFA.unpackEncodedString(DFA32_eofS);
11305     static final char[] DFA32_min = DFA
11306             .unpackEncodedStringToUnsignedChars(DFA32_minS);
11307     static final char[] DFA32_max = DFA
11308             .unpackEncodedStringToUnsignedChars(DFA32_maxS);
11309     static final short[] DFA32_accept = DFA.unpackEncodedString(DFA32_acceptS);
11310     static final short[] DFA32_special = DFA
11311             .unpackEncodedString(DFA32_specialS);
11312     static final short[][] DFA32_transition;
11313
11314     static {
11315         int numStates = DFA32_transitionS.length;
11316         DFA32_transition = new short[numStates][];
11317         for (int i = 0; i < numStates; i++) {
11318             DFA32_transition[i] = DFA.unpackEncodedString(DFA32_transitionS[i]);
11319         }
11320     }
11321
11322     static class DFA32 extends DFA {
11323
11324         public DFA32(BaseRecognizer recognizer) {
11325             this.recognizer = recognizer;
11326             this.decisionNumber = 32;
11327             this.eot = DFA32_eot;
11328             this.eof = DFA32_eof;
11329             this.min = DFA32_min;
11330             this.max = DFA32_max;
11331             this.accept = DFA32_accept;
11332             this.special = DFA32_special;
11333             this.transition = DFA32_transition;
11334         }
11335
11336         @Override
11337         public String getDescription() {
11338             return "655:4: ( enumContainerType enumBody | enumBody | )";
11339         }
11340     }
11341
11342     static final String DFA54_eotS = "\34\uffff";
11343     static final String DFA54_eofS = "\1\2\33\uffff";
11344     static final String DFA54_minS = "\1\5\33\uffff";
11345     static final String DFA54_maxS = "\1\116\33\uffff";
11346     static final String DFA54_acceptS = "\1\uffff\1\1\1\2\31\uffff";
11347     static final String DFA54_specialS = "\34\uffff}>";
11348     static final String[] DFA54_transitionS = {
11349             "\4\2\1\uffff\7\2\1\uffff\2\2\2\uffff\7\2\11\uffff\1\2\4\uffff"
11350                     + "\1\2\1\uffff\1\1\1\uffff\2\2\35\uffff\1\2", "", "", "",
11351             "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
11352             "", "", "", "", "", "", "" };
11353
11354     static final short[] DFA54_eot = DFA.unpackEncodedString(DFA54_eotS);
11355     static final short[] DFA54_eof = DFA.unpackEncodedString(DFA54_eofS);
11356     static final char[] DFA54_min = DFA
11357             .unpackEncodedStringToUnsignedChars(DFA54_minS);
11358     static final char[] DFA54_max = DFA
11359             .unpackEncodedStringToUnsignedChars(DFA54_maxS);
11360     static final short[] DFA54_accept = DFA.unpackEncodedString(DFA54_acceptS);
11361     static final short[] DFA54_special = DFA
11362             .unpackEncodedString(DFA54_specialS);
11363     static final short[][] DFA54_transition;
11364
11365     static {
11366         int numStates = DFA54_transitionS.length;
11367         DFA54_transition = new short[numStates][];
11368         for (int i = 0; i < numStates; i++) {
11369             DFA54_transition[i] = DFA.unpackEncodedString(DFA54_transitionS[i]);
11370         }
11371     }
11372
11373     static class DFA54 extends DFA {
11374
11375         public DFA54(BaseRecognizer recognizer) {
11376             this.recognizer = recognizer;
11377             this.decisionNumber = 54;
11378             this.eot = DFA54_eot;
11379             this.eof = DFA54_eof;
11380             this.min = DFA54_min;
11381             this.max = DFA54_max;
11382             this.accept = DFA54_accept;
11383             this.special = DFA54_special;
11384             this.transition = DFA54_transition;
11385         }
11386
11387         @Override
11388         public String getDescription() {
11389             return "954:15: ( ctfBody )?";
11390         }
11391     }
11392
11393     public static final BitSet FOLLOW_declaration_in_parse321 = new BitSet(
11394             new long[] { 0x000000007FFFFFE0L, 0x0000000000004000L });
11395     public static final BitSet FOLLOW_EOF_in_parse324 = new BitSet(
11396             new long[] { 0x0000000000000002L });
11397     public static final BitSet FOLLOW_SIGN_in_numberLiteral357 = new BitSet(
11398             new long[] { 0x0942000000000000L });
11399     public static final BitSet FOLLOW_HEX_LITERAL_in_numberLiteral362 = new BitSet(
11400             new long[] { 0x0000000000000002L });
11401     public static final BitSet FOLLOW_DECIMAL_LITERAL_in_numberLiteral379 = new BitSet(
11402             new long[] { 0x0000000000000002L });
11403     public static final BitSet FOLLOW_OCTAL_LITERAL_in_numberLiteral396 = new BitSet(
11404             new long[] { 0x0000000000000002L });
11405     public static final BitSet FOLLOW_numberLiteral_in_constant432 = new BitSet(
11406             new long[] { 0x0000000000000002L });
11407     public static final BitSet FOLLOW_enumConstant_in_constant438 = new BitSet(
11408             new long[] { 0x0000000000000002L });
11409     public static final BitSet FOLLOW_CHARACTER_LITERAL_in_constant444 = new BitSet(
11410             new long[] { 0x0000000000000002L });
11411     public static final BitSet FOLLOW_IDENTIFIER_in_primaryExpression475 = new BitSet(
11412             new long[] { 0x0000000000000002L });
11413     public static final BitSet FOLLOW_ctfKeyword_in_primaryExpression497 = new BitSet(
11414             new long[] { 0x0000000000000002L });
11415     public static final BitSet FOLLOW_STRING_LITERAL_in_primaryExpression517 = new BitSet(
11416             new long[] { 0x0000000000000002L });
11417     public static final BitSet FOLLOW_constant_in_primaryExpression538 = new BitSet(
11418             new long[] { 0x0000000000000002L });
11419     public static final BitSet FOLLOW_DOT_in_reference564 = new BitSet(
11420             new long[] { 0x0000000000000000L, 0x0000000000004000L });
11421     public static final BitSet FOLLOW_ARROW_in_reference570 = new BitSet(
11422             new long[] { 0x0000000000000000L, 0x0000000000004000L });
11423     public static final BitSet FOLLOW_IDENTIFIER_in_reference573 = new BitSet(
11424             new long[] { 0x0000000000000002L });
11425     public static final BitSet FOLLOW_OPENBRAC_in_postfixExpressionSuffix612 = new BitSet(
11426             new long[] { 0x0942000060170210L, 0x0000000000004090L });
11427     public static final BitSet FOLLOW_unaryExpression_in_postfixExpressionSuffix614 = new BitSet(
11428             new long[] { 0x0000040000000000L });
11429     public static final BitSet FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix616 = new BitSet(
11430             new long[] { 0x0000000000000002L });
11431     public static final BitSet FOLLOW_reference_in_postfixExpressionSuffix624 = new BitSet(
11432             new long[] { 0x0000000000000002L });
11433     public static final BitSet FOLLOW_primaryExpression_in_postfixExpression648 = new BitSet(
11434             new long[] { 0x000C020000000002L });
11435     public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression652 = new BitSet(
11436             new long[] { 0x000C020000000002L });
11437     public static final BitSet FOLLOW_ctfSpecifierHead_in_postfixExpression661 = new BitSet(
11438             new long[] { 0x000C020000000000L });
11439     public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression666 = new BitSet(
11440             new long[] { 0x000C020000000002L });
11441     public static final BitSet FOLLOW_postfixExpression_in_unaryExpression700 = new BitSet(
11442             new long[] { 0x0000000000000002L });
11443     public static final BitSet FOLLOW_STRING_LITERAL_in_enumConstant725 = new BitSet(
11444             new long[] { 0x0000000000000002L });
11445     public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant741 = new BitSet(
11446             new long[] { 0x0000000000000002L });
11447     public static final BitSet FOLLOW_ctfKeyword_in_enumConstant757 = new BitSet(
11448             new long[] { 0x0000000000000002L });
11449     public static final BitSet FOLLOW_declarationSpecifiers_in_declaration790 = new BitSet(
11450             new long[] { 0x0001800000000000L, 0x0000000000004000L });
11451     public static final BitSet FOLLOW_declaratorList_in_declaration792 = new BitSet(
11452             new long[] { 0x0000800000000000L });
11453     public static final BitSet FOLLOW_TERM_in_declaration795 = new BitSet(
11454             new long[] { 0x0000000000000002L });
11455     public static final BitSet FOLLOW_ctfSpecifier_in_declaration844 = new BitSet(
11456             new long[] { 0x0000800000000000L });
11457     public static final BitSet FOLLOW_TERM_in_declaration846 = new BitSet(
11458             new long[] { 0x0000000000000002L });
11459     public static final BitSet FOLLOW_storageClassSpecifier_in_declarationSpecifiers891 = new BitSet(
11460             new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
11461     public static final BitSet FOLLOW_typeQualifier_in_declarationSpecifiers898 = new BitSet(
11462             new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
11463     public static final BitSet FOLLOW_typeSpecifier_in_declarationSpecifiers905 = new BitSet(
11464             new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
11465     public static final BitSet FOLLOW_declarator_in_declaratorList946 = new BitSet(
11466             new long[] { 0x0000000400000002L });
11467     public static final BitSet FOLLOW_SEPARATOR_in_declaratorList949 = new BitSet(
11468             new long[] { 0x0001000000000000L, 0x0000000000004000L });
11469     public static final BitSet FOLLOW_declarator_in_declaratorList951 = new BitSet(
11470             new long[] { 0x0000000400000002L });
11471     public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList985 = new BitSet(
11472             new long[] { 0x0000000400000002L });
11473     public static final BitSet FOLLOW_SEPARATOR_in_abstractDeclaratorList988 = new BitSet(
11474             new long[] { 0x0001080000000000L, 0x0000000000004000L });
11475     public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList990 = new BitSet(
11476             new long[] { 0x0000000400000002L });
11477     public static final BitSet FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1014 = new BitSet(
11478             new long[] { 0x0000000000000002L });
11479     public static final BitSet FOLLOW_FLOATTOK_in_typeSpecifier1040 = new BitSet(
11480             new long[] { 0x0000000000000002L });
11481     public static final BitSet FOLLOW_INTTOK_in_typeSpecifier1046 = new BitSet(
11482             new long[] { 0x0000000000000002L });
11483     public static final BitSet FOLLOW_LONGTOK_in_typeSpecifier1052 = new BitSet(
11484             new long[] { 0x0000000000000002L });
11485     public static final BitSet FOLLOW_SHORTTOK_in_typeSpecifier1058 = new BitSet(
11486             new long[] { 0x0000000000000002L });
11487     public static final BitSet FOLLOW_SIGNEDTOK_in_typeSpecifier1064 = new BitSet(
11488             new long[] { 0x0000000000000002L });
11489     public static final BitSet FOLLOW_UNSIGNEDTOK_in_typeSpecifier1070 = new BitSet(
11490             new long[] { 0x0000000000000002L });
11491     public static final BitSet FOLLOW_CHARTOK_in_typeSpecifier1076 = new BitSet(
11492             new long[] { 0x0000000000000002L });
11493     public static final BitSet FOLLOW_DOUBLETOK_in_typeSpecifier1082 = new BitSet(
11494             new long[] { 0x0000000000000002L });
11495     public static final BitSet FOLLOW_VOIDTOK_in_typeSpecifier1088 = new BitSet(
11496             new long[] { 0x0000000000000002L });
11497     public static final BitSet FOLLOW_BOOLTOK_in_typeSpecifier1094 = new BitSet(
11498             new long[] { 0x0000000000000002L });
11499     public static final BitSet FOLLOW_COMPLEXTOK_in_typeSpecifier1100 = new BitSet(
11500             new long[] { 0x0000000000000002L });
11501     public static final BitSet FOLLOW_IMAGINARYTOK_in_typeSpecifier1106 = new BitSet(
11502             new long[] { 0x0000000000000002L });
11503     public static final BitSet FOLLOW_structSpecifier_in_typeSpecifier1112 = new BitSet(
11504             new long[] { 0x0000000000000002L });
11505     public static final BitSet FOLLOW_variantSpecifier_in_typeSpecifier1118 = new BitSet(
11506             new long[] { 0x0000000000000002L });
11507     public static final BitSet FOLLOW_enumSpecifier_in_typeSpecifier1124 = new BitSet(
11508             new long[] { 0x0000000000000002L });
11509     public static final BitSet FOLLOW_ctfTypeSpecifier_in_typeSpecifier1130 = new BitSet(
11510             new long[] { 0x0000000000000002L });
11511     public static final BitSet FOLLOW_typedefName_in_typeSpecifier1140 = new BitSet(
11512             new long[] { 0x0000000000000002L });
11513     public static final BitSet FOLLOW_CONSTTOK_in_typeQualifier1163 = new BitSet(
11514             new long[] { 0x0000000000000002L });
11515     public static final BitSet FOLLOW_ALIGNTOK_in_alignAttribute1176 = new BitSet(
11516             new long[] { 0x0000080000000000L });
11517     public static final BitSet FOLLOW_LPAREN_in_alignAttribute1178 = new BitSet(
11518             new long[] { 0x0942000060170210L, 0x0000000000004090L });
11519     public static final BitSet FOLLOW_unaryExpression_in_alignAttribute1180 = new BitSet(
11520             new long[] { 0x0000100000000000L });
11521     public static final BitSet FOLLOW_RPAREN_in_alignAttribute1182 = new BitSet(
11522             new long[] { 0x0000000000000002L });
11523     public static final BitSet FOLLOW_LCURL_in_structBody1223 = new BitSet(
11524             new long[] { 0x000040007FFFFFE0L, 0x0000000000004000L });
11525     public static final BitSet FOLLOW_structOrVariantDeclarationList_in_structBody1225 = new BitSet(
11526             new long[] { 0x0000400000000000L });
11527     public static final BitSet FOLLOW_RCURL_in_structBody1228 = new BitSet(
11528             new long[] { 0x0000000000000002L });
11529     public static final BitSet FOLLOW_STRUCTTOK_in_structSpecifier1266 = new BitSet(
11530             new long[] { 0x0000200000000000L, 0x0000000000004000L });
11531     public static final BitSet FOLLOW_structName_in_structSpecifier1288 = new BitSet(
11532             new long[] { 0x0000200000000012L, 0x0000000000004000L });
11533     public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1304 = new BitSet(
11534             new long[] { 0x0000000000000002L });
11535     public static final BitSet FOLLOW_structBody_in_structSpecifier1333 = new BitSet(
11536             new long[] { 0x0000000000000012L });
11537     public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1358 = new BitSet(
11538             new long[] { 0x0000000000000002L });
11539     public static final BitSet FOLLOW_structBody_in_structSpecifier1456 = new BitSet(
11540             new long[] { 0x0000000000000012L });
11541     public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1474 = new BitSet(
11542             new long[] { 0x0000000000000002L });
11543     public static final BitSet FOLLOW_IDENTIFIER_in_structName1550 = new BitSet(
11544             new long[] { 0x0000000000000002L });
11545     public static final BitSet FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1581 = new BitSet(
11546             new long[] { 0x000000007FFFFFE2L, 0x0000000000004000L });
11547     public static final BitSet FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1619 = new BitSet(
11548             new long[] { 0x0001000000000000L, 0x0000000000004000L });
11549     public static final BitSet FOLLOW_declaratorList_in_structOrVariantDeclaration1651 = new BitSet(
11550             new long[] { 0x0000800000000000L });
11551     public static final BitSet FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1685 = new BitSet(
11552             new long[] { 0x0000800000000000L });
11553     public static final BitSet FOLLOW_typealiasDecl_in_structOrVariantDeclaration1735 = new BitSet(
11554             new long[] { 0x0000800000000000L });
11555     public static final BitSet FOLLOW_TERM_in_structOrVariantDeclaration1747 = new BitSet(
11556             new long[] { 0x0000000000000002L });
11557     public static final BitSet FOLLOW_typeQualifier_in_specifierQualifierList1771 = new BitSet(
11558             new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
11559     public static final BitSet FOLLOW_typeSpecifier_in_specifierQualifierList1775 = new BitSet(
11560             new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
11561     public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1812 = new BitSet(
11562             new long[] { 0x0000000400000002L });
11563     public static final BitSet FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1815 = new BitSet(
11564             new long[] { 0x0001000000000000L, 0x0000000000004000L });
11565     public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1817 = new BitSet(
11566             new long[] { 0x0000000400000002L });
11567     public static final BitSet FOLLOW_declarator_in_structOrVariantDeclarator1858 = new BitSet(
11568             new long[] { 0x0000000800000002L });
11569     public static final BitSet FOLLOW_COLON_in_structOrVariantDeclarator1861 = new BitSet(
11570             new long[] { 0x0942000000000000L });
11571     public static final BitSet FOLLOW_numberLiteral_in_structOrVariantDeclarator1863 = new BitSet(
11572             new long[] { 0x0000000000000002L });
11573     public static final BitSet FOLLOW_VARIANTTOK_in_variantSpecifier1897 = new BitSet(
11574             new long[] { 0x0000208000000000L, 0x0000000000004000L });
11575     public static final BitSet FOLLOW_variantName_in_variantSpecifier1915 = new BitSet(
11576             new long[] { 0x0000208000000000L, 0x0000000000004000L });
11577     public static final BitSet FOLLOW_variantTag_in_variantSpecifier1946 = new BitSet(
11578             new long[] { 0x0000208000000002L, 0x0000000000004000L });
11579     public static final BitSet FOLLOW_variantBody_in_variantSpecifier1972 = new BitSet(
11580             new long[] { 0x0000000000000002L });
11581     public static final BitSet FOLLOW_variantBody_in_variantSpecifier2040 = new BitSet(
11582             new long[] { 0x0000000000000002L });
11583     public static final BitSet FOLLOW_variantTag_in_variantSpecifier2065 = new BitSet(
11584             new long[] { 0x0000208000000000L, 0x0000000000004000L });
11585     public static final BitSet FOLLOW_variantBody_in_variantSpecifier2067 = new BitSet(
11586             new long[] { 0x0000000000000002L });
11587     public static final BitSet FOLLOW_variantBody_in_variantSpecifier2078 = new BitSet(
11588             new long[] { 0x0000000000000002L });
11589     public static final BitSet FOLLOW_IDENTIFIER_in_variantName2120 = new BitSet(
11590             new long[] { 0x0000000000000002L });
11591     public static final BitSet FOLLOW_LCURL_in_variantBody2156 = new BitSet(
11592             new long[] { 0x000000007FFFFFE0L, 0x0000000000004000L });
11593     public static final BitSet FOLLOW_structOrVariantDeclarationList_in_variantBody2158 = new BitSet(
11594             new long[] { 0x0000400000000000L });
11595     public static final BitSet FOLLOW_RCURL_in_variantBody2160 = new BitSet(
11596             new long[] { 0x0000000000000002L });
11597     public static final BitSet FOLLOW_LT_in_variantTag2191 = new BitSet(
11598             new long[] { 0x0000000000000000L, 0x0000000000004000L });
11599     public static final BitSet FOLLOW_IDENTIFIER_in_variantTag2193 = new BitSet(
11600             new long[] { 0x0000010000000000L });
11601     public static final BitSet FOLLOW_GT_in_variantTag2195 = new BitSet(
11602             new long[] { 0x0000000000000002L });
11603     public static final BitSet FOLLOW_ENUMTOK_in_enumSpecifier2225 = new BitSet(
11604             new long[] { 0x0000200800000000L, 0x0000000000004000L });
11605     public static final BitSet FOLLOW_enumName_in_enumSpecifier2240 = new BitSet(
11606             new long[] { 0x0000200800000002L, 0x0000000000004000L });
11607     public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2251 = new BitSet(
11608             new long[] { 0x0000200800000000L, 0x0000000000004000L });
11609     public static final BitSet FOLLOW_enumBody_in_enumSpecifier2253 = new BitSet(
11610             new long[] { 0x0000000000000002L });
11611     public static final BitSet FOLLOW_enumBody_in_enumSpecifier2265 = new BitSet(
11612             new long[] { 0x0000000000000002L });
11613     public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2300 = new BitSet(
11614             new long[] { 0x0000200800000000L, 0x0000000000004000L });
11615     public static final BitSet FOLLOW_enumBody_in_enumSpecifier2302 = new BitSet(
11616             new long[] { 0x0000000000000002L });
11617     public static final BitSet FOLLOW_enumBody_in_enumSpecifier2311 = new BitSet(
11618             new long[] { 0x0000000000000002L });
11619     public static final BitSet FOLLOW_IDENTIFIER_in_enumName2356 = new BitSet(
11620             new long[] { 0x0000000000000002L });
11621     public static final BitSet FOLLOW_LCURL_in_enumBody2389 = new BitSet(
11622             new long[] { 0x0000000000050210L, 0x0000000000004080L });
11623     public static final BitSet FOLLOW_enumeratorList_in_enumBody2391 = new BitSet(
11624             new long[] { 0x0000400400000000L });
11625     public static final BitSet FOLLOW_SEPARATOR_in_enumBody2394 = new BitSet(
11626             new long[] { 0x0000400000000000L });
11627     public static final BitSet FOLLOW_RCURL_in_enumBody2396 = new BitSet(
11628             new long[] { 0x0000000000000002L });
11629     public static final BitSet FOLLOW_RCURL_in_enumBody2400 = new BitSet(
11630             new long[] { 0x0000000000000002L });
11631     public static final BitSet FOLLOW_COLON_in_enumContainerType2432 = new BitSet(
11632             new long[] { 0x000000001FCDFDE0L, 0x0000000000004000L });
11633     public static final BitSet FOLLOW_declarationSpecifiers_in_enumContainerType2434 = new BitSet(
11634             new long[] { 0x0000000000000002L });
11635     public static final BitSet FOLLOW_enumerator_in_enumeratorList2465 = new BitSet(
11636             new long[] { 0x0000000400000002L });
11637     public static final BitSet FOLLOW_SEPARATOR_in_enumeratorList2468 = new BitSet(
11638             new long[] { 0x0000000000050210L, 0x0000000000004080L });
11639     public static final BitSet FOLLOW_enumerator_in_enumeratorList2470 = new BitSet(
11640             new long[] { 0x0000000400000002L });
11641     public static final BitSet FOLLOW_enumConstant_in_enumerator2506 = new BitSet(
11642             new long[] { 0x0000002000000002L });
11643     public static final BitSet FOLLOW_enumeratorValue_in_enumerator2508 = new BitSet(
11644             new long[] { 0x0000000000000002L });
11645     public static final BitSet FOLLOW_ASSIGNMENT_in_enumeratorValue2532 = new BitSet(
11646             new long[] { 0x0942000060170210L, 0x0000000000004090L });
11647     public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2536 = new BitSet(
11648             new long[] { 0x0000001000000002L });
11649     public static final BitSet FOLLOW_ELIPSES_in_enumeratorValue2562 = new BitSet(
11650             new long[] { 0x0942000060170210L, 0x0000000000004090L });
11651     public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2566 = new BitSet(
11652             new long[] { 0x0000000000000002L });
11653     public static final BitSet FOLLOW_pointer_in_declarator2608 = new BitSet(
11654             new long[] { 0x0001000000000000L, 0x0000000000004000L });
11655     public static final BitSet FOLLOW_directDeclarator_in_declarator2611 = new BitSet(
11656             new long[] { 0x0000000000000002L });
11657     public static final BitSet FOLLOW_IDENTIFIER_in_directDeclarator2655 = new BitSet(
11658             new long[] { 0x0000020000000002L });
11659     public static final BitSet FOLLOW_directDeclaratorSuffix_in_directDeclarator2673 = new BitSet(
11660             new long[] { 0x0000020000000002L });
11661     public static final BitSet FOLLOW_OPENBRAC_in_directDeclaratorSuffix2686 = new BitSet(
11662             new long[] { 0x0942000060170210L, 0x0000000000004090L });
11663     public static final BitSet FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2688 = new BitSet(
11664             new long[] { 0x0000040000000000L });
11665     public static final BitSet FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2690 = new BitSet(
11666             new long[] { 0x0000000000000002L });
11667     public static final BitSet FOLLOW_unaryExpression_in_directDeclaratorLength2711 = new BitSet(
11668             new long[] { 0x0000000000000002L });
11669     public static final BitSet FOLLOW_pointer_in_abstractDeclarator2742 = new BitSet(
11670             new long[] { 0x0001080000000002L, 0x0000000000004000L });
11671     public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2745 = new BitSet(
11672             new long[] { 0x0000000000000002L });
11673     public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2765 = new BitSet(
11674             new long[] { 0x0000000000000002L });
11675     public static final BitSet FOLLOW_IDENTIFIER_in_directAbstractDeclarator2805 = new BitSet(
11676             new long[] { 0x0000020000000002L });
11677     public static final BitSet FOLLOW_LPAREN_in_directAbstractDeclarator2814 = new BitSet(
11678             new long[] { 0x0001080000000000L, 0x0000000000004000L });
11679     public static final BitSet FOLLOW_abstractDeclarator_in_directAbstractDeclarator2816 = new BitSet(
11680             new long[] { 0x0000100000000000L });
11681     public static final BitSet FOLLOW_RPAREN_in_directAbstractDeclarator2818 = new BitSet(
11682             new long[] { 0x0000020000000002L });
11683     public static final BitSet FOLLOW_OPENBRAC_in_directAbstractDeclarator2833 = new BitSet(
11684             new long[] { 0x0942040060170210L, 0x0000000000004090L });
11685     public static final BitSet FOLLOW_unaryExpression_in_directAbstractDeclarator2835 = new BitSet(
11686             new long[] { 0x0000040000000000L });
11687     public static final BitSet FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2838 = new BitSet(
11688             new long[] { 0x0000000000000002L });
11689     public static final BitSet FOLLOW_POINTER_in_pointer2866 = new BitSet(
11690             new long[] { 0x0000000000000022L });
11691     public static final BitSet FOLLOW_typeQualifierList_in_pointer2868 = new BitSet(
11692             new long[] { 0x0000000000000002L });
11693     public static final BitSet FOLLOW_typeQualifier_in_typeQualifierList2891 = new BitSet(
11694             new long[] { 0x0000000000000022L });
11695     public static final BitSet FOLLOW_IDENTIFIER_in_typedefName2917 = new BitSet(
11696             new long[] { 0x0000000000000002L });
11697     public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasTarget2945 = new BitSet(
11698             new long[] { 0x0001080000000002L, 0x0000000000004000L });
11699     public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasTarget2947 = new BitSet(
11700             new long[] { 0x0000000000000002L });
11701     public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias2980 = new BitSet(
11702             new long[] { 0x0000000000000002L });
11703     public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasAlias2989 = new BitSet(
11704             new long[] { 0x0001080000000002L, 0x0000000000004000L });
11705     public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias2991 = new BitSet(
11706             new long[] { 0x0000000000000002L });
11707     public static final BitSet FOLLOW_TYPEALIASTOK_in_typealiasDecl3023 = new BitSet(
11708             new long[] { 0x000000001FCDFDE0L, 0x0000000000004000L });
11709     public static final BitSet FOLLOW_typealiasTarget_in_typealiasDecl3025 = new BitSet(
11710             new long[] { 0x0000004000000000L });
11711     public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3027 = new BitSet(
11712             new long[] { 0x000108001FCDFDE0L, 0x0000000000004000L });
11713     public static final BitSet FOLLOW_typealiasAlias_in_typealiasDecl3029 = new BitSet(
11714             new long[] { 0x0000000000000002L });
11715     public static final BitSet FOLLOW_set_in_ctfKeyword0 = new BitSet(
11716             new long[] { 0x0000000000000002L });
11717     public static final BitSet FOLLOW_ctfSpecifierHead_in_ctfSpecifier3123 = new BitSet(
11718             new long[] { 0x0000200000000000L });
11719     public static final BitSet FOLLOW_ctfBody_in_ctfSpecifier3125 = new BitSet(
11720             new long[] { 0x0000000000000002L });
11721     public static final BitSet FOLLOW_typealiasDecl_in_ctfSpecifier3144 = new BitSet(
11722             new long[] { 0x0000000000000002L });
11723     public static final BitSet FOLLOW_EVENTTOK_in_ctfSpecifierHead3176 = new BitSet(
11724             new long[] { 0x0000000000000002L });
11725     public static final BitSet FOLLOW_STREAMTOK_in_ctfSpecifierHead3185 = new BitSet(
11726             new long[] { 0x0000000000000002L });
11727     public static final BitSet FOLLOW_TRACETOK_in_ctfSpecifierHead3194 = new BitSet(
11728             new long[] { 0x0000000000000002L });
11729     public static final BitSet FOLLOW_ENVTOK_in_ctfSpecifierHead3203 = new BitSet(
11730             new long[] { 0x0000000000000002L });
11731     public static final BitSet FOLLOW_CLOCKTOK_in_ctfSpecifierHead3212 = new BitSet(
11732             new long[] { 0x0000000000000002L });
11733     public static final BitSet FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3246 = new BitSet(
11734             new long[] { 0x0000200000000000L });
11735     public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3248 = new BitSet(
11736             new long[] { 0x0000000000000002L });
11737     public static final BitSet FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3263 = new BitSet(
11738             new long[] { 0x0000200000000000L });
11739     public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3265 = new BitSet(
11740             new long[] { 0x0000000000000002L });
11741     public static final BitSet FOLLOW_STRINGTOK_in_ctfTypeSpecifier3280 = new BitSet(
11742             new long[] { 0x0000200000000002L });
11743     public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3282 = new BitSet(
11744             new long[] { 0x0000000000000002L });
11745     public static final BitSet FOLLOW_LCURL_in_ctfBody3320 = new BitSet(
11746             new long[] { 0x094240007FFFFFF0L, 0x0000000000004090L });
11747     public static final BitSet FOLLOW_ctfAssignmentExpressionList_in_ctfBody3322 = new BitSet(
11748             new long[] { 0x0000400000000000L });
11749     public static final BitSet FOLLOW_RCURL_in_ctfBody3325 = new BitSet(
11750             new long[] { 0x0000000000000002L });
11751     public static final BitSet FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3344 = new BitSet(
11752             new long[] { 0x0000800000000000L });
11753     public static final BitSet FOLLOW_TERM_in_ctfAssignmentExpressionList3346 = new BitSet(
11754             new long[] { 0x094200007FFFFFF2L, 0x0000000000004090L });
11755     public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3381 = new BitSet(
11756             new long[] { 0x0000006000000000L });
11757     public static final BitSet FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3400 = new BitSet(
11758             new long[] { 0x0942000060170210L, 0x0000000000004090L });
11759     public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3404 = new BitSet(
11760             new long[] { 0x0000000000000002L });
11761     public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3438 = new BitSet(
11762             new long[] { 0x000000001FCDFDE0L, 0x0000000000004000L });
11763     public static final BitSet FOLLOW_typeSpecifier_in_ctfAssignmentExpression3443 = new BitSet(
11764             new long[] { 0x0000000000000002L });
11765     public static final BitSet FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3493 = new BitSet(
11766             new long[] { 0x0001000000000000L, 0x0000000000004000L });
11767     public static final BitSet FOLLOW_declaratorList_in_ctfAssignmentExpression3497 = new BitSet(
11768             new long[] { 0x0000000000000002L });
11769     public static final BitSet FOLLOW_typealiasDecl_in_ctfAssignmentExpression3525 = new BitSet(
11770             new long[] { 0x0000000000000002L });
11771     public static final BitSet FOLLOW_IDENTIFIER_in_synpred1_CTFParser470 = new BitSet(
11772             new long[] { 0x0000000000000002L });
11773     public static final BitSet FOLLOW_ctfKeyword_in_synpred2_CTFParser492 = new BitSet(
11774             new long[] { 0x0000000000000002L });
11775     public static final BitSet FOLLOW_STRING_LITERAL_in_synpred3_CTFParser512 = new BitSet(
11776             new long[] { 0x0000000000000002L });
11777
11778 }