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

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