src/edu/uci/eecs/utilParser/UtilParserTokenManager.java

   1 /* UtilParserTokenManager.java */
   2 /* Generated By:JavaCC: Do not edit this line. UtilParserTokenManager.java */
   3 package edu.uci.eecs.utilParser;
   4 import edu.uci.eecs.specExtraction.FunctionHeader;
   5 import edu.uci.eecs.specExtraction.QualifiedName;
   6 import edu.uci.eecs.specExtraction.VariableDeclaration;
   7 //import edu.uci.eecs.specExtraction.WrongAnnotationException;
   8
   9 import java.io.FileInputStream;
  10 import java.io.FileNotFoundException;
  11 import java.io.InputStream;
  12 import java.io.ByteArrayInputStream;
  13 import java.io.File;
  14 import java.util.ArrayList;
  15
  16 /** Token Manager. */
  17 @SuppressWarnings("unused")public class UtilParserTokenManager implements UtilParserConstants {
  18
  19   /** Debug output. */
  20   public  java.io.PrintStream debugStream = System.out;
  21   /** Set debug output. */
  22   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  23 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1){
  24    switch (pos)
  25    {
  26       case 0:
  27          if ((active0 & 0x8000000L) != 0L)
  28             return 24;
  29          if ((active0 & 0x20000L) != 0L)
  30             return 85;
  31          if ((active0 & 0x3fc0L) != 0L)
  32          {
  33             jjmatchedKind = 16;
  34             return 1;
  35          }
  36          return -1;
  37       case 1:
  38          if ((active0 & 0x3fc0L) != 0L)
  39          {
  40             if (jjmatchedPos != 1)
  41             {
  42                jjmatchedKind = 16;
  43                jjmatchedPos = 1;
  44             }
  45             return 1;
  46          }
  47          return -1;
  48       case 2:
  49          if ((active0 & 0x1fc0L) != 0L)
  50          {
  51             jjmatchedKind = 16;
  52             jjmatchedPos = 2;
  53             return 1;
  54          }
  55          if ((active0 & 0x2000L) != 0L)
  56             return 1;
  57          return -1;
  58       case 3:
  59          if ((active0 & 0x1fc0L) != 0L)
  60          {
  61             jjmatchedKind = 16;
  62             jjmatchedPos = 3;
  63             return 1;
  64          }
  65          return -1;
  66       case 4:
  67          if ((active0 & 0x1e80L) != 0L)
  68          {
  69             jjmatchedKind = 16;
  70             jjmatchedPos = 4;
  71             return 1;
  72          }
  73          if ((active0 & 0x140L) != 0L)
  74             return 1;
  75          return -1;
  76       case 5:
  77          if ((active0 & 0x600L) != 0L)
  78          {
  79             jjmatchedKind = 16;
  80             jjmatchedPos = 5;
  81             return 1;
  82          }
  83          if ((active0 & 0x1880L) != 0L)
  84             return 1;
  85          return -1;
  86       case 6:
  87          if ((active0 & 0x600L) != 0L)
  88          {
  89             jjmatchedKind = 16;
  90             jjmatchedPos = 6;
  91             return 1;
  92          }
  93          return -1;
  94       default :
  95          return -1;
  96    }
  97 }
  98 private final int jjStartNfa_0(int pos, long active0, long active1){
  99    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
 100 }
 101 private int jjStopAtPos(int pos, int kind)
 102 {
 103    jjmatchedKind = kind;
 104    jjmatchedPos = pos;
 105    return pos + 1;
 106 }
 107 private int jjMoveStringLiteralDfa0_0(){
 108    switch(curChar)
 109    {
 110       case 13:
 111          jjmatchedKind = 3;
 112          return jjMoveStringLiteralDfa1_0(0x10L);
 113       case 33:
 114          jjmatchedKind = 31;
 115          return jjMoveStringLiteralDfa1_0(0x400000000000L);
 116       case 35:
 117          return jjStartNfaWithStates_0(0, 17, 85);
 118       case 36:
 119          return jjStopAtPos(0, 28);
 120       case 37:
 121          jjmatchedKind = 34;
 122          return jjMoveStringLiteralDfa1_0(0x1000000000000000L);
 123       case 38:
 124          jjmatchedKind = 32;
 125          return jjMoveStringLiteralDfa1_0(0x8000800000000000L);
 126       case 40:
 127          return jjStopAtPos(0, 21);
 128       case 41:
 129          return jjStopAtPos(0, 22);
 130       case 42:
 131          jjmatchedKind = 29;
 132          return jjMoveStringLiteralDfa1_0(0x400000000000000L);
 133       case 43:
 134          jjmatchedKind = 35;
 135          return jjMoveStringLiteralDfa1_0(0x100001000000000L);
 136       case 44:
 137          return jjStopAtPos(0, 26);
 138       case 45:
 139          jjmatchedKind = 37;
 140          return jjMoveStringLiteralDfa1_0(0x200004002000000L);
 141       case 46:
 142          return jjStartNfaWithStates_0(0, 27, 24);
 143       case 47:
 144          jjmatchedKind = 39;
 145          return jjMoveStringLiteralDfa1_0(0x800000000000000L);
 146       case 58:
 147          jjmatchedKind = 51;
 148          return jjMoveStringLiteralDfa1_0(0x10000000000000L);
 149       case 59:
 150          return jjStopAtPos(0, 64);
 151       case 60:
 152          jjmatchedKind = 41;
 153          return jjMoveStringLiteralDfa1_0(0x20100000000000L);
 154       case 61:
 155          jjmatchedKind = 20;
 156          return jjMoveStringLiteralDfa1_0(0x200000000000L);
 157       case 62:
 158          jjmatchedKind = 42;
 159          return jjMoveStringLiteralDfa1_0(0xc0080000000000L);
 160       case 63:
 161          return jjStopAtPos(0, 50);
 162       case 91:
 163          return jjStopAtPos(0, 18);
 164       case 92:
 165          return jjStopAtPos(0, 40);
 166       case 93:
 167          return jjStopAtPos(0, 19);
 168       case 94:
 169          jjmatchedKind = 49;
 170          return jjMoveStringLiteralDfa1_0(0x2000000000000000L);
 171       case 99:
 172          return jjMoveStringLiteralDfa1_0(0x140L);
 173       case 102:
 174          return jjMoveStringLiteralDfa1_0(0x2000L);
 175       case 105:
 176          return jjMoveStringLiteralDfa1_0(0x800L);
 177       case 115:
 178          return jjMoveStringLiteralDfa1_0(0x1080L);
 179       case 116:
 180          return jjMoveStringLiteralDfa1_0(0x400L);
 181       case 117:
 182          return jjMoveStringLiteralDfa1_0(0x200L);
 183       case 123:
 184          return jjStopAtPos(0, 23);
 185       case 124:
 186          jjmatchedKind = 33;
 187          return jjMoveStringLiteralDfa1_0(0x4001000000000000L);
 188       case 125:
 189          return jjStopAtPos(0, 24);
 190       case 126:
 191          return jjStopAtPos(0, 30);
 192       default :
 193          return jjMoveNfa_0(0, 0);
 194    }
 195 }
 196 private int jjMoveStringLiteralDfa1_0(long active0){
 197    try { curChar = input_stream.readChar(); }
 198    catch(java.io.IOException e) {
 199       jjStopStringLiteralDfa_0(0, active0, 0L);
 200       return 1;
 201    }
 202    switch(curChar)
 203    {
 204       case 10:
 205          if ((active0 & 0x10L) != 0L)
 206             return jjStopAtPos(1, 4);
 207          break;
 208       case 38:
 209          if ((active0 & 0x800000000000L) != 0L)
 210             return jjStopAtPos(1, 47);
 211          break;
 212       case 43:
 213          if ((active0 & 0x1000000000L) != 0L)
 214             return jjStopAtPos(1, 36);
 215          break;
 216       case 45:
 217          if ((active0 & 0x4000000000L) != 0L)
 218             return jjStopAtPos(1, 38);
 219          break;
 220       case 58:
 221          if ((active0 & 0x10000000000000L) != 0L)
 222             return jjStopAtPos(1, 52);
 223          break;
 224       case 60:
 225          if ((active0 & 0x20000000000000L) != 0L)
 226             return jjStopAtPos(1, 53);
 227          break;
 228       case 61:
 229          if ((active0 & 0x80000000000L) != 0L)
 230             return jjStopAtPos(1, 43);
 231          else if ((active0 & 0x100000000000L) != 0L)
 232             return jjStopAtPos(1, 44);
 233          else if ((active0 & 0x200000000000L) != 0L)
 234             return jjStopAtPos(1, 45);
 235          else if ((active0 & 0x400000000000L) != 0L)
 236             return jjStopAtPos(1, 46);
 237          else if ((active0 & 0x100000000000000L) != 0L)
 238             return jjStopAtPos(1, 56);
 239          else if ((active0 & 0x200000000000000L) != 0L)
 240             return jjStopAtPos(1, 57);
 241          else if ((active0 & 0x400000000000000L) != 0L)
 242             return jjStopAtPos(1, 58);
 243          else if ((active0 & 0x800000000000000L) != 0L)
 244             return jjStopAtPos(1, 59);
 245          else if ((active0 & 0x1000000000000000L) != 0L)
 246             return jjStopAtPos(1, 60);
 247          else if ((active0 & 0x2000000000000000L) != 0L)
 248             return jjStopAtPos(1, 61);
 249          else if ((active0 & 0x4000000000000000L) != 0L)
 250             return jjStopAtPos(1, 62);
 251          else if ((active0 & 0x8000000000000000L) != 0L)
 252             return jjStopAtPos(1, 63);
 253          break;
 254       case 62:
 255          if ((active0 & 0x2000000L) != 0L)
 256             return jjStopAtPos(1, 25);
 257          else if ((active0 & 0x40000000000000L) != 0L)
 258          {
 259             jjmatchedKind = 54;
 260             jjmatchedPos = 1;
 261          }
 262          return jjMoveStringLiteralDfa2_0(active0, 0x80000000000000L);
 263       case 101:
 264          return jjMoveStringLiteralDfa2_0(active0, 0x400L);
 265       case 108:
 266          return jjMoveStringLiteralDfa2_0(active0, 0x100L);
 267       case 110:
 268          return jjMoveStringLiteralDfa2_0(active0, 0xa00L);
 269       case 111:
 270          return jjMoveStringLiteralDfa2_0(active0, 0x2040L);
 271       case 116:
 272          return jjMoveStringLiteralDfa2_0(active0, 0x1080L);
 273       case 124:
 274          if ((active0 & 0x1000000000000L) != 0L)
 275             return jjStopAtPos(1, 48);
 276          break;
 277       default :
 278          break;
 279    }
 280    return jjStartNfa_0(0, active0, 0L);
 281 }
 282 private int jjMoveStringLiteralDfa2_0(long old0, long active0){
 283    if (((active0 &= old0)) == 0L)
 284       return jjStartNfa_0(0, old0, 0L);
 285    try { curChar = input_stream.readChar(); }
 286    catch(java.io.IOException e) {
 287       jjStopStringLiteralDfa_0(1, active0, 0L);
 288       return 2;
 289    }
 290    switch(curChar)
 291    {
 292       case 62:
 293          if ((active0 & 0x80000000000000L) != 0L)
 294             return jjStopAtPos(2, 55);
 295          break;
 296       case 97:
 297          return jjMoveStringLiteralDfa3_0(active0, 0x1100L);
 298       case 108:
 299          return jjMoveStringLiteralDfa3_0(active0, 0x800L);
 300       case 109:
 301          return jjMoveStringLiteralDfa3_0(active0, 0x400L);
 302       case 110:
 303          return jjMoveStringLiteralDfa3_0(active0, 0x40L);
 304       case 114:
 305          if ((active0 & 0x2000L) != 0L)
 306             return jjStartNfaWithStates_0(2, 13, 1);
 307          return jjMoveStringLiteralDfa3_0(active0, 0x80L);
 308       case 115:
 309          return jjMoveStringLiteralDfa3_0(active0, 0x200L);
 310       default :
 311          break;
 312    }
 313    return jjStartNfa_0(1, active0, 0L);
 314 }
 315 private int jjMoveStringLiteralDfa3_0(long old0, long active0){
 316    if (((active0 &= old0)) == 0L)
 317       return jjStartNfa_0(1, old0, 0L);
 318    try { curChar = input_stream.readChar(); }
 319    catch(java.io.IOException e) {
 320       jjStopStringLiteralDfa_0(2, active0, 0L);
 321       return 3;
 322    }
 323    switch(curChar)
 324    {
 325       case 105:
 326          return jjMoveStringLiteralDfa4_0(active0, 0xa00L);
 327       case 112:
 328          return jjMoveStringLiteralDfa4_0(active0, 0x400L);
 329       case 115:
 330          return jjMoveStringLiteralDfa4_0(active0, 0x140L);
 331       case 116:
 332          return jjMoveStringLiteralDfa4_0(active0, 0x1000L);
 333       case 117:
 334          return jjMoveStringLiteralDfa4_0(active0, 0x80L);
 335       default :
 336          break;
 337    }
 338    return jjStartNfa_0(2, active0, 0L);
 339 }
 340 private int jjMoveStringLiteralDfa4_0(long old0, long active0){
 341    if (((active0 &= old0)) == 0L)
 342       return jjStartNfa_0(2, old0, 0L);
 343    try { curChar = input_stream.readChar(); }
 344    catch(java.io.IOException e) {
 345       jjStopStringLiteralDfa_0(3, active0, 0L);
 346       return 4;
 347    }
 348    switch(curChar)
 349    {
 350       case 99:
 351          return jjMoveStringLiteralDfa5_0(active0, 0x80L);
 352       case 103:
 353          return jjMoveStringLiteralDfa5_0(active0, 0x200L);
 354       case 105:
 355          return jjMoveStringLiteralDfa5_0(active0, 0x1000L);
 356       case 108:
 357          return jjMoveStringLiteralDfa5_0(active0, 0x400L);
 358       case 110:
 359          return jjMoveStringLiteralDfa5_0(active0, 0x800L);
 360       case 115:
 361          if ((active0 & 0x100L) != 0L)
 362             return jjStartNfaWithStates_0(4, 8, 1);
 363          break;
 364       case 116:
 365          if ((active0 & 0x40L) != 0L)
 366             return jjStartNfaWithStates_0(4, 6, 1);
 367          break;
 368       default :
 369          break;
 370    }
 371    return jjStartNfa_0(3, active0, 0L);
 372 }
 373 private int jjMoveStringLiteralDfa5_0(long old0, long active0){
 374    if (((active0 &= old0)) == 0L)
 375       return jjStartNfa_0(3, old0, 0L);
 376    try { curChar = input_stream.readChar(); }
 377    catch(java.io.IOException e) {
 378       jjStopStringLiteralDfa_0(4, active0, 0L);
 379       return 5;
 380    }
 381    switch(curChar)
 382    {
 383       case 97:
 384          return jjMoveStringLiteralDfa6_0(active0, 0x400L);
 385       case 99:
 386          if ((active0 & 0x1000L) != 0L)
 387             return jjStartNfaWithStates_0(5, 12, 1);
 388          break;
 389       case 101:
 390          if ((active0 & 0x800L) != 0L)
 391             return jjStartNfaWithStates_0(5, 11, 1);
 392          break;
 393       case 110:
 394          return jjMoveStringLiteralDfa6_0(active0, 0x200L);
 395       case 116:
 396          if ((active0 & 0x80L) != 0L)
 397             return jjStartNfaWithStates_0(5, 7, 1);
 398          break;
 399       default :
 400          break;
 401    }
 402    return jjStartNfa_0(4, active0, 0L);
 403 }
 404 private int jjMoveStringLiteralDfa6_0(long old0, long active0){
 405    if (((active0 &= old0)) == 0L)
 406       return jjStartNfa_0(4, old0, 0L);
 407    try { curChar = input_stream.readChar(); }
 408    catch(java.io.IOException e) {
 409       jjStopStringLiteralDfa_0(5, active0, 0L);
 410       return 6;
 411    }
 412    switch(curChar)
 413    {
 414       case 101:
 415          return jjMoveStringLiteralDfa7_0(active0, 0x200L);
 416       case 116:
 417          return jjMoveStringLiteralDfa7_0(active0, 0x400L);
 418       default :
 419          break;
 420    }
 421    return jjStartNfa_0(5, active0, 0L);
 422 }
 423 private int jjMoveStringLiteralDfa7_0(long old0, long active0){
 424    if (((active0 &= old0)) == 0L)
 425       return jjStartNfa_0(5, old0, 0L);
 426    try { curChar = input_stream.readChar(); }
 427    catch(java.io.IOException e) {
 428       jjStopStringLiteralDfa_0(6, active0, 0L);
 429       return 7;
 430    }
 431    switch(curChar)
 432    {
 433       case 100:
 434          if ((active0 & 0x200L) != 0L)
 435             return jjStartNfaWithStates_0(7, 9, 1);
 436          break;
 437       case 101:
 438          if ((active0 & 0x400L) != 0L)
 439             return jjStartNfaWithStates_0(7, 10, 1);
 440          break;
 441       default :
 442          break;
 443    }
 444    return jjStartNfa_0(6, active0, 0L);
 445 }
 446 private int jjStartNfaWithStates_0(int pos, int kind, int state)
 447 {
 448    jjmatchedKind = kind;
 449    jjmatchedPos = pos;
 450    try { curChar = input_stream.readChar(); }
 451    catch(java.io.IOException e) { return pos + 1; }
 452    return jjMoveNfa_0(state, pos + 1);
 453 }
 454 static final long[] jjbitVec0 = {
 455    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 456 };
 457 static final long[] jjbitVec2 = {
 458    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 459 };
 460 private int jjMoveNfa_0(int startState, int curPos)
 461 {
 462    int startsAt = 0;
 463    jjnewStateCnt = 85;
 464    int i = 1;
 465    jjstateSet[0] = startState;
 466    int kind = 0x7fffffff;
 467    for (;;)
 468    {
 469       if (++jjround == 0x7fffffff)
 470          ReInitRounds();
 471       if (curChar < 64)
 472       {
 473          long l = 1L << curChar;
 474          do
 475          {
 476             switch(jjstateSet[--i])
 477             {
 478                case 0:
 479                   if ((0x3ff000000000000L & l) != 0L)
 480                      { jjCheckNAddStates(0, 6); }
 481                   else if (curChar == 35)
 482                      { jjCheckNAddStates(7, 10); }
 483                   else if (curChar == 46)
 484                      { jjCheckNAdd(24); }
 485                   else if (curChar == 39)
 486                      { jjAddStates(11, 12); }
 487                   else if (curChar == 34)
 488                      { jjCheckNAddStates(13, 15); }
 489                   if ((0x3fe000000000000L & l) != 0L)
 490                   {
 491                      if (kind > 67)
 492                         kind = 67;
 493                      { jjCheckNAddTwoStates(21, 22); }
 494                   }
 495                   else if (curChar == 48)
 496                   {
 497                      if (kind > 67)
 498                         kind = 67;
 499                      { jjCheckNAddStates(16, 20); }
 500                   }
 501                   break;
 502                case 85:
 503                   if ((0xfffffffffffffbffL & l) != 0L)
 504                   {
 505                      if (kind > 79)
 506                         kind = 79;
 507                      { jjCheckNAdd(67); }
 508                   }
 509                   if ((0x100000200L & l) != 0L)
 510                      { jjCheckNAddTwoStates(66, 67); }
 511                   if ((0x100000200L & l) != 0L)
 512                      { jjCheckNAddTwoStates(45, 65); }
 513                   break;
 514                case 1:
 515                   if ((0x3ff000000000000L & l) == 0L)
 516                      break;
 517                   if (kind > 16)
 518                      kind = 16;
 519                   jjstateSet[jjnewStateCnt++] = 1;
 520                   break;
 521                case 2:
 522                   if (curChar == 34)
 523                      { jjCheckNAddStates(13, 15); }
 524                   break;
 525                case 3:
 526                   if ((0xfffffffbffffdbffL & l) != 0L)
 527                      { jjCheckNAddStates(13, 15); }
 528                   break;
 529                case 5:
 530                   if ((0x8400000000L & l) != 0L)
 531                      { jjCheckNAddStates(13, 15); }
 532                   break;
 533                case 6:
 534                   if (curChar == 34 && kind > 65)
 535                      kind = 65;
 536                   break;
 537                case 7:
 538                   if ((0xff000000000000L & l) != 0L)
 539                      { jjCheckNAddStates(21, 24); }
 540                   break;
 541                case 8:
 542                   if ((0xff000000000000L & l) != 0L)
 543                      { jjCheckNAddStates(13, 15); }
 544                   break;
 545                case 9:
 546                   if ((0xf000000000000L & l) != 0L)
 547                      jjstateSet[jjnewStateCnt++] = 10;
 548                   break;
 549                case 10:
 550                   if ((0xff000000000000L & l) != 0L)
 551                      { jjCheckNAdd(8); }
 552                   break;
 553                case 11:
 554                   if (curChar == 39)
 555                      { jjAddStates(11, 12); }
 556                   break;
 557                case 12:
 558                   if ((0xffffff7fffffdbffL & l) != 0L)
 559                      { jjCheckNAdd(13); }
 560                   break;
 561                case 13:
 562                   if (curChar == 39 && kind > 66)
 563                      kind = 66;
 564                   break;
 565                case 15:
 566                   if ((0x8400000000L & l) != 0L)
 567                      { jjCheckNAdd(13); }
 568                   break;
 569                case 16:
 570                   if ((0xff000000000000L & l) != 0L)
 571                      { jjCheckNAddTwoStates(17, 13); }
 572                   break;
 573                case 17:
 574                   if ((0xff000000000000L & l) != 0L)
 575                      { jjCheckNAdd(13); }
 576                   break;
 577                case 18:
 578                   if ((0xf000000000000L & l) != 0L)
 579                      jjstateSet[jjnewStateCnt++] = 19;
 580                   break;
 581                case 19:
 582                   if ((0xff000000000000L & l) != 0L)
 583                      { jjCheckNAdd(17); }
 584                   break;
 585                case 20:
 586                   if ((0x3fe000000000000L & l) == 0L)
 587                      break;
 588                   if (kind > 67)
 589                      kind = 67;
 590                   { jjCheckNAddTwoStates(21, 22); }
 591                   break;
 592                case 21:
 593                   if ((0x3ff000000000000L & l) == 0L)
 594                      break;
 595                   if (kind > 67)
 596                      kind = 67;
 597                   { jjCheckNAddTwoStates(21, 22); }
 598                   break;
 599                case 23:
 600                   if (curChar == 46)
 601                      { jjCheckNAdd(24); }
 602                   break;
 603                case 24:
 604                   if ((0x3ff000000000000L & l) == 0L)
 605                      break;
 606                   if (kind > 71)
 607                      kind = 71;
 608                   { jjCheckNAddStates(25, 27); }
 609                   break;
 610                case 26:
 611                   if ((0x280000000000L & l) != 0L)
 612                      { jjCheckNAdd(27); }
 613                   break;
 614                case 27:
 615                   if ((0x3ff000000000000L & l) == 0L)
 616                      break;
 617                   if (kind > 71)
 618                      kind = 71;
 619                   { jjCheckNAddTwoStates(27, 28); }
 620                   break;
 621                case 29:
 622                   if ((0x3ff000000000000L & l) != 0L)
 623                      { jjCheckNAddStates(0, 6); }
 624                   break;
 625                case 30:
 626                   if ((0x3ff000000000000L & l) != 0L)
 627                      { jjCheckNAddStates(28, 30); }
 628                   break;
 629                case 32:
 630                   if ((0x280000000000L & l) != 0L)
 631                      { jjCheckNAdd(33); }
 632                   break;
 633                case 33:
 634                   if ((0x3ff000000000000L & l) != 0L)
 635                      { jjCheckNAddTwoStates(33, 28); }
 636                   break;
 637                case 34:
 638                   if ((0x3ff000000000000L & l) != 0L)
 639                      { jjCheckNAddTwoStates(34, 35); }
 640                   break;
 641                case 36:
 642                   if ((0x280000000000L & l) != 0L)
 643                      { jjCheckNAdd(37); }
 644                   break;
 645                case 37:
 646                   if ((0x3ff000000000000L & l) == 0L)
 647                      break;
 648                   if (kind > 71)
 649                      kind = 71;
 650                   { jjCheckNAddTwoStates(37, 28); }
 651                   break;
 652                case 38:
 653                   if ((0x3ff000000000000L & l) != 0L)
 654                      { jjCheckNAddTwoStates(38, 39); }
 655                   break;
 656                case 39:
 657                   if (curChar != 46)
 658                      break;
 659                   if (kind > 71)
 660                      kind = 71;
 661                   { jjCheckNAddStates(31, 33); }
 662                   break;
 663                case 40:
 664                   if ((0x3ff000000000000L & l) == 0L)
 665                      break;
 666                   if (kind > 71)
 667                      kind = 71;
 668                   { jjCheckNAddStates(31, 33); }
 669                   break;
 670                case 42:
 671                   if ((0x280000000000L & l) != 0L)
 672                      { jjCheckNAdd(43); }
 673                   break;
 674                case 43:
 675                   if ((0x3ff000000000000L & l) == 0L)
 676                      break;
 677                   if (kind > 71)
 678                      kind = 71;
 679                   { jjCheckNAddTwoStates(43, 28); }
 680                   break;
 681                case 44:
 682                   if (curChar == 35)
 683                      { jjCheckNAddStates(7, 10); }
 684                   break;
 685                case 45:
 686                   if ((0x100000200L & l) != 0L)
 687                      { jjCheckNAddTwoStates(45, 65); }
 688                   break;
 689                case 47:
 690                   if ((0x100000200L & l) != 0L)
 691                      { jjAddStates(34, 36); }
 692                   break;
 693                case 48:
 694                   if (curChar == 34)
 695                      { jjCheckNAddStates(37, 39); }
 696                   break;
 697                case 49:
 698                   if ((0xfffffffbffffdbffL & l) != 0L)
 699                      { jjCheckNAddStates(37, 39); }
 700                   break;
 701                case 51:
 702                   if ((0x8400000000L & l) != 0L)
 703                      { jjCheckNAddStates(37, 39); }
 704                   break;
 705                case 52:
 706                   if (curChar == 34 && kind > 78)
 707                      kind = 78;
 708                   break;
 709                case 53:
 710                   if ((0xff000000000000L & l) != 0L)
 711                      { jjCheckNAddStates(40, 43); }
 712                   break;
 713                case 54:
 714                   if ((0xff000000000000L & l) != 0L)
 715                      { jjCheckNAddStates(37, 39); }
 716                   break;
 717                case 55:
 718                   if ((0xf000000000000L & l) != 0L)
 719                      jjstateSet[jjnewStateCnt++] = 56;
 720                   break;
 721                case 56:
 722                   if ((0xff000000000000L & l) != 0L)
 723                      { jjCheckNAdd(54); }
 724                   break;
 725                case 57:
 726                   if (curChar == 60)
 727                      { jjCheckNAdd(58); }
 728                   break;
 729                case 58:
 730                   if (curChar == 46)
 731                      { jjCheckNAddTwoStates(58, 59); }
 732                   break;
 733                case 59:
 734                   if (curChar == 62 && kind > 78)
 735                      kind = 78;
 736                   break;
 737                case 66:
 738                   if ((0x100000200L & l) != 0L)
 739                      { jjCheckNAddTwoStates(66, 67); }
 740                   break;
 741                case 67:
 742                   if ((0xfffffffffffffbffL & l) == 0L)
 743                      break;
 744                   if (kind > 79)
 745                      kind = 79;
 746                   { jjCheckNAdd(67); }
 747                   break;
 748                case 68:
 749                   if (curChar != 48)
 750                      break;
 751                   if (kind > 67)
 752                      kind = 67;
 753                   { jjCheckNAddStates(16, 20); }
 754                   break;
 755                case 70:
 756                   if ((0x3ff000000000000L & l) == 0L)
 757                      break;
 758                   if (kind > 67)
 759                      kind = 67;
 760                   { jjCheckNAddTwoStates(70, 22); }
 761                   break;
 762                case 71:
 763                   if ((0xff000000000000L & l) == 0L)
 764                      break;
 765                   if (kind > 67)
 766                      kind = 67;
 767                   { jjCheckNAddTwoStates(71, 22); }
 768                   break;
 769                case 73:
 770                   if ((0x3ff000000000000L & l) != 0L)
 771                      { jjAddStates(44, 45); }
 772                   break;
 773                case 74:
 774                   if (curChar == 46)
 775                      { jjCheckNAdd(75); }
 776                   break;
 777                case 75:
 778                   if ((0x3ff000000000000L & l) != 0L)
 779                      { jjCheckNAddTwoStates(75, 76); }
 780                   break;
 781                case 77:
 782                   if ((0x280000000000L & l) != 0L)
 783                      { jjCheckNAdd(78); }
 784                   break;
 785                case 78:
 786                   if ((0x3ff000000000000L & l) == 0L)
 787                      break;
 788                   if (kind > 71)
 789                      kind = 71;
 790                   { jjCheckNAddTwoStates(78, 28); }
 791                   break;
 792                case 80:
 793                   if ((0x3ff000000000000L & l) != 0L)
 794                      { jjCheckNAddStates(46, 48); }
 795                   break;
 796                case 81:
 797                   if (curChar == 46)
 798                      { jjCheckNAdd(82); }
 799                   break;
 800                case 83:
 801                   if ((0x280000000000L & l) != 0L)
 802                      { jjCheckNAdd(84); }
 803                   break;
 804                case 84:
 805                   if ((0x3ff000000000000L & l) == 0L)
 806                      break;
 807                   if (kind > 71)
 808                      kind = 71;
 809                   { jjCheckNAddTwoStates(84, 28); }
 810                   break;
 811                default : break;
 812             }
 813          } while(i != startsAt);
 814       }
 815       else if (curChar < 128)
 816       {
 817          long l = 1L << (curChar & 077);
 818          do
 819          {
 820             switch(jjstateSet[--i])
 821             {
 822                case 0:
 823                case 1:
 824                   if ((0x7fffffe87fffffeL & l) == 0L)
 825                      break;
 826                   if (kind > 16)
 827                      kind = 16;
 828                   { jjCheckNAdd(1); }
 829                   break;
 830                case 85:
 831                   if (kind > 79)
 832                      kind = 79;
 833                   { jjCheckNAdd(67); }
 834                   if (curChar == 105)
 835                      jjstateSet[jjnewStateCnt++] = 64;
 836                   break;
 837                case 3:
 838                   if ((0xffffffffefffffffL & l) != 0L)
 839                      { jjCheckNAddStates(13, 15); }
 840                   break;
 841                case 4:
 842                   if (curChar == 92)
 843                      { jjAddStates(49, 51); }
 844                   break;
 845                case 5:
 846                   if ((0x14404410000000L & l) != 0L)
 847                      { jjCheckNAddStates(13, 15); }
 848                   break;
 849                case 12:
 850                   if ((0xffffffffefffffffL & l) != 0L)
 851                      { jjCheckNAdd(13); }
 852                   break;
 853                case 14:
 854                   if (curChar == 92)
 855                      { jjAddStates(52, 54); }
 856                   break;
 857                case 15:
 858                   if ((0x14404410000000L & l) != 0L)
 859                      { jjCheckNAdd(13); }
 860                   break;
 861                case 22:
 862                   if ((0x100000001000L & l) != 0L && kind > 67)
 863                      kind = 67;
 864                   break;
 865                case 25:
 866                   if ((0x2000000020L & l) != 0L)
 867                      { jjAddStates(55, 56); }
 868                   break;
 869                case 28:
 870                   if ((0x5000000050L & l) != 0L && kind > 71)
 871                      kind = 71;
 872                   break;
 873                case 31:
 874                   if ((0x2000000020L & l) != 0L)
 875                      { jjAddStates(57, 58); }
 876                   break;
 877                case 35:
 878                   if ((0x2000000020L & l) != 0L)
 879                      { jjAddStates(59, 60); }
 880                   break;
 881                case 41:
 882                   if ((0x2000000020L & l) != 0L)
 883                      { jjAddStates(61, 62); }
 884                   break;
 885                case 46:
 886                   if (curChar == 101)
 887                      jjstateSet[jjnewStateCnt++] = 47;
 888                   break;
 889                case 49:
 890                   if ((0xffffffffefffffffL & l) != 0L)
 891                      { jjCheckNAddStates(37, 39); }
 892                   break;
 893                case 50:
 894                   if (curChar == 92)
 895                      { jjAddStates(63, 65); }
 896                   break;
 897                case 51:
 898                   if ((0x14404410000000L & l) != 0L)
 899                      { jjCheckNAddStates(37, 39); }
 900                   break;
 901                case 58:
 902                   if ((0x7fffffe07fffffeL & l) != 0L)
 903                      { jjAddStates(66, 67); }
 904                   break;
 905                case 60:
 906                   if (curChar == 100)
 907                      jjstateSet[jjnewStateCnt++] = 46;
 908                   break;
 909                case 61:
 910                   if (curChar == 117)
 911                      jjstateSet[jjnewStateCnt++] = 60;
 912                   break;
 913                case 62:
 914                   if (curChar == 108)
 915                      jjstateSet[jjnewStateCnt++] = 61;
 916                   break;
 917                case 63:
 918                   if (curChar == 99)
 919                      jjstateSet[jjnewStateCnt++] = 62;
 920                   break;
 921                case 64:
 922                   if (curChar == 110)
 923                      jjstateSet[jjnewStateCnt++] = 63;
 924                   break;
 925                case 65:
 926                   if (curChar == 105)
 927                      jjstateSet[jjnewStateCnt++] = 64;
 928                   break;
 929                case 67:
 930                   if (kind > 79)
 931                      kind = 79;
 932                   { jjCheckNAdd(67); }
 933                   break;
 934                case 69:
 935                   if ((0x100000001000000L & l) != 0L)
 936                      { jjCheckNAdd(70); }
 937                   break;
 938                case 70:
 939                   if ((0x7e0000007eL & l) == 0L)
 940                      break;
 941                   if (kind > 67)
 942                      kind = 67;
 943                   { jjCheckNAddTwoStates(70, 22); }
 944                   break;
 945                case 72:
 946                   if ((0x100000001000000L & l) != 0L)
 947                      { jjCheckNAddTwoStates(73, 74); }
 948                   break;
 949                case 73:
 950                   if ((0x7e0000007eL & l) != 0L)
 951                      { jjCheckNAddTwoStates(73, 74); }
 952                   break;
 953                case 75:
 954                   if ((0x7e0000007eL & l) != 0L)
 955                      { jjAddStates(68, 69); }
 956                   break;
 957                case 76:
 958                   if ((0x1000000010000L & l) != 0L)
 959                      { jjAddStates(70, 71); }
 960                   break;
 961                case 79:
 962                   if ((0x100000001000000L & l) != 0L)
 963                      { jjCheckNAdd(80); }
 964                   break;
 965                case 80:
 966                   if ((0x7e0000007eL & l) != 0L)
 967                      { jjCheckNAddStates(46, 48); }
 968                   break;
 969                case 82:
 970                   if ((0x1000000010000L & l) != 0L)
 971                      { jjAddStates(72, 73); }
 972                   break;
 973                default : break;
 974             }
 975          } while(i != startsAt);
 976       }
 977       else
 978       {
 979          int hiByte = (curChar >> 8);
 980          int i1 = hiByte >> 6;
 981          long l1 = 1L << (hiByte & 077);
 982          int i2 = (curChar & 0xff) >> 6;
 983          long l2 = 1L << (curChar & 077);
 984          do
 985          {
 986             switch(jjstateSet[--i])
 987             {
 988                case 85:
 989                case 67:
 990                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 991                      break;
 992                   if (kind > 79)
 993                      kind = 79;
 994                   { jjCheckNAdd(67); }
 995                   break;
 996                case 3:
 997                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 998                      { jjAddStates(13, 15); }
 999                   break;
1000                case 12:
1001                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1002                      jjstateSet[jjnewStateCnt++] = 13;
1003                   break;
1004                case 49:
1005                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1006                      { jjAddStates(37, 39); }
1007                   break;
1008                default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break;
1009             }
1010          } while(i != startsAt);
1011       }
1012       if (kind != 0x7fffffff)
1013       {
1014          jjmatchedKind = kind;
1015          jjmatchedPos = curPos;
1016          kind = 0x7fffffff;
1017       }
1018       ++curPos;
1019       if ((i = jjnewStateCnt) == (startsAt = 85 - (jjnewStateCnt = startsAt)))
1020          return curPos;
1021       try { curChar = input_stream.readChar(); }
1022       catch(java.io.IOException e) { return curPos; }
1023    }
1024 }
1025 static final int[] jjnextStates = {
1026    30, 31, 28, 34, 35, 38, 39, 45, 65, 66, 67, 12, 14, 3, 4, 6,
1027    69, 71, 22, 72, 79, 3, 4, 8, 6, 24, 25, 28, 30, 31, 28, 40,
1028    41, 28, 47, 48, 57, 49, 50, 52, 49, 50, 54, 52, 73, 74, 80, 81,
1029    82, 5, 7, 9, 15, 16, 18, 26, 27, 32, 33, 36, 37, 42, 43, 51,
1030    53, 55, 58, 59, 75, 76, 77, 78, 83, 84,
1031 };
1032 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1033 {
1034    switch(hiByte)
1035    {
1036       case 0:
1037          return ((jjbitVec2[i2] & l2) != 0L);
1038       default :
1039          if ((jjbitVec0[i1] & l1) != 0L)
1040             return true;
1041          return false;
1042    }
1043 }
1044
1045 /** Token literal values. */
1046 public static final String[] jjstrLiteralImages = {
1047 "", null, null, null, null, null, "\143\157\156\163\164",
1048 "\163\164\162\165\143\164", "\143\154\141\163\163", "\165\156\163\151\147\156\145\144",
1049 "\164\145\155\160\154\141\164\145", "\151\156\154\151\156\145", "\163\164\141\164\151\143", "\146\157\162", null,
1050 null, null, "\43", "\133", "\135", "\75", "\50", "\51", "\173", "\175", "\55\76",
1051 "\54", "\56", "\44", "\52", "\176", "\41", "\46", "\174", "\45", "\53", "\53\53",
1052 "\55", "\55\55", "\57", "\134", "\74", "\76", "\76\75", "\74\75", "\75\75", "\41\75",
1053 "\46\46", "\174\174", "\136", "\77", "\72", "\72\72", "\74\74", "\76\76", "\76\76\76",
1054 "\53\75", "\55\75", "\52\75", "\57\75", "\45\75", "\136\75", "\174\75", "\46\75", "\73",
1055 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1056 null, };
1057 protected Token jjFillToken()
1058 {
1059    final Token t;
1060    final String curTokenImage;
1061    final int beginLine;
1062    final int endLine;
1063    final int beginColumn;
1064    final int endColumn;
1065    String im = jjstrLiteralImages[jjmatchedKind];
1066    curTokenImage = (im == null) ? input_stream.GetImage() : im;
1067    beginLine = input_stream.getBeginLine();
1068    beginColumn = input_stream.getBeginColumn();
1069    endLine = input_stream.getEndLine();
1070    endColumn = input_stream.getEndColumn();
1071    t = Token.newToken(jjmatchedKind, curTokenImage);
1072
1073    t.beginLine = beginLine;
1074    t.endLine = endLine;
1075    t.beginColumn = beginColumn;
1076    t.endColumn = endColumn;
1077
1078    return t;
1079 }
1080
1081 int curLexState = 0;
1082 int defaultLexState = 0;
1083 int jjnewStateCnt;
1084 int jjround;
1085 int jjmatchedPos;
1086 int jjmatchedKind;
1087
1088 /** Get the next Token. */
1089 public Token getNextToken()
1090 {
1091   Token matchedToken;
1092   int curPos = 0;
1093
1094   EOFLoop :
1095   for (;;)
1096   {
1097    try
1098    {
1099       curChar = input_stream.BeginToken();
1100    }
1101    catch(java.io.IOException e)
1102    {
1103       jjmatchedKind = 0;
1104       jjmatchedPos = -1;
1105       matchedToken = jjFillToken();
1106       return matchedToken;
1107    }
1108
1109    try { input_stream.backup(0);
1110       while (curChar <= 32 && (0x100000600L & (1L << curChar)) != 0L)
1111          curChar = input_stream.BeginToken();
1112    }
1113    catch (java.io.IOException e1) { continue EOFLoop; }
1114    jjmatchedKind = 0x7fffffff;
1115    jjmatchedPos = 0;
1116    curPos = jjMoveStringLiteralDfa0_0();
1117    if (jjmatchedKind != 0x7fffffff)
1118    {
1119       if (jjmatchedPos + 1 < curPos)
1120          input_stream.backup(curPos - jjmatchedPos - 1);
1121       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1122       {
1123          matchedToken = jjFillToken();
1124          return matchedToken;
1125       }
1126       else
1127       {
1128          continue EOFLoop;
1129       }
1130    }
1131    int error_line = input_stream.getEndLine();
1132    int error_column = input_stream.getEndColumn();
1133    String error_after = null;
1134    boolean EOFSeen = false;
1135    try { input_stream.readChar(); input_stream.backup(1); }
1136    catch (java.io.IOException e1) {
1137       EOFSeen = true;
1138       error_after = curPos <= 1 ? "" : input_stream.GetImage();
1139       if (curChar == '\n' || curChar == '\r') {
1140          error_line++;
1141          error_column = 0;
1142       }
1143       else
1144          error_column++;
1145    }
1146    if (!EOFSeen) {
1147       input_stream.backup(1);
1148       error_after = curPos <= 1 ? "" : input_stream.GetImage();
1149    }
1150    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1151   }
1152 }
1153
1154 private void jjCheckNAdd(int state)
1155 {
1156    if (jjrounds[state] != jjround)
1157    {
1158       jjstateSet[jjnewStateCnt++] = state;
1159       jjrounds[state] = jjround;
1160    }
1161 }
1162 private void jjAddStates(int start, int end)
1163 {
1164    do {
1165       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1166    } while (start++ != end);
1167 }
1168 private void jjCheckNAddTwoStates(int state1, int state2)
1169 {
1170    jjCheckNAdd(state1);
1171    jjCheckNAdd(state2);
1172 }
1173
1174 private void jjCheckNAddStates(int start, int end)
1175 {
1176    do {
1177       jjCheckNAdd(jjnextStates[start]);
1178    } while (start++ != end);
1179 }
1180
1181     /** Constructor. */
1182     public UtilParserTokenManager(JavaCharStream stream){
1183
1184       if (JavaCharStream.staticFlag)
1185             throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1186
1187     input_stream = stream;
1188   }
1189
1190   /** Constructor. */
1191   public UtilParserTokenManager (JavaCharStream stream, int lexState){
1192     ReInit(stream);
1193     SwitchTo(lexState);
1194   }
1195
1196   /** Reinitialise parser. */
1197   public void ReInit(JavaCharStream stream)
1198   {
1199     jjmatchedPos = jjnewStateCnt = 0;
1200     curLexState = defaultLexState;
1201     input_stream = stream;
1202     ReInitRounds();
1203   }
1204
1205   private void ReInitRounds()
1206   {
1207     int i;
1208     jjround = 0x80000001;
1209     for (i = 85; i-- > 0;)
1210       jjrounds[i] = 0x80000000;
1211   }
1212
1213   /** Reinitialise parser. */
1214   public void ReInit(JavaCharStream stream, int lexState)
1215   {
1216     ReInit(stream);
1217     SwitchTo(lexState);
1218   }
1219
1220   /** Switch to specified lex state. */
1221   public void SwitchTo(int lexState)
1222   {
1223     if (lexState >= 1 || lexState < 0)
1224       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1225     else
1226       curLexState = lexState;
1227   }
1228
1229 /** Lexer state names. */
1230 public static final String[] lexStateNames = {
1231    "DEFAULT",
1232 };
1233 static final long[] jjtoToken = {
1234    0xffffffffffff3fc1L, 0xc08fL,
1235 };
1236 static final long[] jjtoSkip = {
1237    0x3eL, 0x0L,
1238 };
1239     protected JavaCharStream  input_stream;
1240
1241     private final int[] jjrounds = new int[85];
1242     private final int[] jjstateSet = new int[2 * 85];
1243
1244
1245     protected char curChar;
1246 }