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

   1 // $ANTLR !Unknown version! Grammar/CTFLexer.g 2012-03-09 14:59:17
   2
   3 package org.eclipse.linuxtools.ctf.parser;
   4
   5 import org.antlr.runtime.BaseRecognizer;
   6 import org.antlr.runtime.CharStream;
   7 import org.antlr.runtime.DFA;
   8 import org.antlr.runtime.EarlyExitException;
   9 import org.antlr.runtime.Lexer;
  10 import org.antlr.runtime.MismatchedSetException;
  11 import org.antlr.runtime.MismatchedTokenException;
  12 import org.antlr.runtime.NoViableAltException;
  13 import org.antlr.runtime.RecognitionException;
  14 import org.antlr.runtime.RecognizerSharedState;
  15
  16 @SuppressWarnings({"nls"})
  17 public class CTFLexer extends Lexer {
  18     public static final int SIGN = 49;
  19     public static final int TERM = 47;
  20     public static final int BOOLTOK = 26;
  21     public static final int LT = 39;
  22     public static final int TYPEDEFTOK = 22;
  23     public static final int STRING_CONTENT = 70;
  24     public static final int INTEGER_TYPES_SUFFIX = 53;
  25     public static final int POINTER = 48;
  26     public static final int HEX_PREFIX = 57;
  27     public static final int INTTOK = 13;
  28     public static final int SEPARATOR = 34;
  29     public static final int TYPE_ASSIGNMENT = 38;
  30     public static final int ENUMTOK = 8;
  31     public static final int COMPLEXTOK = 27;
  32     public static final int IMAGINARYTOK = 28;
  33     public static final int DOUBLEQUOTE = 69;
  34     public static final int STREAMTOK = 17;
  35     public static final int EOF = -1;
  36     public static final int INFINITYTOK = 32;
  37     public static final int LPAREN = 43;
  38     public static final int STRINGPREFIX = 65;
  39     public static final int UNSIGNEDTOK = 23;
  40     public static final int ESCAPE_SEQUENCE = 64;
  41     public static final int CHAR_CONTENT = 67;
  42     public static final int RPAREN = 44;
  43     public static final int UNICODE_ESCAPE = 62;
  44     public static final int STRING_LITERAL = 71;
  45     public static final int SINGLEQUOTE = 66;
  46     public static final int IDENTIFIER = 78;
  47     public static final int ALIGNTOK = 4;
  48     public static final int FLOATTOK = 11;
  49     public static final int COMMENT_CLOSE = 74;
  50     public static final int STRINGTOK = 18;
  51     public static final int HEX_LITERAL = 59;
  52     public static final int DIGIT = 55;
  53     public static final int COMMENT = 75;
  54     public static final int DOT = 51;
  55     public static final int STRUCTTOK = 19;
  56     public static final int ENVTOK = 29;
  57     public static final int TYPEALIASTOK = 21;
  58     public static final int OPENBRAC = 41;
  59     public static final int FLOATINGPOINTTOK = 10;
  60     public static final int EVENTTOK = 9;
  61     public static final int LINE_COMMENT = 76;
  62     public static final int NINFINITYTOK = 33;
  63     public static final int VOIDTOK = 25;
  64     public static final int DOUBLETOK = 7;
  65     public static final int CHARACTER_LITERAL = 68;
  66     public static final int OCTAL_LITERAL = 54;
  67     public static final int COMMENT_OPEN = 73;
  68     public static final int HEX_DIGIT = 58;
  69     public static final int OCTAL_ESCAPE = 61;
  70     public static final int NANNUMBERTOK = 31;
  71     public static final int LONGTOK = 14;
  72     public static final int CLOCKTOK = 30;
  73     public static final int SIGNEDTOK = 16;
  74     public static final int TRACETOK = 20;
  75     public static final int COLON = 35;
  76     public static final int HEXADECIMAL_ESCAPE = 63;
  77     public static final int CHARTOK = 6;
  78     public static final int LCURL = 45;
  79     public static final int WS = 72;
  80     public static final int INTEGERTOK = 12;
  81     public static final int VARIANTTOK = 24;
  82     public static final int ELIPSES = 36;
  83     public static final int NONDIGIT = 77;
  84     public static final int RCURL = 46;
  85     public static final int ARROW = 50;
  86     public static final int GT = 40;
  87     public static final int ASSIGNMENT = 37;
  88     public static final int SHORTTOK = 15;
  89     public static final int NONZERO_DIGIT = 60;
  90     public static final int DECIMAL_LITERAL = 56;
  91     public static final int CONSTTOK = 5;
  92     public static final int BACKSLASH = 52;
  93     public static final int CLOSEBRAC = 42;
  94
  95     // delegates
  96     // delegators
  97
  98     public CTFLexer() {
  99     }
 100
 101     public CTFLexer(CharStream input) {
 102         this(input, new RecognizerSharedState());
 103     }
 104
 105     public CTFLexer(CharStream input, RecognizerSharedState state) {
 106         super(input, state);
 107
 108     }
 109
 110     @Override
 111     public String getGrammarFileName() {
 112         return "Grammar/CTFLexer.g";
 113     }
 114
 115     // $ANTLR start "ALIGNTOK"
 116     public final void mALIGNTOK() throws RecognitionException {
 117         int _type = ALIGNTOK;
 118         int _channel = DEFAULT_TOKEN_CHANNEL;
 119         match("align", _type, _channel);
 120     }
 121
 122     // $ANTLR end "ALIGNTOK"
 123
 124     // $ANTLR start "CONSTTOK"
 125     public final void mCONSTTOK() throws RecognitionException {
 126         int _type = CONSTTOK;
 127         int _channel = DEFAULT_TOKEN_CHANNEL;
 128         match("const", _type, _channel);
 129     }
 130
 131     // $ANTLR end "CONSTTOK"
 132
 133     // $ANTLR start "CHARTOK"
 134     public final void mCHARTOK() throws RecognitionException {
 135         int _type = CHARTOK;
 136         int _channel = DEFAULT_TOKEN_CHANNEL;
 137         match("char", _type, _channel);
 138     }
 139
 140     // $ANTLR end "CHARTOK"
 141
 142     // $ANTLR start "DOUBLETOK"
 143     public final void mDOUBLETOK() throws RecognitionException {
 144         int _type = DOUBLETOK;
 145         int _channel = DEFAULT_TOKEN_CHANNEL;
 146         match("double", _type, _channel);
 147     }
 148
 149     // $ANTLR end "DOUBLETOK"
 150
 151     // $ANTLR start "ENUMTOK"
 152     public final void mENUMTOK() throws RecognitionException {
 153         int _type = ENUMTOK;
 154         int _channel = DEFAULT_TOKEN_CHANNEL;
 155         match("enum", _type, _channel);
 156     }
 157
 158     // $ANTLR end "ENUMTOK"
 159
 160     // $ANTLR start "EVENTTOK"
 161     public final void mEVENTTOK() throws RecognitionException {
 162         int _type = EVENTTOK;
 163         int _channel = DEFAULT_TOKEN_CHANNEL;
 164         match("event", _type, _channel);
 165     }
 166
 167     // $ANTLR end "EVENTTOK"
 168
 169     // $ANTLR start "FLOATINGPOINTTOK"
 170     public final void mFLOATINGPOINTTOK() throws RecognitionException {
 171         int _type = FLOATINGPOINTTOK;
 172         int _channel = DEFAULT_TOKEN_CHANNEL;
 173         match("floating_point", _type, _channel);
 174     }
 175
 176     // $ANTLR end "FLOATINGPOINTTOK"
 177
 178     // $ANTLR start "FLOATTOK"
 179     public final void mFLOATTOK() throws RecognitionException {
 180         int _type = FLOATTOK;
 181         int _channel = DEFAULT_TOKEN_CHANNEL;
 182         match("float", _type, _channel);
 183     }
 184
 185     // $ANTLR end "FLOATTOK"
 186
 187     // $ANTLR start "INTEGERTOK"
 188     public final void mINTEGERTOK() throws RecognitionException {
 189         int _type = INTEGERTOK;
 190         int _channel = DEFAULT_TOKEN_CHANNEL;
 191         match("integer", _type, _channel);
 192     }
 193
 194     // $ANTLR end "INTEGERTOK"
 195
 196     // $ANTLR start "INTTOK"
 197     public final void mINTTOK() throws RecognitionException {
 198         int _type = INTTOK;
 199         int _channel = DEFAULT_TOKEN_CHANNEL;
 200         match("int", _type, _channel);
 201     }
 202
 203     // $ANTLR end "INTTOK"
 204
 205     // $ANTLR start "LONGTOK"
 206     public final void mLONGTOK() throws RecognitionException {
 207         int _type = LONGTOK;
 208         int _channel = DEFAULT_TOKEN_CHANNEL;
 209         match("long", _type, _channel);
 210     }
 211
 212     // $ANTLR end "LONGTOK"
 213
 214     // $ANTLR start "SHORTTOK"
 215     public final void mSHORTTOK() throws RecognitionException {
 216         int _type = SHORTTOK;
 217         int _channel = DEFAULT_TOKEN_CHANNEL;
 218         match("short", _type, _channel);
 219     }
 220
 221     // $ANTLR end "SHORTTOK"
 222
 223     // $ANTLR start "SIGNEDTOK"
 224     public final void mSIGNEDTOK() throws RecognitionException {
 225         int _type = SIGNEDTOK;
 226         int _channel = DEFAULT_TOKEN_CHANNEL;
 227         match("signed", _type, _channel);
 228     }
 229
 230     // $ANTLR end "SIGNEDTOK"
 231
 232     // $ANTLR start "STREAMTOK"
 233     public final void mSTREAMTOK() throws RecognitionException {
 234         int _type = STREAMTOK;
 235         int _channel = DEFAULT_TOKEN_CHANNEL;
 236         match("stream", _type, _channel);
 237     }
 238
 239     // $ANTLR end "STREAMTOK"
 240
 241     // $ANTLR start "STRINGTOK"
 242     public final void mSTRINGTOK() throws RecognitionException {
 243         int _type = STRINGTOK;
 244         int _channel = DEFAULT_TOKEN_CHANNEL;
 245         match("string", _type, _channel);
 246     }
 247
 248     // $ANTLR end "STRINGTOK"
 249
 250     // $ANTLR start "STRUCTTOK"
 251     public final void mSTRUCTTOK() throws RecognitionException {
 252         int _type = STRUCTTOK;
 253         int _channel = DEFAULT_TOKEN_CHANNEL;
 254         match("struct", _type, _channel);
 255     }
 256
 257     // $ANTLR end "STRUCTTOK"
 258
 259     // $ANTLR start "TRACETOK"
 260     public final void mTRACETOK() throws RecognitionException {
 261         int _type = TRACETOK;
 262         int _channel = DEFAULT_TOKEN_CHANNEL;
 263         match("trace", _type, _channel);
 264     }
 265
 266     // $ANTLR end "TRACETOK"
 267
 268     // $ANTLR start "TYPEALIASTOK"
 269     public final void mTYPEALIASTOK() throws RecognitionException {
 270         int _type = TYPEALIASTOK;
 271         int _channel = DEFAULT_TOKEN_CHANNEL;
 272         match("typealias", _type, _channel);
 273     }
 274
 275     // $ANTLR end "TYPEALIASTOK"
 276
 277     // $ANTLR start "TYPEDEFTOK"
 278     public final void mTYPEDEFTOK() throws RecognitionException {
 279         int _type = TYPEDEFTOK;
 280         int _channel = DEFAULT_TOKEN_CHANNEL;
 281         match("typedef", _type, _channel);
 282     }
 283
 284     // $ANTLR end "TYPEDEFTOK"
 285
 286     // $ANTLR start "UNSIGNEDTOK"
 287     public final void mUNSIGNEDTOK() throws RecognitionException {
 288         int _type = UNSIGNEDTOK;
 289         int _channel = DEFAULT_TOKEN_CHANNEL;
 290         match("unsigned", _type, _channel);
 291     }
 292
 293     // $ANTLR end "UNSIGNEDTOK"
 294
 295     // $ANTLR start "VARIANTTOK"
 296     public final void mVARIANTTOK() throws RecognitionException {
 297         int _type = VARIANTTOK;
 298         int _channel = DEFAULT_TOKEN_CHANNEL;
 299         match("variant", _type, _channel);
 300     }
 301
 302     // $ANTLR end "VARIANTTOK"
 303
 304     // $ANTLR start "VOIDTOK"
 305     public final void mVOIDTOK() throws RecognitionException {
 306         int _type = VOIDTOK;
 307         int _channel = DEFAULT_TOKEN_CHANNEL;
 308         match("void", _type, _channel);
 309     }
 310
 311     // $ANTLR end "VOIDTOK"
 312
 313     // $ANTLR start "BOOLTOK"
 314     public final void mBOOLTOK() throws RecognitionException {
 315         int _type = BOOLTOK;
 316         int _channel = DEFAULT_TOKEN_CHANNEL;
 317         match("_Bool", _type, _channel);
 318     }
 319
 320     // $ANTLR end "BOOLTOK"
 321
 322     // $ANTLR start "COMPLEXTOK"
 323     public final void mCOMPLEXTOK() throws RecognitionException {
 324         int _type = COMPLEXTOK;
 325         int _channel = DEFAULT_TOKEN_CHANNEL;
 326         match("_Complex", _type, _channel);
 327     }
 328
 329     // $ANTLR end "COMPLEXTOK"
 330
 331     // $ANTLR start "IMAGINARYTOK"
 332     public final void mIMAGINARYTOK() throws RecognitionException {
 333         int _type = IMAGINARYTOK;
 334         int _channel = DEFAULT_TOKEN_CHANNEL;
 335         match("_Imaginary", _type, _channel);
 336     }
 337
 338     // $ANTLR end "IMAGINARYTOK"
 339
 340     // $ANTLR start "ENVTOK"
 341     public final void mENVTOK() throws RecognitionException {
 342         int _type = ENVTOK;
 343         int _channel = DEFAULT_TOKEN_CHANNEL;
 344         match("env", _type, _channel);
 345     }
 346
 347     // $ANTLR end "ENVTOK"
 348
 349     // $ANTLR start "CLOCKTOK"
 350     public final void mCLOCKTOK() throws RecognitionException {
 351         int _type = CLOCKTOK;
 352         int _channel = DEFAULT_TOKEN_CHANNEL;
 353         match("clock", _type, _channel);
 354     }
 355
 356     // $ANTLR end "CLOCKTOK"
 357
 358     // $ANTLR start "NANNUMBERTOK"
 359     public final void mNANNUMBERTOK() throws RecognitionException {
 360         int _type = NANNUMBERTOK;
 361         int _channel = DEFAULT_TOKEN_CHANNEL;
 362         match("NaN", _type, _channel);
 363     }
 364
 365     // $ANTLR end "NANNUMBERTOK"
 366
 367     // $ANTLR start "INFINITYTOK"
 368     public final void mINFINITYTOK() throws RecognitionException {
 369         int _type = INFINITYTOK;
 370         int _channel = DEFAULT_TOKEN_CHANNEL;
 371         match("+inf", _type, _channel);
 372     }
 373
 374     // $ANTLR end "INFINITYTOK"
 375
 376     // $ANTLR start "NINFINITYTOK"
 377     public final void mNINFINITYTOK() throws RecognitionException {
 378         int _type = NINFINITYTOK;
 379         int _channel = DEFAULT_TOKEN_CHANNEL;
 380         match("-inf", _type, _channel);
 381     }
 382
 383     // $ANTLR end "NINFINITYTOK"
 384
 385     // $ANTLR start "SEPARATOR"
 386     public final void mSEPARATOR() throws RecognitionException {
 387         int _type = SEPARATOR;
 388         int _channel = DEFAULT_TOKEN_CHANNEL;
 389         match(',', _type, _channel);
 390     }
 391
 392     // $ANTLR end "SEPARATOR"
 393
 394     // $ANTLR start "COLON"
 395     public final void mCOLON() throws RecognitionException {
 396         int _type = COLON;
 397         int _channel = DEFAULT_TOKEN_CHANNEL;
 398         match(':', _type, _channel);
 399     }
 400
 401     // $ANTLR end "COLON"
 402
 403     // $ANTLR start "ELIPSES"
 404     public final void mELIPSES() throws RecognitionException {
 405         int _type = ELIPSES;
 406         int _channel = DEFAULT_TOKEN_CHANNEL;
 407         match("...", _type, _channel);
 408     }
 409
 410     // $ANTLR end "ELIPSES"
 411
 412     // $ANTLR start "ASSIGNMENT"
 413     public final void mASSIGNMENT() throws RecognitionException {
 414         int _type = ASSIGNMENT;
 415         int _channel = DEFAULT_TOKEN_CHANNEL;
 416         match('=', _type, _channel);
 417     }
 418
 419     // $ANTLR end "ASSIGNMENT"
 420
 421     // $ANTLR start "TYPE_ASSIGNMENT"
 422     public final void mTYPE_ASSIGNMENT() throws RecognitionException {
 423         int _type = TYPE_ASSIGNMENT;
 424         int _channel = DEFAULT_TOKEN_CHANNEL;
 425         match(":=", _type, _channel);
 426     }
 427
 428     // $ANTLR end "TYPE_ASSIGNMENT"
 429
 430     // $ANTLR start "LT"
 431     public final void mLT() throws RecognitionException {
 432         int _type = LT;
 433         int _channel = DEFAULT_TOKEN_CHANNEL;
 434         match('<', _type, _channel);
 435     }
 436
 437     // $ANTLR end "LT"
 438
 439     // $ANTLR start "GT"
 440     public final void mGT() throws RecognitionException {
 441         int _type = GT;
 442         int _channel = DEFAULT_TOKEN_CHANNEL;
 443         match('>', _type, _channel);
 444     }
 445
 446     // $ANTLR end "GT"
 447
 448     // $ANTLR start "OPENBRAC"
 449     public final void mOPENBRAC() throws RecognitionException {
 450         int _type = OPENBRAC;
 451         int _channel = DEFAULT_TOKEN_CHANNEL;
 452         match('[', _type, _channel);
 453     }
 454
 455     // $ANTLR end "OPENBRAC"
 456
 457     // $ANTLR start "CLOSEBRAC"
 458     public final void mCLOSEBRAC() throws RecognitionException {
 459         int _type = CLOSEBRAC;
 460         int _channel = DEFAULT_TOKEN_CHANNEL;
 461         match(']', _type, _channel);
 462     }
 463
 464     // $ANTLR end "CLOSEBRAC"
 465
 466     // $ANTLR start "LPAREN"
 467     public final void mLPAREN() throws RecognitionException {
 468         int _type = LPAREN;
 469         int _channel = DEFAULT_TOKEN_CHANNEL;
 470         match('(', _type, _channel);
 471     }
 472
 473     // $ANTLR end "LPAREN"
 474
 475     // $ANTLR start "RPAREN"
 476     public final void mRPAREN() throws RecognitionException {
 477         int _type = RPAREN;
 478         int _channel = DEFAULT_TOKEN_CHANNEL;
 479         match(')', _type, _channel);
 480     }
 481
 482     // $ANTLR end "RPAREN"
 483
 484     // $ANTLR start "LCURL"
 485     public final void mLCURL() throws RecognitionException {
 486         int _type = LCURL;
 487         int _channel = DEFAULT_TOKEN_CHANNEL;
 488         match('{', _type, _channel);
 489     }
 490
 491     // $ANTLR end "LCURL"
 492
 493     // $ANTLR start "RCURL"
 494     public final void mRCURL() throws RecognitionException {
 495         int _type = RCURL;
 496         int _channel = DEFAULT_TOKEN_CHANNEL;
 497         match('}', _type, _channel);
 498     }
 499
 500     // $ANTLR end "RCURL"
 501
 502     // $ANTLR start "TERM"
 503     public final void mTERM() throws RecognitionException {
 504         int _type = TERM;
 505         int _channel = DEFAULT_TOKEN_CHANNEL;
 506         match(';', _type, _channel);
 507     }
 508
 509     // $ANTLR end "TERM"
 510
 511     // $ANTLR start "POINTER"
 512     public final void mPOINTER() throws RecognitionException {
 513         int _type = POINTER;
 514         int _channel = DEFAULT_TOKEN_CHANNEL;
 515         match('*', _type, _channel);
 516     }
 517
 518     /**
 519      * @param matchable
 520      * @param _type
 521      * @param _channel
 522      * @throws MismatchedTokenException
 523      */
 524     private void match(String matchable, int _type, int _channel)
 525             throws MismatchedTokenException {
 526         match(matchable);
 527         setState(_type, _channel);
 528     }
 529
 530     /**
 531      * @param matchable
 532      * @param _type
 533      * @param _channel
 534      * @throws MismatchedTokenException
 535      */
 536     private void match(char matchable, int _type, int _channel)
 537             throws MismatchedTokenException {
 538         match(matchable);
 539         setState(_type, _channel);
 540     }
 541
 542     /**
 543      * @param _type
 544      * @param _channel
 545      */
 546     private void setState(int _type, int _channel) {
 547         state.type = _type;
 548         state.channel = _channel;
 549     }
 550
 551     // $ANTLR end "POINTER"
 552
 553     // $ANTLR start "SIGN"
 554     public final void mSIGN() throws RecognitionException {
 555         int _type = SIGN;
 556         int _channel = DEFAULT_TOKEN_CHANNEL;
 557         // Grammar/CTFLexer.g:71:20: ( '+' | '-' )
 558         // Grammar/CTFLexer.g:
 559         {
 560             if ((input.LA(1) == '+') || (input.LA(1) == '-')) {
 561                 input.consume();
 562
 563             } else {
 564                 MismatchedSetException mse = new MismatchedSetException(null,
 565                         input);
 566                 recover(mse);
 567                 throw mse;
 568             }
 569
 570         }
 571
 572         setState(_type, _channel);
 573     }
 574
 575     // $ANTLR end "SIGN"
 576
 577     // $ANTLR start "ARROW"
 578     public final void mARROW() throws RecognitionException {
 579         int _type = ARROW;
 580         int _channel = DEFAULT_TOKEN_CHANNEL;
 581         match("->", _type, _channel);
 582     }
 583
 584     // $ANTLR end "ARROW"
 585
 586     // $ANTLR start "DOT"
 587     public final void mDOT() throws RecognitionException {
 588         int _type = DOT;
 589         int _channel = DEFAULT_TOKEN_CHANNEL;
 590         match('.', _type, _channel);
 591     }
 592
 593     // $ANTLR end "DOT"
 594
 595     // $ANTLR start "BACKSLASH"
 596     public final void mBACKSLASH() throws RecognitionException {
 597         match('\\');
 598     }
 599
 600     // $ANTLR end "BACKSLASH"
 601
 602     // $ANTLR start "OCTAL_LITERAL"
 603     public final void mOCTAL_LITERAL() throws RecognitionException {
 604         int _type = OCTAL_LITERAL;
 605         int _channel = DEFAULT_TOKEN_CHANNEL;
 606         {
 607             match('0');
 608             // Grammar/CTFLexer.g:89:21: ( '0' .. '7' )+
 609             int cnt1 = 0;
 610             loop1: do {
 611                 int alt1 = 2;
 612                 int LA1_0 = input.LA(1);
 613
 614                 if ((((LA1_0 >= '0') && (LA1_0 <= '7')))) {
 615                     alt1 = 1;
 616                 }
 617
 618                 switch (alt1) {
 619                 case 1:
 620                 // Grammar/CTFLexer.g:89:22: '0' .. '7'
 621                 {
 622                     matchRange('0', '7');
 623
 624                 }
 625                     break;
 626
 627                 default:
 628                     if (cnt1 >= 1) {
 629                         break loop1;
 630                     }
 631                     EarlyExitException eee = new EarlyExitException(1, input);
 632                     throw eee;
 633                 }
 634                 cnt1++;
 635             } while (true);
 636
 637             // Grammar/CTFLexer.g:89:33: ( INTEGER_TYPES_SUFFIX )?
 638             int alt2 = 2;
 639             int LA2_0 = input.LA(1);
 640
 641             if (((LA2_0 == 'L') || (LA2_0 == 'U') || (LA2_0 == 'l') || (LA2_0 == 'u'))) {
 642                 alt2 = 1;
 643             }
 644             switch (alt2) {
 645             case 1:
 646             // Grammar/CTFLexer.g:89:33: INTEGER_TYPES_SUFFIX
 647             {
 648                 mINTEGER_TYPES_SUFFIX();
 649
 650             }
 651                 break;
 652
 653             }
 654
 655         }
 656
 657         setState(_type, _channel);
 658     }
 659
 660     // $ANTLR end "OCTAL_LITERAL"
 661
 662     // $ANTLR start "DECIMAL_LITERAL"
 663     public final void mDECIMAL_LITERAL() throws RecognitionException {
 664         int _type = DECIMAL_LITERAL;
 665         int _channel = DEFAULT_TOKEN_CHANNEL;
 666         // Grammar/CTFLexer.g:91:17: ( ( DIGIT )+ ( INTEGER_TYPES_SUFFIX )?
 667         // )
 668         // Grammar/CTFLexer.g:91:19: ( DIGIT )+ ( INTEGER_TYPES_SUFFIX )?
 669         {
 670             // Grammar/CTFLexer.g:91:19: ( DIGIT )+
 671             int cnt3 = 0;
 672             loop3: do {
 673                 int alt3 = 2;
 674                 int LA3_0 = input.LA(1);
 675
 676                 if ((((LA3_0 >= '0') && (LA3_0 <= '9')))) {
 677                     alt3 = 1;
 678                 }
 679
 680                 switch (alt3) {
 681                 case 1:
 682                 // Grammar/CTFLexer.g:91:19: DIGIT
 683                 {
 684                     mDIGIT();
 685
 686                 }
 687                     break;
 688
 689                 default:
 690                     if (cnt3 >= 1) {
 691                         break loop3;
 692                     }
 693                     EarlyExitException eee = new EarlyExitException(3, input);
 694                     throw eee;
 695                 }
 696                 cnt3++;
 697             } while (true);
 698
 699             // Grammar/CTFLexer.g:91:26: ( INTEGER_TYPES_SUFFIX )?
 700             int alt4 = 2;
 701             int LA4_0 = input.LA(1);
 702
 703             if (((LA4_0 == 'L') || (LA4_0 == 'U') || (LA4_0 == 'l') || (LA4_0 == 'u'))) {
 704                 alt4 = 1;
 705             }
 706             switch (alt4) {
 707             case 1:
 708             // Grammar/CTFLexer.g:91:26: INTEGER_TYPES_SUFFIX
 709             {
 710                 mINTEGER_TYPES_SUFFIX();
 711
 712             }
 713                 break;
 714
 715             }
 716
 717         }
 718
 719         setState(_type, _channel);
 720     }
 721
 722     // $ANTLR end "DECIMAL_LITERAL"
 723
 724     // $ANTLR start "HEX_LITERAL"
 725     public final void mHEX_LITERAL() throws RecognitionException {
 726         int _type = HEX_LITERAL;
 727         int _channel = DEFAULT_TOKEN_CHANNEL;
 728         // Grammar/CTFLexer.g:93:13: ( HEX_PREFIX ( HEX_DIGIT )+ (
 729         // INTEGER_TYPES_SUFFIX )? )
 730         // Grammar/CTFLexer.g:93:15: HEX_PREFIX ( HEX_DIGIT )+ (
 731         // INTEGER_TYPES_SUFFIX )?
 732         {
 733             mHEX_PREFIX();
 734             // Grammar/CTFLexer.g:93:26: ( HEX_DIGIT )+
 735             int cnt5 = 0;
 736             loop5: do {
 737                 int alt5 = 2;
 738                 int LA5_0 = input.LA(1);
 739
 740                 if ((((LA5_0 >= '0') && (LA5_0 <= '9'))
 741                         || ((LA5_0 >= 'A') && (LA5_0 <= 'F')) || ((LA5_0 >= 'a') && (LA5_0 <= 'f')))) {
 742                     alt5 = 1;
 743                 }
 744
 745                 switch (alt5) {
 746                 case 1:
 747                 // Grammar/CTFLexer.g:93:26: HEX_DIGIT
 748                 {
 749                     mHEX_DIGIT();
 750
 751                 }
 752                     break;
 753
 754                 default:
 755                     if (cnt5 >= 1) {
 756                         break loop5;
 757                     }
 758                     EarlyExitException eee = new EarlyExitException(5, input);
 759                     throw eee;
 760                 }
 761                 cnt5++;
 762             } while (true);
 763
 764             // Grammar/CTFLexer.g:93:37: ( INTEGER_TYPES_SUFFIX )?
 765             int alt6 = 2;
 766             int LA6_0 = input.LA(1);
 767
 768             if (((LA6_0 == 'L') || (LA6_0 == 'U') || (LA6_0 == 'l') || (LA6_0 == 'u'))) {
 769                 alt6 = 1;
 770             }
 771             switch (alt6) {
 772             case 1:
 773             // Grammar/CTFLexer.g:93:37: INTEGER_TYPES_SUFFIX
 774             {
 775                 mINTEGER_TYPES_SUFFIX();
 776
 777             }
 778                 break;
 779
 780             }
 781
 782         }
 783
 784         setState(_type, _channel);
 785     }
 786
 787     // $ANTLR end "HEX_LITERAL"
 788
 789     // $ANTLR start "HEX_DIGIT"
 790     public final void mHEX_DIGIT() throws RecognitionException {
 791         int alt7 = 3;
 792         switch (input.LA(1)) {
 793         case '0':
 794         case '1':
 795         case '2':
 796         case '3':
 797         case '4':
 798         case '5':
 799         case '6':
 800         case '7':
 801         case '8':
 802         case '9': {
 803             alt7 = 1;
 804         }
 805             break;
 806         case 'a':
 807         case 'b':
 808         case 'c':
 809         case 'd':
 810         case 'e':
 811         case 'f': {
 812             alt7 = 2;
 813         }
 814             break;
 815         case 'A':
 816         case 'B':
 817         case 'C':
 818         case 'D':
 819         case 'E':
 820         case 'F': {
 821             alt7 = 3;
 822         }
 823             break;
 824         default:
 825             NoViableAltException nvae = new NoViableAltException("", 7, 0,
 826                     input);
 827
 828             throw nvae;
 829         }
 830
 831         switch (alt7) {
 832         case 1:
 833         // Grammar/CTFLexer.g:94:22: DIGIT
 834         {
 835             mDIGIT();
 836
 837         }
 838             break;
 839         case 2:
 840         // Grammar/CTFLexer.g:94:30: ( 'a' .. 'f' )
 841         {
 842             // Grammar/CTFLexer.g:94:30: ( 'a' .. 'f' )
 843             // Grammar/CTFLexer.g:94:31: 'a' .. 'f'
 844             {
 845                 matchRange('a', 'f');
 846
 847             }
 848
 849         }
 850             break;
 851         case 3:
 852         // Grammar/CTFLexer.g:94:43: ( 'A' .. 'F' )
 853         {
 854             // Grammar/CTFLexer.g:94:43: ( 'A' .. 'F' )
 855             // Grammar/CTFLexer.g:94:44: 'A' .. 'F'
 856             {
 857                 matchRange('A', 'F');
 858
 859             }
 860
 861         }
 862             break;
 863
 864         }
 865     }
 866
 867     // $ANTLR end "HEX_DIGIT"
 868
 869     // $ANTLR start "HEX_PREFIX"
 870     public final void mHEX_PREFIX() throws RecognitionException {
 871         {
 872             match('0');
 873             if ((input.LA(1) == 'X') || (input.LA(1) == 'x')) {
 874                 input.consume();
 875
 876             } else {
 877                 MismatchedSetException mse = new MismatchedSetException(null,
 878                         input);
 879                 recover(mse);
 880                 throw mse;
 881             }
 882
 883         }
 884
 885     }
 886
 887     // $ANTLR end "HEX_PREFIX"
 888
 889     // $ANTLR start "DIGIT"
 890     public final void mDIGIT() throws RecognitionException {
 891         // Grammar/CTFLexer.g:98:16: ( '0' .. '9' )
 892         // Grammar/CTFLexer.g:98:18: '0' .. '9'
 893         {
 894             matchRange('0', '9');
 895
 896         }
 897
 898     }
 899
 900     // $ANTLR end "DIGIT"
 901
 902     // $ANTLR start "NONZERO_DIGIT"
 903     public final void mNONZERO_DIGIT() throws RecognitionException {
 904         // Grammar/CTFLexer.g:99:24: ( '1' .. '9' )
 905         // Grammar/CTFLexer.g:99:26: '1' .. '9'
 906         {
 907             matchRange('1', '9');
 908
 909         }
 910
 911     }
 912
 913     // $ANTLR end "NONZERO_DIGIT"
 914
 915     // $ANTLR start "INTEGER_TYPES_SUFFIX"
 916     public final void mINTEGER_TYPES_SUFFIX() throws RecognitionException {
 917         // Grammar/CTFLexer.g:107:31: ( ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | (
 918         // 'u' | 'U' ) | ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | (
 919         // 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' ) )
 920         int alt17 = 4;
 921         alt17 = dfa17.predict(input);
 922         switch (alt17) {
 923         case 1:
 924         // Grammar/CTFLexer.g:108:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
 925         {
 926             // Grammar/CTFLexer.g:108:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
 927             int alt10 = 2;
 928             int LA10_0 = input.LA(1);
 929
 930             if ((LA10_0 == 'l')) {
 931                 alt10 = 1;
 932             } else if ((LA10_0 == 'L')) {
 933                 alt10 = 2;
 934             } else {
 935                 NoViableAltException nvae = new NoViableAltException("", 10, 0,
 936                         input);
 937
 938                 throw nvae;
 939             }
 940             switch (alt10) {
 941             case 1:
 942             // Grammar/CTFLexer.g:108:5: 'l' ( 'l' )?
 943             {
 944                 match('l');
 945                 // Grammar/CTFLexer.g:108:9: ( 'l' )?
 946                 int alt8 = 2;
 947                 int LA8_0 = input.LA(1);
 948
 949                 if ((LA8_0 == 'l')) {
 950                     alt8 = 1;
 951                 }
 952                 switch (alt8) {
 953                 case 1:
 954                 // Grammar/CTFLexer.g:108:10: 'l'
 955                 {
 956                     match('l');
 957
 958                 }
 959                     break;
 960
 961                 }
 962
 963             }
 964                 break;
 965             case 2:
 966             // Grammar/CTFLexer.g:108:18: 'L' ( 'L' )?
 967             {
 968                 match('L');
 969                 // Grammar/CTFLexer.g:108:22: ( 'L' )?
 970                 int alt9 = 2;
 971                 int LA9_0 = input.LA(1);
 972
 973                 if ((LA9_0 == 'L')) {
 974                     alt9 = 1;
 975                 }
 976                 switch (alt9) {
 977                 case 1:
 978                 // Grammar/CTFLexer.g:108:23: 'L'
 979                 {
 980                     match('L');
 981
 982                 }
 983                     break;
 984
 985                 }
 986
 987             }
 988                 break;
 989
 990             }
 991
 992         }
 993             break;
 994         case 2:
 995         // Grammar/CTFLexer.g:109:4: ( 'u' | 'U' )
 996         {
 997             if ((input.LA(1) == 'U') || (input.LA(1) == 'u')) {
 998                 input.consume();
 999
1000             } else {
1001                 MismatchedSetException mse = new MismatchedSetException(null,
1002                         input);
1003                 recover(mse);
1004                 throw mse;
1005             }
1006
1007         }
1008             break;
1009         case 3:
1010         // Grammar/CTFLexer.g:110:4: ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' (
1011         // 'L' )? )
1012         {
1013             if ((input.LA(1) == 'U') || (input.LA(1) == 'u')) {
1014                 input.consume();
1015
1016             } else {
1017                 MismatchedSetException mse = new MismatchedSetException(null,
1018                         input);
1019                 recover(mse);
1020                 throw mse;
1021             }
1022
1023             // Grammar/CTFLexer.g:110:16: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
1024             int alt13 = 2;
1025             int LA13_0 = input.LA(1);
1026
1027             if ((LA13_0 == 'l')) {
1028                 alt13 = 1;
1029             } else if ((LA13_0 == 'L')) {
1030                 alt13 = 2;
1031             } else {
1032                 NoViableAltException nvae = new NoViableAltException("", 13, 0,
1033                         input);
1034
1035                 throw nvae;
1036             }
1037             switch (alt13) {
1038             case 1:
1039             // Grammar/CTFLexer.g:110:17: 'l' ( 'l' )?
1040             {
1041                 match('l');
1042                 // Grammar/CTFLexer.g:110:21: ( 'l' )?
1043                 int alt11 = 2;
1044                 int LA11_0 = input.LA(1);
1045
1046                 if ((LA11_0 == 'l')) {
1047                     alt11 = 1;
1048                 }
1049                 switch (alt11) {
1050                 case 1:
1051                 // Grammar/CTFLexer.g:110:22: 'l'
1052                 {
1053                     match('l');
1054
1055                 }
1056                     break;
1057
1058                 }
1059
1060             }
1061                 break;
1062             case 2:
1063             // Grammar/CTFLexer.g:110:30: 'L' ( 'L' )?
1064             {
1065                 match('L');
1066                 // Grammar/CTFLexer.g:110:34: ( 'L' )?
1067                 int alt12 = 2;
1068                 int LA12_0 = input.LA(1);
1069
1070                 if ((LA12_0 == 'L')) {
1071                     alt12 = 1;
1072                 }
1073                 switch (alt12) {
1074                 case 1:
1075                 // Grammar/CTFLexer.g:110:35: 'L'
1076                 {
1077                     match('L');
1078
1079                 }
1080                     break;
1081
1082                 }
1083
1084             }
1085                 break;
1086
1087             }
1088
1089         }
1090             break;
1091         case 4:
1092         // Grammar/CTFLexer.g:111:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' |
1093         // 'U' )
1094         {
1095             // Grammar/CTFLexer.g:111:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
1096             int alt16 = 2;
1097             int LA16_0 = input.LA(1);
1098
1099             if ((LA16_0 == 'l')) {
1100                 alt16 = 1;
1101             } else if ((LA16_0 == 'L')) {
1102                 alt16 = 2;
1103             } else {
1104                 NoViableAltException nvae = new NoViableAltException("", 16, 0,
1105                         input);
1106
1107                 throw nvae;
1108             }
1109             switch (alt16) {
1110             case 1:
1111             // Grammar/CTFLexer.g:111:5: 'l' ( 'l' )?
1112             {
1113                 match('l');
1114                 // Grammar/CTFLexer.g:111:9: ( 'l' )?
1115                 int alt14 = 2;
1116                 int LA14_0 = input.LA(1);
1117
1118                 if ((LA14_0 == 'l')) {
1119                     alt14 = 1;
1120                 }
1121                 switch (alt14) {
1122                 case 1:
1123                 // Grammar/CTFLexer.g:111:10: 'l'
1124                 {
1125                     match('l');
1126
1127                 }
1128                     break;
1129
1130                 }
1131
1132             }
1133                 break;
1134             case 2:
1135             // Grammar/CTFLexer.g:111:18: 'L' ( 'L' )?
1136             {
1137                 match('L');
1138                 // Grammar/CTFLexer.g:111:22: ( 'L' )?
1139                 int alt15 = 2;
1140                 int LA15_0 = input.LA(1);
1141
1142                 if ((LA15_0 == 'L')) {
1143                     alt15 = 1;
1144                 }
1145                 switch (alt15) {
1146                 case 1:
1147                 // Grammar/CTFLexer.g:111:23: 'L'
1148                 {
1149                     match('L');
1150
1151                 }
1152                     break;
1153
1154                 }
1155
1156             }
1157                 break;
1158
1159             }
1160
1161             if ((input.LA(1) == 'U') || (input.LA(1) == 'u')) {
1162                 input.consume();
1163
1164             } else {
1165                 MismatchedSetException mse = new MismatchedSetException(null,
1166                         input);
1167                 recover(mse);
1168                 throw mse;
1169             }
1170
1171         }
1172             break;
1173
1174         }
1175     }
1176
1177     // $ANTLR end "INTEGER_TYPES_SUFFIX"
1178
1179     // $ANTLR start "ESCAPE_SEQUENCE"
1180     public final void mESCAPE_SEQUENCE() throws RecognitionException {
1181         // Grammar/CTFLexer.g:117:26: ( BACKSLASH ( '\\'' | '\"' | '?' |
1182         // BACKSLASH | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' ) |
1183         // OCTAL_ESCAPE | UNICODE_ESCAPE | HEXADECIMAL_ESCAPE )
1184         int alt18 = 4;
1185         int LA18_0 = input.LA(1);
1186
1187         if ((LA18_0 == '\\')) {
1188             switch (input.LA(2)) {
1189             case 'U':
1190             case 'u': {
1191                 alt18 = 3;
1192             }
1193                 break;
1194             case '0':
1195             case '1':
1196             case '2':
1197             case '3':
1198             case '4':
1199             case '5':
1200             case '6':
1201             case '7': {
1202                 alt18 = 2;
1203             }
1204                 break;
1205             case 'x': {
1206                 alt18 = 4;
1207             }
1208                 break;
1209             case '\"':
1210             case '\'':
1211             case '?':
1212             case '\\':
1213             case 'a':
1214             case 'b':
1215             case 'f':
1216             case 'n':
1217             case 'r':
1218             case 't':
1219             case 'v': {
1220                 alt18 = 1;
1221             }
1222                 break;
1223             default:
1224                 NoViableAltException nvae = new NoViableAltException("", 18, 1,
1225                         input);
1226
1227                 throw nvae;
1228             }
1229
1230         } else {
1231             NoViableAltException nvae = new NoViableAltException("", 18, 0,
1232                     input);
1233
1234             throw nvae;
1235         }
1236         switch (alt18) {
1237         case 1:
1238         // Grammar/CTFLexer.g:118:4: BACKSLASH ( '\\'' | '\"' | '?' |
1239         // BACKSLASH | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' )
1240         {
1241             mBACKSLASH();
1242             if ((input.LA(1) == '\"') || (input.LA(1) == '\'')
1243                     || (input.LA(1) == '?') || (input.LA(1) == '\\')
1244                     || ((input.LA(1) >= 'a') && (input.LA(1) <= 'b'))
1245                     || (input.LA(1) == 'f') || (input.LA(1) == 'n')
1246                     || (input.LA(1) == 'r') || (input.LA(1) == 't')
1247                     || (input.LA(1) == 'v')) {
1248                 input.consume();
1249
1250             } else {
1251                 MismatchedSetException mse = new MismatchedSetException(null,
1252                         input);
1253                 recover(mse);
1254                 throw mse;
1255             }
1256
1257         }
1258             break;
1259         case 2:
1260         // Grammar/CTFLexer.g:119:4: OCTAL_ESCAPE
1261         {
1262             mOCTAL_ESCAPE();
1263
1264         }
1265             break;
1266         case 3:
1267         // Grammar/CTFLexer.g:120:4: UNICODE_ESCAPE
1268         {
1269             mUNICODE_ESCAPE();
1270
1271         }
1272             break;
1273         case 4:
1274         // Grammar/CTFLexer.g:121:4: HEXADECIMAL_ESCAPE
1275         {
1276             mHEXADECIMAL_ESCAPE();
1277
1278         }
1279             break;
1280
1281         }
1282     }
1283
1284     // $ANTLR end "ESCAPE_SEQUENCE"
1285
1286     // $ANTLR start "OCTAL_ESCAPE"
1287     public final void mOCTAL_ESCAPE() throws RecognitionException {
1288         // Grammar/CTFLexer.g:127:23: ( BACKSLASH ( '0' .. '3' ) ( '0' ..
1289         // '7' ) ( '0' .. '7' ) | BACKSLASH ( '0' .. '7' ) ( '0' .. '7' ) |
1290         // BACKSLASH ( '0' .. '7' ) )
1291         int alt19 = 3;
1292         int LA19_0 = input.LA(1);
1293
1294         if ((LA19_0 == '\\')) {
1295             int LA19_1 = input.LA(2);
1296
1297             if ((((LA19_1 >= '0') && (LA19_1 <= '3')))) {
1298                 int LA19_2 = input.LA(3);
1299
1300                 if ((((LA19_2 >= '0') && (LA19_2 <= '7')))) {
1301                     int LA19_5 = input.LA(4);
1302
1303                     if ((((LA19_5 >= '0') && (LA19_5 <= '7')))) {
1304                         alt19 = 1;
1305                     } else {
1306                         alt19 = 2;
1307                     }
1308                 } else {
1309                     alt19 = 3;
1310                 }
1311             } else if ((((LA19_1 >= '4') && (LA19_1 <= '7')))) {
1312                 int LA19_3 = input.LA(3);
1313
1314                 if ((((LA19_3 >= '0') && (LA19_3 <= '7')))) {
1315                     alt19 = 2;
1316                 } else {
1317                     alt19 = 3;
1318                 }
1319             } else {
1320                 NoViableAltException nvae = new NoViableAltException("", 19, 1,
1321                         input);
1322
1323                 throw nvae;
1324             }
1325         } else {
1326             NoViableAltException nvae = new NoViableAltException("", 19, 0,
1327                     input);
1328
1329             throw nvae;
1330         }
1331         switch (alt19) {
1332         case 1:
1333         // Grammar/CTFLexer.g:128:5: BACKSLASH ( '0' .. '3' ) ( '0' .. '7' )
1334         // ( '0' .. '7' )
1335         {
1336             mBACKSLASH();
1337             // Grammar/CTFLexer.g:128:15: ( '0' .. '3' )
1338             // Grammar/CTFLexer.g:128:16: '0' .. '3'
1339             {
1340                 matchRange('0', '3');
1341
1342             }
1343
1344             // Grammar/CTFLexer.g:128:26: ( '0' .. '7' )
1345             // Grammar/CTFLexer.g:128:27: '0' .. '7'
1346             {
1347                 matchRange('0', '7');
1348
1349             }
1350
1351             // Grammar/CTFLexer.g:128:37: ( '0' .. '7' )
1352             // Grammar/CTFLexer.g:128:38: '0' .. '7'
1353             {
1354                 matchRange('0', '7');
1355
1356             }
1357
1358         }
1359             break;
1360         case 2:
1361         // Grammar/CTFLexer.g:129:5: BACKSLASH ( '0' .. '7' ) ( '0' .. '7' )
1362         {
1363             mBACKSLASH();
1364             // Grammar/CTFLexer.g:129:15: ( '0' .. '7' )
1365             // Grammar/CTFLexer.g:129:16: '0' .. '7'
1366             {
1367                 matchRange('0', '7');
1368
1369             }
1370
1371             // Grammar/CTFLexer.g:129:26: ( '0' .. '7' )
1372             // Grammar/CTFLexer.g:129:27: '0' .. '7'
1373             {
1374                 matchRange('0', '7');
1375
1376             }
1377
1378         }
1379             break;
1380         case 3:
1381         // Grammar/CTFLexer.g:130:5: BACKSLASH ( '0' .. '7' )
1382         {
1383             mBACKSLASH();
1384             // Grammar/CTFLexer.g:130:15: ( '0' .. '7' )
1385             // Grammar/CTFLexer.g:130:16: '0' .. '7'
1386             {
1387                 matchRange('0', '7');
1388
1389             }
1390
1391         }
1392             break;
1393
1394         }
1395     }
1396
1397     // $ANTLR end "OCTAL_ESCAPE"
1398
1399     // $ANTLR start "HEXADECIMAL_ESCAPE"
1400     public final void mHEXADECIMAL_ESCAPE() throws RecognitionException {
1401         // Grammar/CTFLexer.g:136:29: ( BACKSLASH 'x' ( HEX_DIGIT )+ )
1402         // Grammar/CTFLexer.g:136:31: BACKSLASH 'x' ( HEX_DIGIT )+
1403         {
1404             mBACKSLASH();
1405             match('x');
1406             // Grammar/CTFLexer.g:136:45: ( HEX_DIGIT )+
1407             int cnt20 = 0;
1408             loop20: do {
1409                 int alt20 = 2;
1410                 int LA20_0 = input.LA(1);
1411
1412                 if ((((LA20_0 >= '0') && (LA20_0 <= '9'))
1413                         || ((LA20_0 >= 'A') && (LA20_0 <= 'F')) || ((LA20_0 >= 'a') && (LA20_0 <= 'f')))) {
1414                     alt20 = 1;
1415                 }
1416
1417                 switch (alt20) {
1418                 case 1:
1419                 // Grammar/CTFLexer.g:136:45: HEX_DIGIT
1420                 {
1421                     mHEX_DIGIT();
1422
1423                 }
1424                     break;
1425
1426                 default:
1427                     if (cnt20 >= 1) {
1428                         break loop20;
1429                     }
1430                     EarlyExitException eee = new EarlyExitException(20, input);
1431                     throw eee;
1432                 }
1433                 cnt20++;
1434             } while (true);
1435
1436         }
1437     }
1438
1439     // $ANTLR end "HEXADECIMAL_ESCAPE"
1440
1441     // $ANTLR start "UNICODE_ESCAPE"
1442     public final void mUNICODE_ESCAPE() throws RecognitionException {
1443         // Grammar/CTFLexer.g:141:25: ( BACKSLASH 'u' HEX_DIGIT HEX_DIGIT
1444         // HEX_DIGIT HEX_DIGIT | BACKSLASH 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT
1445         // HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
1446         int alt21 = 2;
1447         int LA21_0 = input.LA(1);
1448
1449         if ((LA21_0 == '\\')) {
1450             int LA21_1 = input.LA(2);
1451
1452             if ((LA21_1 == 'u')) {
1453                 alt21 = 1;
1454             } else if ((LA21_1 == 'U')) {
1455                 alt21 = 2;
1456             } else {
1457                 NoViableAltException nvae = new NoViableAltException("", 21, 1,
1458                         input);
1459
1460                 throw nvae;
1461             }
1462         } else {
1463             NoViableAltException nvae = new NoViableAltException("", 21, 0,
1464                     input);
1465
1466             throw nvae;
1467         }
1468         switch (alt21) {
1469         case 1:
1470         // Grammar/CTFLexer.g:142:5: BACKSLASH 'u' HEX_DIGIT HEX_DIGIT
1471         // HEX_DIGIT HEX_DIGIT
1472         {
1473             mBACKSLASH();
1474             match('u');
1475             mHEX_DIGIT();
1476             mHEX_DIGIT();
1477             mHEX_DIGIT();
1478             mHEX_DIGIT();
1479
1480         }
1481             break;
1482         case 2:
1483         // Grammar/CTFLexer.g:143:5: BACKSLASH 'U' HEX_DIGIT HEX_DIGIT
1484         // HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
1485         {
1486             mBACKSLASH();
1487             match('U');
1488             mHEX_DIGIT();
1489             mHEX_DIGIT();
1490             mHEX_DIGIT();
1491             mHEX_DIGIT();
1492             mHEX_DIGIT();
1493             mHEX_DIGIT();
1494             mHEX_DIGIT();
1495             mHEX_DIGIT();
1496
1497         }
1498             break;
1499         }
1500     }
1501
1502     // $ANTLR end "UNICODE_ESCAPE"
1503
1504     // $ANTLR start "STRINGPREFIX"
1505     public final void mSTRINGPREFIX() throws RecognitionException {
1506         match('L');
1507     }
1508
1509     // $ANTLR end "STRINGPREFIX"
1510
1511     // $ANTLR start "CHARACTER_LITERAL"
1512     public final void mCHARACTER_LITERAL() throws RecognitionException {
1513         int _type = CHARACTER_LITERAL;
1514         int _channel = DEFAULT_TOKEN_CHANNEL;
1515         // Grammar/CTFLexer.g:153:19: ( ( STRINGPREFIX )? SINGLEQUOTE (
1516         // CHAR_CONTENT )+ SINGLEQUOTE )
1517         // Grammar/CTFLexer.g:153:21: ( STRINGPREFIX )? SINGLEQUOTE (
1518         // CHAR_CONTENT )+ SINGLEQUOTE
1519         {
1520             // Grammar/CTFLexer.g:153:21: ( STRINGPREFIX )?
1521             int alt22 = 2;
1522             int LA22_0 = input.LA(1);
1523
1524             if ((LA22_0 == 'L')) {
1525                 alt22 = 1;
1526             }
1527             switch (alt22) {
1528             case 1:
1529             // Grammar/CTFLexer.g:153:21: STRINGPREFIX
1530             {
1531                 mSTRINGPREFIX();
1532
1533             }
1534                 break;
1535
1536             }
1537
1538             mSINGLEQUOTE();
1539             // Grammar/CTFLexer.g:153:47: ( CHAR_CONTENT )+
1540             int cnt23 = 0;
1541             loop23: do {
1542                 int alt23 = 2;
1543                 int LA23_0 = input.LA(1);
1544
1545                 if ((((LA23_0 >= '\u0000') && (LA23_0 <= '&')) || ((LA23_0 >= '(') && (LA23_0 <= '\uFFFF')))) {
1546                     alt23 = 1;
1547                 }
1548
1549                 switch (alt23) {
1550                 case 1:
1551                 // Grammar/CTFLexer.g:153:47: CHAR_CONTENT
1552                 {
1553                     mCHAR_CONTENT();
1554
1555                 }
1556                     break;
1557
1558                 default:
1559                     if (cnt23 >= 1) {
1560                         break loop23;
1561                     }
1562                     EarlyExitException eee = new EarlyExitException(23, input);
1563                     throw eee;
1564                 }
1565                 cnt23++;
1566             } while (true);
1567
1568             mSINGLEQUOTE();
1569
1570         }
1571
1572         setState(_type, _channel);
1573     }
1574
1575     // $ANTLR end "CHARACTER_LITERAL"
1576
1577     // $ANTLR start "CHAR_CONTENT"
1578     public final void mCHAR_CONTENT() throws RecognitionException {
1579         // Grammar/CTFLexer.g:154:23: ( ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
1580         // SINGLEQUOTE ) ) )
1581         // Grammar/CTFLexer.g:154:25: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
1582         // SINGLEQUOTE ) )
1583         {
1584             // Grammar/CTFLexer.g:154:25: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH
1585             // | SINGLEQUOTE ) )
1586             int alt24 = 2;
1587             int LA24_0 = input.LA(1);
1588
1589             if ((LA24_0 == '\\')) {
1590                 alt24 = 1;
1591             } else if ((((LA24_0 >= '\u0000') && (LA24_0 <= '&'))
1592                     || ((LA24_0 >= '(') && (LA24_0 <= '[')) || ((LA24_0 >= ']') && (LA24_0 <= '\uFFFF')))) {
1593                 alt24 = 2;
1594             } else {
1595                 NoViableAltException nvae = new NoViableAltException("", 24, 0,
1596                         input);
1597
1598                 throw nvae;
1599             }
1600             switch (alt24) {
1601             case 1:
1602             // Grammar/CTFLexer.g:154:26: ESCAPE_SEQUENCE
1603             {
1604                 mESCAPE_SEQUENCE();
1605
1606             }
1607                 break;
1608             case 2:
1609             // Grammar/CTFLexer.g:154:44: ~ ( BACKSLASH | SINGLEQUOTE )
1610             {
1611                 if (((input.LA(1) >= '\u0000') && (input.LA(1) <= '&'))
1612                         || ((input.LA(1) >= '(') && (input.LA(1) <= '['))
1613                         || ((input.LA(1) >= ']') && (input.LA(1) <= '\uFFFF'))) {
1614                     input.consume();
1615
1616                 } else {
1617                     MismatchedSetException mse = new MismatchedSetException(
1618                             null, input);
1619                     recover(mse);
1620                     throw mse;
1621                 }
1622
1623             }
1624                 break;
1625
1626             }
1627
1628         }
1629
1630     }
1631
1632     // $ANTLR end "CHAR_CONTENT"
1633
1634     // $ANTLR start "SINGLEQUOTE"
1635     public final void mSINGLEQUOTE() throws RecognitionException {
1636         match('\'');
1637     }
1638
1639     // $ANTLR end "SINGLEQUOTE"
1640
1641     // $ANTLR start "STRING_LITERAL"
1642     public final void mSTRING_LITERAL() throws RecognitionException {
1643         int _type = STRING_LITERAL;
1644         int _channel = DEFAULT_TOKEN_CHANNEL;
1645         // Grammar/CTFLexer.g:160:16: ( ( STRINGPREFIX )? DOUBLEQUOTE (
1646         // STRING_CONTENT )* DOUBLEQUOTE )
1647         // Grammar/CTFLexer.g:160:18: ( STRINGPREFIX )? DOUBLEQUOTE (
1648         // STRING_CONTENT )* DOUBLEQUOTE
1649         {
1650             // Grammar/CTFLexer.g:160:18: ( STRINGPREFIX )?
1651             int alt25 = 2;
1652             int LA25_0 = input.LA(1);
1653
1654             if ((LA25_0 == 'L')) {
1655                 alt25 = 1;
1656             }
1657             switch (alt25) {
1658             case 1:
1659             // Grammar/CTFLexer.g:160:18: STRINGPREFIX
1660             {
1661                 mSTRINGPREFIX();
1662
1663             }
1664                 break;
1665
1666             }
1667
1668             mDOUBLEQUOTE();
1669             // Grammar/CTFLexer.g:160:44: ( STRING_CONTENT )*
1670             loop26: do {
1671                 int alt26 = 2;
1672                 int LA26_0 = input.LA(1);
1673
1674                 if ((((LA26_0 >= '\u0000') && (LA26_0 <= '!')) || ((LA26_0 >= '#') && (LA26_0 <= '\uFFFF')))) {
1675                     alt26 = 1;
1676                 }
1677
1678                 switch (alt26) {
1679                 case 1:
1680                 // Grammar/CTFLexer.g:160:44: STRING_CONTENT
1681                 {
1682                     mSTRING_CONTENT();
1683
1684                 }
1685                     break;
1686
1687                 default:
1688                     break loop26;
1689                 }
1690             } while (true);
1691
1692             mDOUBLEQUOTE();
1693
1694         }
1695
1696         setState(_type, _channel);
1697     }
1698
1699     // $ANTLR end "STRING_LITERAL"
1700
1701     // $ANTLR start "STRING_CONTENT"
1702     public final void mSTRING_CONTENT() throws RecognitionException {
1703         // Grammar/CTFLexer.g:161:25: ( ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
1704         // DOUBLEQUOTE ) ) )
1705         // Grammar/CTFLexer.g:161:27: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
1706         // DOUBLEQUOTE ) )
1707         {
1708             // Grammar/CTFLexer.g:161:27: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH
1709             // | DOUBLEQUOTE ) )
1710             int alt27 = 2;
1711             int LA27_0 = input.LA(1);
1712
1713             if ((LA27_0 == '\\')) {
1714                 alt27 = 1;
1715             } else if ((((LA27_0 >= '\u0000') && (LA27_0 <= '!'))
1716                     || ((LA27_0 >= '#') && (LA27_0 <= '[')) || ((LA27_0 >= ']') && (LA27_0 <= '\uFFFF')))) {
1717                 alt27 = 2;
1718             } else {
1719                 NoViableAltException nvae = new NoViableAltException("", 27, 0,
1720                         input);
1721
1722                 throw nvae;
1723             }
1724             switch (alt27) {
1725             case 1:
1726             // Grammar/CTFLexer.g:161:28: ESCAPE_SEQUENCE
1727             {
1728                 mESCAPE_SEQUENCE();
1729
1730             }
1731                 break;
1732             case 2:
1733             // Grammar/CTFLexer.g:161:46: ~ ( BACKSLASH | DOUBLEQUOTE )
1734             {
1735                 if (((input.LA(1) >= '\u0000') && (input.LA(1) <= '!'))
1736                         || ((input.LA(1) >= '#') && (input.LA(1) <= '['))
1737                         || ((input.LA(1) >= ']') && (input.LA(1) <= '\uFFFF'))) {
1738                     input.consume();
1739
1740                 } else {
1741                     MismatchedSetException mse = new MismatchedSetException(
1742                             null, input);
1743                     recover(mse);
1744                     throw mse;
1745                 }
1746
1747             }
1748                 break;
1749
1750             }
1751
1752         }
1753
1754     }
1755
1756     // $ANTLR end "STRING_CONTENT"
1757
1758     // $ANTLR start "DOUBLEQUOTE"
1759     public final void mDOUBLEQUOTE() throws RecognitionException {
1760         match('\"');
1761     }
1762
1763     // $ANTLR end "DOUBLEQUOTE"
1764
1765     // $ANTLR start "WS"
1766     public final void mWS() throws RecognitionException {
1767         int _type = WS;
1768         int _channel = DEFAULT_TOKEN_CHANNEL;
1769         // Grammar/CTFLexer.g:167:4: ( ( ' ' | '\\r' | '\\t' | '\ ' | '\\n'
1770         // ) )
1771         // Grammar/CTFLexer.g:167:6: ( ' ' | '\\r' | '\\t' | '\ ' | '\\n' )
1772         {
1773             if (((input.LA(1) >= '\t') && (input.LA(1) <= '\n'))
1774                     || ((input.LA(1) >= '\f') && (input.LA(1) <= '\r'))
1775                     || (input.LA(1) == ' ')) {
1776                 input.consume();
1777
1778             } else {
1779                 MismatchedSetException mse = new MismatchedSetException(null,
1780                         input);
1781                 recover(mse);
1782                 throw mse;
1783             }
1784
1785             _channel = HIDDEN;
1786
1787         }
1788
1789         setState(_type, _channel);
1790     }
1791
1792     // $ANTLR end "WS"
1793
1794     // $ANTLR start "COMMENT"
1795     public final void mCOMMENT() throws RecognitionException {
1796         int _type = COMMENT;
1797         int _channel = DEFAULT_TOKEN_CHANNEL;
1798         // Grammar/CTFLexer.g:174:9: ( COMMENT_OPEN ( . )* COMMENT_CLOSE )
1799         // Grammar/CTFLexer.g:174:11: COMMENT_OPEN ( . )* COMMENT_CLOSE
1800         {
1801             mCOMMENT_OPEN();
1802             // Grammar/CTFLexer.g:174:24: ( . )*
1803             loop28: do {
1804                 int alt28 = 2;
1805                 int LA28_0 = input.LA(1);
1806
1807                 if ((LA28_0 == '*')) {
1808                     int LA28_1 = input.LA(2);
1809
1810                     if ((LA28_1 == '/')) {
1811                         alt28 = 2;
1812                     } else if ((((LA28_1 >= '\u0000') && (LA28_1 <= '.')) || ((LA28_1 >= '0') && (LA28_1 <= '\uFFFF')))) {
1813                         alt28 = 1;
1814                     }
1815
1816                 } else if ((((LA28_0 >= '\u0000') && (LA28_0 <= ')')) || ((LA28_0 >= '+') && (LA28_0 <= '\uFFFF')))) {
1817                     alt28 = 1;
1818                 }
1819
1820                 switch (alt28) {
1821                 case 1:
1822                 // Grammar/CTFLexer.g:174:24: .
1823                 {
1824                     matchAny();
1825
1826                 }
1827                     break;
1828
1829                 default:
1830                     break loop28;
1831                 }
1832             } while (true);
1833
1834             mCOMMENT_CLOSE();
1835             _channel = HIDDEN;
1836
1837         }
1838
1839         setState(_type, _channel);
1840     }
1841
1842     // $ANTLR end "COMMENT"
1843
1844     // $ANTLR start "COMMENT_OPEN"
1845     public final void mCOMMENT_OPEN() throws RecognitionException {
1846         match("/*");
1847     }
1848
1849     // $ANTLR end "COMMENT_OPEN"
1850
1851     // $ANTLR start "COMMENT_CLOSE"
1852     public final void mCOMMENT_CLOSE() throws RecognitionException {
1853         match("*/");
1854     }
1855
1856     // $ANTLR end "COMMENT_CLOSE"
1857
1858     // $ANTLR start "LINE_COMMENT"
1859     public final void mLINE_COMMENT() throws RecognitionException {
1860         int _type = LINE_COMMENT;
1861         int _channel = DEFAULT_TOKEN_CHANNEL;
1862         // Grammar/CTFLexer.g:181:14: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r'
1863         // )? '\\n' )
1864         // Grammar/CTFLexer.g:181:16: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r'
1865         // )? '\\n'
1866         {
1867             match("//");
1868
1869             // Grammar/CTFLexer.g:181:21: (~ ( '\\n' | '\\r' ) )*
1870             loop29: do {
1871                 int alt29 = 2;
1872                 int LA29_0 = input.LA(1);
1873
1874                 if ((((LA29_0 >= '\u0000') && (LA29_0 <= '\t'))
1875                         || ((LA29_0 >= '\u000B') && (LA29_0 <= '\f')) || ((LA29_0 >= '\u000E') && (LA29_0 <= '\uFFFF')))) {
1876                     alt29 = 1;
1877                 }
1878
1879                 switch (alt29) {
1880                 case 1:
1881                 // Grammar/CTFLexer.g:181:21: ~ ( '\\n' | '\\r' )
1882                 {
1883                     if (((input.LA(1) >= '\u0000') && (input.LA(1) <= '\t'))
1884                             || ((input.LA(1) >= '\u000B') && (input.LA(1) <= '\f'))
1885                             || ((input.LA(1) >= '\u000E') && (input.LA(1) <= '\uFFFF'))) {
1886                         input.consume();
1887
1888                     } else {
1889                         MismatchedSetException mse = new MismatchedSetException(
1890                                 null, input);
1891                         recover(mse);
1892                         throw mse;
1893                     }
1894
1895                 }
1896                     break;
1897
1898                 default:
1899                     break loop29;
1900                 }
1901             } while (true);
1902
1903             // Grammar/CTFLexer.g:181:35: ( '\\r' )?
1904             int alt30 = 2;
1905             int LA30_0 = input.LA(1);
1906
1907             if ((LA30_0 == '\r')) {
1908                 alt30 = 1;
1909             }
1910             switch (alt30) {
1911             case 1:
1912             // Grammar/CTFLexer.g:181:35: '\\r'
1913             {
1914                 match('\r');
1915
1916             }
1917                 break;
1918
1919             }
1920
1921             match('\n');
1922             _channel = HIDDEN;
1923
1924         }
1925
1926         setState(_type, _channel);
1927     }
1928
1929     // $ANTLR end "LINE_COMMENT"
1930
1931     // $ANTLR start "IDENTIFIER"
1932     public final void mIDENTIFIER() throws RecognitionException {
1933         int _type = IDENTIFIER;
1934         int _channel = DEFAULT_TOKEN_CHANNEL;
1935         // Grammar/CTFLexer.g:186:12: ( NONDIGIT ( NONDIGIT | DIGIT )* )
1936         // Grammar/CTFLexer.g:186:14: NONDIGIT ( NONDIGIT | DIGIT )*
1937         {
1938             mNONDIGIT();
1939             // Grammar/CTFLexer.g:186:23: ( NONDIGIT | DIGIT )*
1940             loop31: do {
1941                 int alt31 = 3;
1942                 int LA31_0 = input.LA(1);
1943
1944                 if ((((LA31_0 >= 'A') && (LA31_0 <= 'Z')) || (LA31_0 == '_') || ((LA31_0 >= 'a') && (LA31_0 <= 'z')))) {
1945                     alt31 = 1;
1946                 } else if ((((LA31_0 >= '0') && (LA31_0 <= '9')))) {
1947                     alt31 = 2;
1948                 }
1949
1950                 switch (alt31) {
1951                 case 1:
1952                 // Grammar/CTFLexer.g:186:24: NONDIGIT
1953                 {
1954                     mNONDIGIT();
1955
1956                 }
1957                     break;
1958                 case 2:
1959                 // Grammar/CTFLexer.g:186:35: DIGIT
1960                 {
1961                     mDIGIT();
1962
1963                 }
1964                     break;
1965
1966                 default:
1967                     break loop31;
1968                 }
1969             } while (true);
1970
1971         }
1972
1973         setState(_type, _channel);
1974     }
1975
1976     // $ANTLR end "IDENTIFIER"
1977
1978     // $ANTLR start "NONDIGIT"
1979     public final void mNONDIGIT() throws RecognitionException {
1980         // Grammar/CTFLexer.g:187:19: ( ( '_' ) | ( 'A' .. 'Z' ) | ( 'a' ..
1981         // 'z' ) )
1982         int alt32 = 3;
1983         switch (input.LA(1)) {
1984         case '_': {
1985             alt32 = 1;
1986         }
1987             break;
1988         case 'A':
1989         case 'B':
1990         case 'C':
1991         case 'D':
1992         case 'E':
1993         case 'F':
1994         case 'G':
1995         case 'H':
1996         case 'I':
1997         case 'J':
1998         case 'K':
1999         case 'L':
2000         case 'M':
2001         case 'N':
2002         case 'O':
2003         case 'P':
2004         case 'Q':
2005         case 'R':
2006         case 'S':
2007         case 'T':
2008         case 'U':
2009         case 'V':
2010         case 'W':
2011         case 'X':
2012         case 'Y':
2013         case 'Z': {
2014             alt32 = 2;
2015         }
2016             break;
2017         case 'a':
2018         case 'b':
2019         case 'c':
2020         case 'd':
2021         case 'e':
2022         case 'f':
2023         case 'g':
2024         case 'h':
2025         case 'i':
2026         case 'j':
2027         case 'k':
2028         case 'l':
2029         case 'm':
2030         case 'n':
2031         case 'o':
2032         case 'p':
2033         case 'q':
2034         case 'r':
2035         case 's':
2036         case 't':
2037         case 'u':
2038         case 'v':
2039         case 'w':
2040         case 'x':
2041         case 'y':
2042         case 'z': {
2043             alt32 = 3;
2044         }
2045             break;
2046         default:
2047             NoViableAltException nvae = new NoViableAltException("", 32, 0,
2048                     input);
2049
2050             throw nvae;
2051         }
2052
2053         switch (alt32) {
2054         case 1:
2055         // Grammar/CTFLexer.g:187:21: ( '_' )
2056         {
2057             // Grammar/CTFLexer.g:187:21: ( '_' )
2058             // Grammar/CTFLexer.g:187:22: '_'
2059             {
2060                 match('_');
2061
2062             }
2063
2064         }
2065             break;
2066         case 2:
2067         // Grammar/CTFLexer.g:187:29: ( 'A' .. 'Z' )
2068         {
2069             // Grammar/CTFLexer.g:187:29: ( 'A' .. 'Z' )
2070             // Grammar/CTFLexer.g:187:30: 'A' .. 'Z'
2071             {
2072                 matchRange('A', 'Z');
2073
2074             }
2075
2076         }
2077             break;
2078         case 3:
2079         // Grammar/CTFLexer.g:187:42: ( 'a' .. 'z' )
2080         {
2081             // Grammar/CTFLexer.g:187:42: ( 'a' .. 'z' )
2082             // Grammar/CTFLexer.g:187:43: 'a' .. 'z'
2083             {
2084                 matchRange('a', 'z');
2085
2086             }
2087
2088         }
2089             break;
2090
2091         }
2092     }
2093
2094     // $ANTLR end "NONDIGIT"
2095
2096     @Override
2097     public void mTokens() throws RecognitionException {
2098         // Grammar/CTFLexer.g:1:8: ( ALIGNTOK | CONSTTOK | CHARTOK | DOUBLETOK |
2099         // ENUMTOK | EVENTTOK | FLOATINGPOINTTOK | FLOATTOK | INTEGERTOK |
2100         // INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | STREAMTOK | STRINGTOK |
2101         // STRUCTTOK | TRACETOK | TYPEALIASTOK | TYPEDEFTOK | UNSIGNEDTOK |
2102         // VARIANTTOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | ENVTOK |
2103         // CLOCKTOK | NANNUMBERTOK | INFINITYTOK | NINFINITYTOK | SEPARATOR |
2104         // COLON | ELIPSES | ASSIGNMENT | TYPE_ASSIGNMENT | LT | GT | OPENBRAC |
2105         // CLOSEBRAC | LPAREN | RPAREN | LCURL | RCURL | TERM | POINTER | SIGN |
2106         // ARROW | DOT | OCTAL_LITERAL | DECIMAL_LITERAL | HEX_LITERAL |
2107         // CHARACTER_LITERAL | STRING_LITERAL | WS | COMMENT | LINE_COMMENT |
2108         // IDENTIFIER )
2109         int alt33 = 57;
2110         alt33 = dfa33.predict(input);
2111         switch (alt33) {
2112         case 1:
2113         // Grammar/CTFLexer.g:1:10: ALIGNTOK
2114         {
2115             mALIGNTOK();
2116
2117         }
2118             break;
2119         case 2:
2120         // Grammar/CTFLexer.g:1:19: CONSTTOK
2121         {
2122             mCONSTTOK();
2123
2124         }
2125             break;
2126         case 3:
2127         // Grammar/CTFLexer.g:1:28: CHARTOK
2128         {
2129             mCHARTOK();
2130
2131         }
2132             break;
2133         case 4:
2134         // Grammar/CTFLexer.g:1:36: DOUBLETOK
2135         {
2136             mDOUBLETOK();
2137
2138         }
2139             break;
2140         case 5:
2141         // Grammar/CTFLexer.g:1:46: ENUMTOK
2142         {
2143             mENUMTOK();
2144
2145         }
2146             break;
2147         case 6:
2148         // Grammar/CTFLexer.g:1:54: EVENTTOK
2149         {
2150             mEVENTTOK();
2151
2152         }
2153             break;
2154         case 7:
2155         // Grammar/CTFLexer.g:1:63: FLOATINGPOINTTOK
2156         {
2157             mFLOATINGPOINTTOK();
2158
2159         }
2160             break;
2161         case 8:
2162         // Grammar/CTFLexer.g:1:80: FLOATTOK
2163         {
2164             mFLOATTOK();
2165
2166         }
2167             break;
2168         case 9:
2169         // Grammar/CTFLexer.g:1:89: INTEGERTOK
2170         {
2171             mINTEGERTOK();
2172
2173         }
2174             break;
2175         case 10:
2176         // Grammar/CTFLexer.g:1:100: INTTOK
2177         {
2178             mINTTOK();
2179
2180         }
2181             break;
2182         case 11:
2183         // Grammar/CTFLexer.g:1:107: LONGTOK
2184         {
2185             mLONGTOK();
2186
2187         }
2188             break;
2189         case 12:
2190         // Grammar/CTFLexer.g:1:115: SHORTTOK
2191         {
2192             mSHORTTOK();
2193
2194         }
2195             break;
2196         case 13:
2197         // Grammar/CTFLexer.g:1:124: SIGNEDTOK
2198         {
2199             mSIGNEDTOK();
2200
2201         }
2202             break;
2203         case 14:
2204         // Grammar/CTFLexer.g:1:134: STREAMTOK
2205         {
2206             mSTREAMTOK();
2207
2208         }
2209             break;
2210         case 15:
2211         // Grammar/CTFLexer.g:1:144: STRINGTOK
2212         {
2213             mSTRINGTOK();
2214
2215         }
2216             break;
2217         case 16:
2218         // Grammar/CTFLexer.g:1:154: STRUCTTOK
2219         {
2220             mSTRUCTTOK();
2221
2222         }
2223             break;
2224         case 17:
2225         // Grammar/CTFLexer.g:1:164: TRACETOK
2226         {
2227             mTRACETOK();
2228
2229         }
2230             break;
2231         case 18:
2232         // Grammar/CTFLexer.g:1:173: TYPEALIASTOK
2233         {
2234             mTYPEALIASTOK();
2235
2236         }
2237             break;
2238         case 19:
2239         // Grammar/CTFLexer.g:1:186: TYPEDEFTOK
2240         {
2241             mTYPEDEFTOK();
2242
2243         }
2244             break;
2245         case 20:
2246         // Grammar/CTFLexer.g:1:197: UNSIGNEDTOK
2247         {
2248             mUNSIGNEDTOK();
2249
2250         }
2251             break;
2252         case 21:
2253         // Grammar/CTFLexer.g:1:209: VARIANTTOK
2254         {
2255             mVARIANTTOK();
2256
2257         }
2258             break;
2259         case 22:
2260         // Grammar/CTFLexer.g:1:220: VOIDTOK
2261         {
2262             mVOIDTOK();
2263
2264         }
2265             break;
2266         case 23:
2267         // Grammar/CTFLexer.g:1:228: BOOLTOK
2268         {
2269             mBOOLTOK();
2270
2271         }
2272             break;
2273         case 24:
2274         // Grammar/CTFLexer.g:1:236: COMPLEXTOK
2275         {
2276             mCOMPLEXTOK();
2277
2278         }
2279             break;
2280         case 25:
2281         // Grammar/CTFLexer.g:1:247: IMAGINARYTOK
2282         {
2283             mIMAGINARYTOK();
2284
2285         }
2286             break;
2287         case 26:
2288         // Grammar/CTFLexer.g:1:260: ENVTOK
2289         {
2290             mENVTOK();
2291
2292         }
2293             break;
2294         case 27:
2295         // Grammar/CTFLexer.g:1:267: CLOCKTOK
2296         {
2297             mCLOCKTOK();
2298
2299         }
2300             break;
2301         case 28:
2302         // Grammar/CTFLexer.g:1:276: NANNUMBERTOK
2303         {
2304             mNANNUMBERTOK();
2305
2306         }
2307             break;
2308         case 29:
2309         // Grammar/CTFLexer.g:1:289: INFINITYTOK
2310         {
2311             mINFINITYTOK();
2312
2313         }
2314             break;
2315         case 30:
2316         // Grammar/CTFLexer.g:1:301: NINFINITYTOK
2317         {
2318             mNINFINITYTOK();
2319
2320         }
2321             break;
2322         case 31:
2323         // Grammar/CTFLexer.g:1:314: SEPARATOR
2324         {
2325             mSEPARATOR();
2326
2327         }
2328             break;
2329         case 32:
2330         // Grammar/CTFLexer.g:1:324: COLON
2331         {
2332             mCOLON();
2333
2334         }
2335             break;
2336         case 33:
2337         // Grammar/CTFLexer.g:1:330: ELIPSES
2338         {
2339             mELIPSES();
2340
2341         }
2342             break;
2343         case 34:
2344         // Grammar/CTFLexer.g:1:338: ASSIGNMENT
2345         {
2346             mASSIGNMENT();
2347
2348         }
2349             break;
2350         case 35:
2351         // Grammar/CTFLexer.g:1:349: TYPE_ASSIGNMENT
2352         {
2353             mTYPE_ASSIGNMENT();
2354
2355         }
2356             break;
2357         case 36:
2358         // Grammar/CTFLexer.g:1:365: LT
2359         {
2360             mLT();
2361
2362         }
2363             break;
2364         case 37:
2365         // Grammar/CTFLexer.g:1:368: GT
2366         {
2367             mGT();
2368
2369         }
2370             break;
2371         case 38:
2372         // Grammar/CTFLexer.g:1:371: OPENBRAC
2373         {
2374             mOPENBRAC();
2375
2376         }
2377             break;
2378         case 39:
2379         // Grammar/CTFLexer.g:1:380: CLOSEBRAC
2380         {
2381             mCLOSEBRAC();
2382
2383         }
2384             break;
2385         case 40:
2386         // Grammar/CTFLexer.g:1:390: LPAREN
2387         {
2388             mLPAREN();
2389
2390         }
2391             break;
2392         case 41:
2393         // Grammar/CTFLexer.g:1:397: RPAREN
2394         {
2395             mRPAREN();
2396
2397         }
2398             break;
2399         case 42:
2400         // Grammar/CTFLexer.g:1:404: LCURL
2401         {
2402             mLCURL();
2403
2404         }
2405             break;
2406         case 43:
2407         // Grammar/CTFLexer.g:1:410: RCURL
2408         {
2409             mRCURL();
2410
2411         }
2412             break;
2413         case 44:
2414         // Grammar/CTFLexer.g:1:416: TERM
2415         {
2416             mTERM();
2417
2418         }
2419             break;
2420         case 45:
2421         // Grammar/CTFLexer.g:1:421: POINTER
2422         {
2423             mPOINTER();
2424
2425         }
2426             break;
2427         case 46:
2428         // Grammar/CTFLexer.g:1:429: SIGN
2429         {
2430             mSIGN();
2431
2432         }
2433             break;
2434         case 47:
2435         // Grammar/CTFLexer.g:1:434: ARROW
2436         {
2437             mARROW();
2438
2439         }
2440             break;
2441         case 48:
2442         // Grammar/CTFLexer.g:1:440: DOT
2443         {
2444             mDOT();
2445
2446         }
2447             break;
2448         case 49:
2449         // Grammar/CTFLexer.g:1:444: OCTAL_LITERAL
2450         {
2451             mOCTAL_LITERAL();
2452
2453         }
2454             break;
2455         case 50:
2456         // Grammar/CTFLexer.g:1:458: DECIMAL_LITERAL
2457         {
2458             mDECIMAL_LITERAL();
2459
2460         }
2461             break;
2462         case 51:
2463         // Grammar/CTFLexer.g:1:474: HEX_LITERAL
2464         {
2465             mHEX_LITERAL();
2466
2467         }
2468             break;
2469         case 52:
2470         // Grammar/CTFLexer.g:1:486: CHARACTER_LITERAL
2471         {
2472             mCHARACTER_LITERAL();
2473
2474         }
2475             break;
2476         case 53:
2477         // Grammar/CTFLexer.g:1:504: STRING_LITERAL
2478         {
2479             mSTRING_LITERAL();
2480
2481         }
2482             break;
2483         case 54:
2484         // Grammar/CTFLexer.g:1:519: WS
2485         {
2486             mWS();
2487
2488         }
2489             break;
2490         case 55:
2491         // Grammar/CTFLexer.g:1:522: COMMENT
2492         {
2493             mCOMMENT();
2494
2495         }
2496             break;
2497         case 56:
2498         // Grammar/CTFLexer.g:1:530: LINE_COMMENT
2499         {
2500             mLINE_COMMENT();
2501
2502         }
2503             break;
2504         case 57:
2505         // Grammar/CTFLexer.g:1:543: IDENTIFIER
2506         {
2507             mIDENTIFIER();
2508
2509         }
2510             break;
2511
2512         }
2513
2514     }
2515
2516     protected DFA17 dfa17 = new DFA17(this);
2517     protected DFA33 dfa33 = new DFA33(this);
2518     static final String DFA17_eotS = "\1\uffff\2\5\1\11\1\5\2\uffff\1\5\2\uffff";
2519     static final String DFA17_eofS = "\12\uffff";
2520     static final String DFA17_minS = "\1\114\1\125\2\114\1\125\2\uffff\1\125\2\uffff";
2521     static final String DFA17_maxS = "\3\165\1\154\1\165\2\uffff\1\165\2\uffff";
2522     static final String DFA17_acceptS = "\5\uffff\1\1\1\4\1\uffff\1\3\1\2";
2523     static final String DFA17_specialS = "\12\uffff}>";
2524     static final String[] DFA17_transitionS = {
2525             "\1\2\10\uffff\1\3\26\uffff\1\1\10\uffff\1\3",
2526             "\1\6\26\uffff\1\4\10\uffff\1\6", "\1\7\10\uffff\1\6\37\uffff\1\6",
2527             "\1\10\37\uffff\1\10", "\1\6\37\uffff\1\6", "", "",
2528             "\1\6\37\uffff\1\6", "", "" };
2529
2530     static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
2531     static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
2532     static final char[] DFA17_min = DFA
2533             .unpackEncodedStringToUnsignedChars(DFA17_minS);
2534     static final char[] DFA17_max = DFA
2535             .unpackEncodedStringToUnsignedChars(DFA17_maxS);
2536     static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
2537     static final short[] DFA17_special = DFA
2538             .unpackEncodedString(DFA17_specialS);
2539     static final short[][] DFA17_transition;
2540
2541     static {
2542         int numStates = DFA17_transitionS.length;
2543         DFA17_transition = new short[numStates][];
2544         for (int i = 0; i < numStates; i++) {
2545             DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
2546         }
2547     }
2548
2549     static class DFA17 extends DFA {
2550
2551         public DFA17(BaseRecognizer recognizer) {
2552             this.recognizer = recognizer;
2553             this.decisionNumber = 17;
2554             this.eot = DFA17_eot;
2555             this.eof = DFA17_eof;
2556             this.min = DFA17_min;
2557             this.max = DFA17_max;
2558             this.accept = DFA17_accept;
2559             this.special = DFA17_special;
2560             this.transition = DFA17_transition;
2561         }
2562
2563         @Override
2564         public String getDescription() {
2565             return "102:10: fragment INTEGER_TYPES_SUFFIX : ( ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'u' | 'U' ) | ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' ) );";
2566         }
2567     }
2568
2569     static final String DFA33_eotS = "\1\uffff\15\45\2\75\1\uffff\1\101\1\103\13\uffff\1\37\1\uffff\1"
2570             + "\45\5\uffff\26\45\11\uffff\1\137\2\uffff\6\45\1\151\2\45\1\155\14"
2571             + "\45\1\174\1\uffff\3\137\2\45\1\u0084\2\45\1\u0087\1\uffff\3\45\1"
2572             + "\uffff\1\u008b\11\45\1\u0096\3\45\1\uffff\1\137\1\uffff\3\137\1"
2573             + "\u009c\1\u009d\1\uffff\1\u009e\1\45\1\uffff\1\u00a0\1\u00a2\1\45"
2574             + "\1\uffff\1\u00a4\4\45\1\u00a9\4\45\1\uffff\1\u00ae\2\45\5\uffff"
2575             + "\1\u00b1\1\uffff\1\45\1\uffff\1\45\1\uffff\1\u00b4\1\u00b5\1\u00b6"
2576             + "\1\u00b7\1\uffff\4\45\1\uffff\2\45\1\uffff\1\45\1\u00bf\4\uffff"
2577             + "\1\45\1\u00c1\1\45\1\u00c3\3\45\1\uffff\1\45\1\uffff\1\u00c8\1\uffff"
2578             + "\1\u00c9\2\45\1\u00cc\2\uffff\2\45\1\uffff\1\u00cf\1\45\1\uffff"
2579             + "\2\45\1\u00d3\1\uffff";
2580     static final String DFA33_eofS = "\u00d4\uffff";
2581     static final String DFA33_minS = "\1\11\1\154\1\150\1\157\1\156\1\154\1\156\1\157\1\150\1\162\1\156"
2582             + "\1\141\1\102\1\141\1\151\1\76\1\uffff\1\75\1\56\13\uffff\1\60\1"
2583             + "\uffff\1\42\3\uffff\1\52\1\uffff\1\151\1\156\1\141\1\157\2\165\1"
2584             + "\145\1\157\1\164\1\156\1\157\1\147\1\162\1\141\1\160\1\163\1\162"
2585             + "\1\151\2\157\1\155\1\116\11\uffff\1\60\2\uffff\1\147\1\163\1\162"
2586             + "\1\143\1\142\1\155\1\60\1\156\1\141\1\60\1\147\1\162\1\156\1\145"
2587             + "\1\143\1\145\2\151\1\144\1\157\1\155\1\141\1\60\1\uffff\1\125\2"
2588             + "\114\1\156\1\164\1\60\1\153\1\154\1\60\1\uffff\2\164\1\147\1\uffff"
2589             + "\1\60\1\164\1\145\1\141\1\156\1\143\1\145\1\141\1\147\1\141\1\60"
2590             + "\1\154\1\160\1\147\1\uffff\1\125\1\uffff\1\125\1\154\1\114\2\60"
2591             + "\1\uffff\1\60\1\145\1\uffff\2\60\1\145\1\uffff\1\60\1\144\1\155"
2592             + "\1\147\1\164\1\60\1\154\1\145\2\156\1\uffff\1\60\1\154\1\151\5\uffff"
2593             + "\1\60\1\uffff\1\156\1\uffff\1\162\1\uffff\4\60\1\uffff\1\151\1\146"
2594             + "\1\145\1\164\1\uffff\1\145\1\156\1\uffff\1\147\1\60\4\uffff\1\141"
2595             + "\1\60\1\144\1\60\1\170\1\141\1\137\1\uffff\1\163\1\uffff\1\60\1"
2596             + "\uffff\1\60\1\162\1\160\1\60\2\uffff\1\171\1\157\1\uffff\1\60\1"
2597             + "\151\1\uffff\1\156\1\164\1\60\1\uffff";
2598     static final String DFA33_maxS = "\1\175\1\154\2\157\1\166\1\154\1\156\1\157\1\164\1\171\1\156\1\157"
2599             + "\1\111\1\141\2\151\1\uffff\1\75\1\56\13\uffff\1\170\1\uffff\1\47"
2600             + "\3\uffff\1\57\1\uffff\1\151\1\156\1\141\1\157\1\165\1\166\1\145"
2601             + "\1\157\1\164\1\156\1\157\1\147\1\162\1\141\1\160\1\163\1\162\1\151"
2602             + "\2\157\1\155\1\116\11\uffff\1\165\2\uffff\1\147\1\163\1\162\1\143"
2603             + "\1\142\1\155\1\172\1\156\1\141\1\172\1\147\1\162\1\156\1\165\1\143"
2604             + "\1\145\2\151\1\144\1\157\1\155\1\141\1\172\1\uffff\2\165\1\154\1"
2605             + "\156\1\164\1\172\1\153\1\154\1\172\1\uffff\2\164\1\147\1\uffff\1"
2606             + "\172\1\164\1\145\1\141\1\156\1\143\1\145\1\144\1\147\1\141\1\172"
2607             + "\1\154\1\160\1\147\1\uffff\1\165\1\uffff\1\165\1\154\1\114\2\172"
2608             + "\1\uffff\1\172\1\145\1\uffff\2\172\1\145\1\uffff\1\172\1\144\1\155"
2609             + "\1\147\1\164\1\172\1\154\1\145\2\156\1\uffff\1\172\1\154\1\151\5"
2610             + "\uffff\1\172\1\uffff\1\156\1\uffff\1\162\1\uffff\4\172\1\uffff\1"
2611             + "\151\1\146\1\145\1\164\1\uffff\1\145\1\156\1\uffff\1\147\1\172\4"
2612             + "\uffff\1\141\1\172\1\144\1\172\1\170\1\141\1\137\1\uffff\1\163\1"
2613             + "\uffff\1\172\1\uffff\1\172\1\162\1\160\1\172\2\uffff\1\171\1\157"
2614             + "\1\uffff\1\172\1\151\1\uffff\1\156\1\164\1\172\1\uffff";
2615     static final String DFA33_acceptS = "\20\uffff\1\37\2\uffff\1\42\1\44\1\45\1\46\1\47\1\50\1\51\1\52\1"
2616             + "\53\1\54\1\55\1\uffff\1\62\1\uffff\1\64\1\65\1\66\1\uffff\1\71\26"
2617             + "\uffff\1\35\1\56\1\36\1\57\1\43\1\40\1\41\1\60\1\63\1\uffff\1\67"
2618             + "\1\70\27\uffff\1\61\11\uffff\1\32\3\uffff\1\12\16\uffff\1\34\1\uffff"
2619             + "\1\61\5\uffff\1\3\2\uffff\1\5\3\uffff\1\13\12\uffff\1\26\3\uffff"
2620             + "\2\61\1\1\1\2\1\33\1\uffff\1\6\1\uffff\1\10\1\uffff\1\14\4\uffff"
2621             + "\1\21\4\uffff\1\27\2\uffff\1\4\2\uffff\1\15\1\16\1\17\1\20\7\uffff"
2622             + "\1\11\1\uffff\1\23\1\uffff\1\25\4\uffff\1\24\1\30\2\uffff\1\22\2"
2623             + "\uffff\1\31\3\uffff\1\7";
2624     static final String DFA33_specialS = "\u00d4\uffff}>";
2625     static final String[] DFA33_transitionS = {
2626             "\2\43\1\uffff\2\43\22\uffff\1\43\1\uffff\1\42\4\uffff\1\41\1"
2627                     + "\30\1\31\1\35\1\16\1\20\1\17\1\22\1\44\1\36\11\37\1\21\1\34"
2628                     + "\1\24\1\23\1\25\2\uffff\13\45\1\40\1\45\1\15\14\45\1\26\1\uffff"
2629                     + "\1\27\1\uffff\1\14\1\uffff\1\1\1\45\1\2\1\3\1\4\1\5\2\45\1\6"
2630                     + "\2\45\1\7\6\45\1\10\1\11\1\12\1\13\4\45\1\32\1\uffff\1\33",
2631             "\1\46",
2632             "\1\50\3\uffff\1\51\2\uffff\1\47",
2633             "\1\52",
2634             "\1\53\7\uffff\1\54",
2635             "\1\55",
2636             "\1\56",
2637             "\1\57",
2638             "\1\60\1\61\12\uffff\1\62",
2639             "\1\63\6\uffff\1\64",
2640             "\1\65",
2641             "\1\66\15\uffff\1\67",
2642             "\1\70\1\71\5\uffff\1\72",
2643             "\1\73",
2644             "\1\74",
2645             "\1\77\52\uffff\1\76",
2646             "",
2647             "\1\100",
2648             "\1\102",
2649             "",
2650             "",
2651             "",
2652             "",
2653             "",
2654             "",
2655             "",
2656             "",
2657             "",
2658             "",
2659             "",
2660             "\10\105\40\uffff\1\104\37\uffff\1\104",
2661             "",
2662             "\1\42\4\uffff\1\41",
2663             "",
2664             "",
2665             "",
2666             "\1\106\4\uffff\1\107",
2667             "",
2668             "\1\110",
2669             "\1\111",
2670             "\1\112",
2671             "\1\113",
2672             "\1\114",
2673             "\1\115\1\116",
2674             "\1\117",
2675             "\1\120",
2676             "\1\121",
2677             "\1\122",
2678             "\1\123",
2679             "\1\124",
2680             "\1\125",
2681             "\1\126",
2682             "\1\127",
2683             "\1\130",
2684             "\1\131",
2685             "\1\132",
2686             "\1\133",
2687             "\1\134",
2688             "\1\135",
2689             "\1\136",
2690             "",
2691             "",
2692             "",
2693             "",
2694             "",
2695             "",
2696             "",
2697             "",
2698             "",
2699             "\10\105\2\37\22\uffff\1\141\10\uffff\1\142\26\uffff\1\140\10"
2700                     + "\uffff\1\142",
2701             "",
2702             "",
2703             "\1\143",
2704             "\1\144",
2705             "\1\145",
2706             "\1\146",
2707             "\1\147",
2708             "\1\150",
2709             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2710             "\1\152",
2711             "\1\153",
2712             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\4\45\1\154\25\45",
2713             "\1\156",
2714             "\1\157",
2715             "\1\160",
2716             "\1\161\3\uffff\1\162\13\uffff\1\163",
2717             "\1\164",
2718             "\1\165",
2719             "\1\166",
2720             "\1\167",
2721             "\1\170",
2722             "\1\171",
2723             "\1\172",
2724             "\1\173",
2725             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2726             "",
2727             "\1\176\26\uffff\1\175\10\uffff\1\176",
2728             "\1\177\10\uffff\1\176\37\uffff\1\176",
2729             "\1\u0081\37\uffff\1\u0080",
2730             "\1\u0082",
2731             "\1\u0083",
2732             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2733             "\1\u0085",
2734             "\1\u0086",
2735             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2736             "",
2737             "\1\u0088",
2738             "\1\u0089",
2739             "\1\u008a",
2740             "",
2741             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2742             "\1\u008c",
2743             "\1\u008d",
2744             "\1\u008e",
2745             "\1\u008f",
2746             "\1\u0090",
2747             "\1\u0091",
2748             "\1\u0092\2\uffff\1\u0093",
2749             "\1\u0094",
2750             "\1\u0095",
2751             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2752             "\1\u0097",
2753             "\1\u0098",
2754             "\1\u0099",
2755             "",
2756             "\1\176\37\uffff\1\176",
2757             "",
2758             "\1\176\37\uffff\1\176",
2759             "\1\u009a",
2760             "\1\u009b",
2761             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2762             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2763             "",
2764             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2765             "\1\u009f",
2766             "",
2767             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2768             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\10\45\1\u00a1\21"
2769                     + "\45", "\1\u00a3", "",
2770             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00a5",
2771             "\1\u00a6", "\1\u00a7", "\1\u00a8",
2772             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00aa",
2773             "\1\u00ab", "\1\u00ac", "\1\u00ad", "",
2774             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00af",
2775             "\1\u00b0", "", "", "", "", "",
2776             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "\1\u00b2",
2777             "", "\1\u00b3", "",
2778             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2779             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2780             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
2781             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "\1\u00b8",
2782             "\1\u00b9", "\1\u00ba", "\1\u00bb", "", "\1\u00bc", "\1\u00bd", "",
2783             "\1\u00be", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "",
2784             "", "", "", "\1\u00c0",
2785             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00c2",
2786             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00c4",
2787             "\1\u00c5", "\1\u00c6", "", "\1\u00c7", "",
2788             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "",
2789             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00ca",
2790             "\1\u00cb", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "",
2791             "", "\1\u00cd", "\1\u00ce", "",
2792             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00d0", "",
2793             "\1\u00d1", "\1\u00d2",
2794             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "" };
2795
2796     static final short[] DFA33_eot = DFA.unpackEncodedString(DFA33_eotS);
2797     static final short[] DFA33_eof = DFA.unpackEncodedString(DFA33_eofS);
2798     static final char[] DFA33_min = DFA
2799             .unpackEncodedStringToUnsignedChars(DFA33_minS);
2800     static final char[] DFA33_max = DFA
2801             .unpackEncodedStringToUnsignedChars(DFA33_maxS);
2802     static final short[] DFA33_accept = DFA.unpackEncodedString(DFA33_acceptS);
2803     static final short[] DFA33_special = DFA
2804             .unpackEncodedString(DFA33_specialS);
2805     static final short[][] DFA33_transition;
2806
2807     static {
2808         int numStates = DFA33_transitionS.length;
2809         DFA33_transition = new short[numStates][];
2810         for (int i = 0; i < numStates; i++) {
2811             DFA33_transition[i] = DFA.unpackEncodedString(DFA33_transitionS[i]);
2812         }
2813     }
2814
2815     static class DFA33 extends DFA {
2816
2817         public DFA33(BaseRecognizer recognizer) {
2818             this.recognizer = recognizer;
2819             this.decisionNumber = 33;
2820             this.eot = DFA33_eot;
2821             this.eof = DFA33_eof;
2822             this.min = DFA33_min;
2823             this.max = DFA33_max;
2824             this.accept = DFA33_accept;
2825             this.special = DFA33_special;
2826             this.transition = DFA33_transition;
2827         }
2828
2829         @Override
2830         public String getDescription() {
2831             return "1:1: Tokens : ( ALIGNTOK | CONSTTOK | CHARTOK | DOUBLETOK | ENUMTOK | EVENTTOK | FLOATINGPOINTTOK | FLOATTOK | INTEGERTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | STREAMTOK | STRINGTOK | STRUCTTOK | TRACETOK | TYPEALIASTOK | TYPEDEFTOK | UNSIGNEDTOK | VARIANTTOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | ENVTOK | CLOCKTOK | NANNUMBERTOK | INFINITYTOK | NINFINITYTOK | SEPARATOR | COLON | ELIPSES | ASSIGNMENT | TYPE_ASSIGNMENT | LT | GT | OPENBRAC | CLOSEBRAC | LPAREN | RPAREN | LCURL | RCURL | TERM | POINTER | SIGN | ARROW | DOT | OCTAL_LITERAL | DECIMAL_LITERAL | HEX_LITERAL | CHARACTER_LITERAL | STRING_LITERAL | WS | COMMENT | LINE_COMMENT | IDENTIFIER );";
2832         }
2833     }
2834
2835 }