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