net.sourceforge.phpeclipse/src/test/PHPParserTokenManager.java

   1 /* Generated By:JavaCC: Do not edit this line. PHPParserTokenManager.java */
   2 package test;
   3 import org.eclipse.core.resources.IFile;
   4 import org.eclipse.core.resources.IMarker;
   5 import org.eclipse.core.runtime.CoreException;
   6 import org.eclipse.ui.texteditor.MarkerUtilities;
   7 import org.eclipse.jface.preference.IPreferenceStore;
   8 import java.util.Hashtable;
   9 import java.io.StringReader;
  10 import java.text.MessageFormat;
  11 import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
  12 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  13 import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
  14 import net.sourceforge.phpdt.internal.compiler.parser.PHPSegmentWithChildren;
  15 import net.sourceforge.phpdt.internal.compiler.parser.PHPFunctionDeclaration;
  16 import net.sourceforge.phpdt.internal.compiler.parser.PHPClassDeclaration;
  17
  18 public class PHPParserTokenManager implements PHPParserConstants
  19 {
  20   public static  java.io.PrintStream debugStream = System.out;
  21   public static  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  22 private static final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2)
  23 {
  24    switch (pos)
  25    {
  26       default :
  27          return -1;
  28    }
  29 }
  30 private static final int jjStartNfa_0(int pos, long active0, long active1, long active2)
  31 {
  32    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
  33 }
  34 static private final int jjStopAtPos(int pos, int kind)
  35 {
  36    jjmatchedKind = kind;
  37    jjmatchedPos = pos;
  38    return pos + 1;
  39 }
  40 static private final int jjStartNfaWithStates_0(int pos, int kind, int state)
  41 {
  42    jjmatchedKind = kind;
  43    jjmatchedPos = pos;
  44    try { curChar = input_stream.readChar(); }
  45    catch(java.io.IOException e) { return pos + 1; }
  46    return jjMoveNfa_0(state, pos + 1);
  47 }
  48 static private final int jjMoveStringLiteralDfa0_0()
  49 {
  50    switch(curChar)
  51    {
  52       case 63:
  53          return jjMoveStringLiteralDfa1_0(0x8000000000000000L);
  54       default :
  55          return jjMoveNfa_0(0, 0);
  56    }
  57 }
  58 static private final int jjMoveStringLiteralDfa1_0(long active1)
  59 {
  60    try { curChar = input_stream.readChar(); }
  61    catch(java.io.IOException e) {
  62       jjStopStringLiteralDfa_0(0, 0L, active1, 0L);
  63       return 1;
  64    }
  65    switch(curChar)
  66    {
  67       case 62:
  68          if ((active1 & 0x8000000000000000L) != 0L)
  69             return jjStopAtPos(1, 127);
  70          break;
  71       default :
  72          break;
  73    }
  74    return jjStartNfa_0(0, 0L, active1, 0L);
  75 }
  76 static private final void jjCheckNAdd(int state)
  77 {
  78    if (jjrounds[state] != jjround)
  79    {
  80       jjstateSet[jjnewStateCnt++] = state;
  81       jjrounds[state] = jjround;
  82    }
  83 }
  84 static private final void jjAddStates(int start, int end)
  85 {
  86    do {
  87       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
  88    } while (start++ != end);
  89 }
  90 static private final void jjCheckNAddTwoStates(int state1, int state2)
  91 {
  92    jjCheckNAdd(state1);
  93    jjCheckNAdd(state2);
  94 }
  95 static private final void jjCheckNAddStates(int start, int end)
  96 {
  97    do {
  98       jjCheckNAdd(jjnextStates[start]);
  99    } while (start++ != end);
 100 }
 101 static private final void jjCheckNAddStates(int start)
 102 {
 103    jjCheckNAdd(jjnextStates[start]);
 104    jjCheckNAdd(jjnextStates[start + 1]);
 105 }
 106 static private final int jjMoveNfa_0(int startState, int curPos)
 107 {
 108    int[] nextStates;
 109    int startsAt = 0;
 110    jjnewStateCnt = 6;
 111    int i = 1;
 112    jjstateSet[0] = startState;
 113    int j, kind = 0x7fffffff;
 114    for (;;)
 115    {
 116       if (++jjround == 0x7fffffff)
 117          ReInitRounds();
 118       if (curChar < 64)
 119       {
 120          long l = 1L << curChar;
 121          MatchLoop: do
 122          {
 123             switch(jjstateSet[--i])
 124             {
 125                case 0:
 126                   if (curChar == 60)
 127                      jjAddStates(0, 1);
 128                   break;
 129                case 4:
 130                   if (curChar == 63)
 131                      jjstateSet[jjnewStateCnt++] = 3;
 132                   break;
 133                case 5:
 134                   if (curChar == 63 && kind > 1)
 135                      kind = 1;
 136                   break;
 137                default : break;
 138             }
 139          } while(i != startsAt);
 140       }
 141       else if (curChar < 128)
 142       {
 143          long l = 1L << (curChar & 077);
 144          MatchLoop: do
 145          {
 146             switch(jjstateSet[--i])
 147             {
 148                case 1:
 149                   if ((0x1000000010000L & l) != 0L && kind > 1)
 150                      kind = 1;
 151                   break;
 152                case 2:
 153                   if ((0x10000000100L & l) != 0L)
 154                      jjstateSet[jjnewStateCnt++] = 1;
 155                   break;
 156                case 3:
 157                   if ((0x1000000010000L & l) != 0L)
 158                      jjstateSet[jjnewStateCnt++] = 2;
 159                   break;
 160                default : break;
 161             }
 162          } while(i != startsAt);
 163       }
 164       else
 165       {
 166          int i2 = (curChar & 0xff) >> 6;
 167          long l2 = 1L << (curChar & 077);
 168          MatchLoop: do
 169          {
 170             switch(jjstateSet[--i])
 171             {
 172                default : break;
 173             }
 174          } while(i != startsAt);
 175       }
 176       if (kind != 0x7fffffff)
 177       {
 178          jjmatchedKind = kind;
 179          jjmatchedPos = curPos;
 180          kind = 0x7fffffff;
 181       }
 182       ++curPos;
 183       if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
 184          return curPos;
 185       try { curChar = input_stream.readChar(); }
 186       catch(java.io.IOException e) { return curPos; }
 187    }
 188 }
 189 static private final int jjMoveStringLiteralDfa0_4()
 190 {
 191    switch(curChar)
 192    {
 193       case 42:
 194          return jjMoveStringLiteralDfa1_4(0x4000L);
 195       default :
 196          return 1;
 197    }
 198 }
 199 static private final int jjMoveStringLiteralDfa1_4(long active0)
 200 {
 201    try { curChar = input_stream.readChar(); }
 202    catch(java.io.IOException e) {
 203       return 1;
 204    }
 205    switch(curChar)
 206    {
 207       case 47:
 208          if ((active0 & 0x4000L) != 0L)
 209             return jjStopAtPos(1, 14);
 210          break;
 211       default :
 212          return 2;
 213    }
 214    return 2;
 215 }
 216 static private final int jjMoveStringLiteralDfa0_2()
 217 {
 218    return jjMoveNfa_2(0, 0);
 219 }
 220 static private final int jjMoveNfa_2(int startState, int curPos)
 221 {
 222    int[] nextStates;
 223    int startsAt = 0;
 224    jjnewStateCnt = 5;
 225    int i = 1;
 226    jjstateSet[0] = startState;
 227    int j, kind = 0x7fffffff;
 228    for (;;)
 229    {
 230       if (++jjround == 0x7fffffff)
 231          ReInitRounds();
 232       if (curChar < 64)
 233       {
 234          long l = 1L << curChar;
 235          MatchLoop: do
 236          {
 237             switch(jjstateSet[--i])
 238             {
 239                case 0:
 240                   if ((0x2400L & l) != 0L)
 241                   {
 242                      if (kind > 12)
 243                         kind = 12;
 244                   }
 245                   else if (curChar == 63)
 246                      jjstateSet[jjnewStateCnt++] = 3;
 247                   if (curChar == 13)
 248                      jjstateSet[jjnewStateCnt++] = 1;
 249                   break;
 250                case 1:
 251                   if (curChar == 10 && kind > 12)
 252                      kind = 12;
 253                   break;
 254                case 2:
 255                   if (curChar == 13)
 256                      jjstateSet[jjnewStateCnt++] = 1;
 257                   break;
 258                case 3:
 259                   if (curChar == 62)
 260                      kind = 12;
 261                   break;
 262                case 4:
 263                   if (curChar == 63)
 264                      jjstateSet[jjnewStateCnt++] = 3;
 265                   break;
 266                default : break;
 267             }
 268          } while(i != startsAt);
 269       }
 270       else if (curChar < 128)
 271       {
 272          long l = 1L << (curChar & 077);
 273          MatchLoop: do
 274          {
 275             switch(jjstateSet[--i])
 276             {
 277                default : break;
 278             }
 279          } while(i != startsAt);
 280       }
 281       else
 282       {
 283          int i2 = (curChar & 0xff) >> 6;
 284          long l2 = 1L << (curChar & 077);
 285          MatchLoop: do
 286          {
 287             switch(jjstateSet[--i])
 288             {
 289                default : break;
 290             }
 291          } while(i != startsAt);
 292       }
 293       if (kind != 0x7fffffff)
 294       {
 295          jjmatchedKind = kind;
 296          jjmatchedPos = curPos;
 297          kind = 0x7fffffff;
 298       }
 299       ++curPos;
 300       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
 301          return curPos;
 302       try { curChar = input_stream.readChar(); }
 303       catch(java.io.IOException e) { return curPos; }
 304    }
 305 }
 306 private static final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
 307 {
 308    switch (pos)
 309    {
 310       case 0:
 311          if ((active0 & 0xfffffffc7fff0000L) != 0L)
 312          {
 313             jjmatchedKind = 74;
 314             return 14;
 315          }
 316          if ((active0 & 0xa00L) != 0L || (active1 & 0x20040000000000L) != 0L)
 317             return 2;
 318          if ((active1 & 0x1000000L) != 0L)
 319             return 16;
 320          if ((active1 & 0x200000000400000L) != 0L)
 321             return 8;
 322          return -1;
 323       case 1:
 324          if ((active0 & 0x800L) != 0L)
 325             return 0;
 326          if ((active0 & 0x4400008000080000L) != 0L)
 327             return 14;
 328          if ((active0 & 0xbbffff7c7ff70000L) != 0L)
 329          {
 330             if (jjmatchedPos != 1)
 331             {
 332                jjmatchedKind = 74;
 333                jjmatchedPos = 1;
 334             }
 335             return 14;
 336          }
 337          return -1;
 338       case 2:
 339          if ((active0 & 0xb000140000040000L) != 0L)
 340             return 14;
 341          if ((active0 & 0xfffeb7c7ff30000L) != 0L)
 342          {
 343             if (jjmatchedPos != 2)
 344             {
 345                jjmatchedKind = 74;
 346                jjmatchedPos = 2;
 347             }
 348             return 14;
 349          }
 350          return -1;
 351       case 3:
 352          if ((active0 & 0x2c79c3747ec30000L) != 0L)
 353          {
 354             if (jjmatchedPos != 3)
 355             {
 356                jjmatchedKind = 74;
 357                jjmatchedPos = 3;
 358             }
 359             return 14;
 360          }
 361          if ((active0 & 0x386280801300000L) != 0L)
 362             return 14;
 363          return -1;
 364       case 4:
 365          if ((active0 & 0x808821400c10000L) != 0L)
 366             return 14;
 367          if ((active0 & 0x257141607e120000L) != 0L)
 368          {
 369             jjmatchedKind = 74;
 370             jjmatchedPos = 4;
 371             return 14;
 372          }
 373          return -1;
 374       case 5:
 375          if ((active0 & 0x461400060100000L) != 0L)
 376             return 14;
 377          if ((active0 & 0x211001601e020000L) != 0L)
 378          {
 379             jjmatchedKind = 74;
 380             jjmatchedPos = 5;
 381             return 14;
 382          }
 383          return -1;
 384       case 6:
 385          if ((active0 & 0x210001401e000000L) != 0L)
 386             return 14;
 387          if ((active0 & 0x10002000020000L) != 0L)
 388          {
 389             if (jjmatchedPos != 6)
 390             {
 391                jjmatchedKind = 74;
 392                jjmatchedPos = 6;
 393             }
 394             return 14;
 395          }
 396          return -1;
 397       case 7:
 398          if ((active0 & 0x10002000020000L) != 0L)
 399             return 14;
 400          if ((active0 & 0x18000000L) != 0L)
 401          {
 402             jjmatchedKind = 74;
 403             jjmatchedPos = 7;
 404             return 14;
 405          }
 406          return -1;
 407       case 8:
 408          if ((active0 & 0x18000000L) != 0L)
 409          {
 410             jjmatchedKind = 74;
 411             jjmatchedPos = 8;
 412             return 14;
 413          }
 414          return -1;
 415       case 9:
 416          if ((active0 & 0x18000000L) != 0L)
 417          {
 418             jjmatchedKind = 74;
 419             jjmatchedPos = 9;
 420             return 14;
 421          }
 422          return -1;
 423       case 10:
 424          if ((active0 & 0x18000000L) != 0L)
 425          {
 426             jjmatchedKind = 74;
 427             jjmatchedPos = 10;
 428             return 14;
 429          }
 430          return -1;
 431       default :
 432          return -1;
 433    }
 434 }
 435 private static final int jjStartNfa_1(int pos, long active0, long active1)
 436 {
 437    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
 438 }
 439 static private final int jjStartNfaWithStates_1(int pos, int kind, int state)
 440 {
 441    jjmatchedKind = kind;
 442    jjmatchedPos = pos;
 443    try { curChar = input_stream.readChar(); }
 444    catch(java.io.IOException e) { return pos + 1; }
 445    return jjMoveNfa_1(state, pos + 1);
 446 }
 447 static private final int jjMoveStringLiteralDfa0_1()
 448 {
 449    switch(curChar)
 450    {
 451       case 33:
 452          jjmatchedKind = 92;
 453          return jjMoveStringLiteralDfa1_1(0x0L, 0x400000000L);
 454       case 36:
 455          return jjStartNfaWithStates_1(0, 88, 16);
 456       case 37:
 457          jjmatchedKind = 110;
 458          return jjMoveStringLiteralDfa1_1(0x0L, 0x400000000000000L);
 459       case 38:
 460          jjmatchedKind = 107;
 461          return jjMoveStringLiteralDfa1_1(0x0L, 0x40001000000000L);
 462       case 40:
 463          return jjStopAtPos(0, 78);
 464       case 41:
 465          return jjStopAtPos(0, 79);
 466       case 42:
 467          jjmatchedKind = 105;
 468          return jjMoveStringLiteralDfa1_1(0x0L, 0x10000000000000L);
 469       case 43:
 470          jjmatchedKind = 103;
 471          return jjMoveStringLiteralDfa1_1(0x0L, 0x4002000000000L);
 472       case 44:
 473          return jjStopAtPos(0, 85);
 474       case 45:
 475          jjmatchedKind = 104;
 476          return jjMoveStringLiteralDfa1_1(0x80000000L, 0x8004000000000L);
 477       case 46:
 478          jjmatchedKind = 86;
 479          return jjMoveStringLiteralDfa1_1(0x0L, 0x200000000000000L);
 480       case 47:
 481          jjmatchedKind = 106;
 482          return jjMoveStringLiteralDfa1_1(0xa00L, 0x20000000000000L);
 483       case 58:
 484          jjmatchedKind = 94;
 485          return jjMoveStringLiteralDfa1_1(0x100000000L, 0x0L);
 486       case 59:
 487          return jjStopAtPos(0, 84);
 488       case 60:
 489          jjmatchedKind = 91;
 490          return jjMoveStringLiteralDfa1_1(0x0L, 0x800800100000000L);
 491       case 61:
 492          jjmatchedKind = 89;
 493          return jjMoveStringLiteralDfa1_1(0x200000000L, 0x80000000L);
 494       case 62:
 495          jjmatchedKind = 90;
 496          return jjMoveStringLiteralDfa1_1(0x0L, 0x3003000200000000L);
 497       case 63:
 498          jjmatchedKind = 93;
 499          return jjMoveStringLiteralDfa1_1(0x4L, 0x0L);
 500       case 64:
 501          return jjStopAtPos(0, 87);
 502       case 91:
 503          return jjStopAtPos(0, 82);
 504       case 93:
 505          return jjStopAtPos(0, 83);
 506       case 94:
 507          jjmatchedKind = 109;
 508          return jjMoveStringLiteralDfa1_1(0x0L, 0x100000000000000L);
 509       case 65:
 510       case 97:
 511          return jjMoveStringLiteralDfa1_1(0x8000000000400000L, 0x0L);
 512       case 66:
 513       case 98:
 514          return jjMoveStringLiteralDfa1_1(0x180000400000000L, 0x0L);
 515       case 67:
 516       case 99:
 517          return jjMoveStringLiteralDfa1_1(0x3800010000L, 0x0L);
 518       case 68:
 519       case 100:
 520          return jjMoveStringLiteralDfa1_1(0x40000c000000000L, 0x0L);
 521       case 69:
 522       case 101:
 523          return jjMoveStringLiteralDfa1_1(0x10010001300000L, 0x0L);
 524       case 70:
 525       case 102:
 526          return jjMoveStringLiteralDfa1_1(0x800060000020000L, 0x0L);
 527       case 71:
 528       case 103:
 529          return jjMoveStringLiteralDfa1_1(0x80020000000L, 0x0L);
 530       case 73:
 531       case 105:
 532          return jjMoveStringLiteralDfa1_1(0x300000000a080000L, 0x0L);
 533       case 78:
 534       case 110:
 535          return jjMoveStringLiteralDfa1_1(0x300000000000L, 0x0L);
 536       case 79:
 537       case 111:
 538          return jjMoveStringLiteralDfa1_1(0x4040000000000000L, 0x0L);
 539       case 80:
 540       case 112:
 541          return jjMoveStringLiteralDfa1_1(0x800000L, 0x0L);
 542       case 82:
 543       case 114:
 544          return jjMoveStringLiteralDfa1_1(0x200400014000000L, 0x0L);
 545       case 83:
 546       case 115:
 547          return jjMoveStringLiteralDfa1_1(0x21800040000000L, 0x0L);
 548       case 84:
 549       case 116:
 550          return jjMoveStringLiteralDfa1_1(0x6000000000000L, 0x0L);
 551       case 86:
 552       case 118:
 553          return jjMoveStringLiteralDfa1_1(0x40000L, 0x0L);
 554       case 87:
 555       case 119:
 556          return jjMoveStringLiteralDfa1_1(0x8000000000000L, 0x0L);
 557       case 123:
 558          return jjStopAtPos(0, 80);
 559       case 124:
 560          jjmatchedKind = 108;
 561          return jjMoveStringLiteralDfa1_1(0x0L, 0x80000800000000L);
 562       case 125:
 563          return jjStopAtPos(0, 81);
 564       default :
 565          return jjMoveNfa_1(3, 0);
 566    }
 567 }
 568 static private final int jjMoveStringLiteralDfa1_1(long active0, long active1)
 569 {
 570    try { curChar = input_stream.readChar(); }
 571    catch(java.io.IOException e) {
 572       jjStopStringLiteralDfa_1(0, active0, active1);
 573       return 1;
 574    }
 575    switch(curChar)
 576    {
 577       case 38:
 578          if ((active1 & 0x1000000000L) != 0L)
 579             return jjStopAtPos(1, 100);
 580          break;
 581       case 42:
 582          if ((active0 & 0x800L) != 0L)
 583             return jjStartNfaWithStates_1(1, 11, 0);
 584          break;
 585       case 43:
 586          if ((active1 & 0x2000000000L) != 0L)
 587             return jjStopAtPos(1, 101);
 588          break;
 589       case 45:
 590          if ((active1 & 0x4000000000L) != 0L)
 591             return jjStopAtPos(1, 102);
 592          break;
 593       case 47:
 594          if ((active0 & 0x200L) != 0L)
 595             return jjStopAtPos(1, 9);
 596          break;
 597       case 58:
 598          if ((active0 & 0x100000000L) != 0L)
 599             return jjStopAtPos(1, 32);
 600          break;
 601       case 60:
 602          if ((active1 & 0x800000000000L) != 0L)
 603          {
 604             jjmatchedKind = 111;
 605             jjmatchedPos = 1;
 606          }
 607          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x800000000000000L);
 608       case 61:
 609          if ((active1 & 0x80000000L) != 0L)
 610             return jjStopAtPos(1, 95);
 611          else if ((active1 & 0x100000000L) != 0L)
 612             return jjStopAtPos(1, 96);
 613          else if ((active1 & 0x200000000L) != 0L)
 614             return jjStopAtPos(1, 97);
 615          else if ((active1 & 0x400000000L) != 0L)
 616             return jjStopAtPos(1, 98);
 617          else if ((active1 & 0x4000000000000L) != 0L)
 618             return jjStopAtPos(1, 114);
 619          else if ((active1 & 0x8000000000000L) != 0L)
 620             return jjStopAtPos(1, 115);
 621          else if ((active1 & 0x10000000000000L) != 0L)
 622             return jjStopAtPos(1, 116);
 623          else if ((active1 & 0x20000000000000L) != 0L)
 624             return jjStopAtPos(1, 117);
 625          else if ((active1 & 0x40000000000000L) != 0L)
 626             return jjStopAtPos(1, 118);
 627          else if ((active1 & 0x80000000000000L) != 0L)
 628             return jjStopAtPos(1, 119);
 629          else if ((active1 & 0x100000000000000L) != 0L)
 630             return jjStopAtPos(1, 120);
 631          else if ((active1 & 0x200000000000000L) != 0L)
 632             return jjStopAtPos(1, 121);
 633          else if ((active1 & 0x400000000000000L) != 0L)
 634             return jjStopAtPos(1, 122);
 635          break;
 636       case 62:
 637          if ((active0 & 0x4L) != 0L)
 638             return jjStopAtPos(1, 2);
 639          else if ((active0 & 0x80000000L) != 0L)
 640             return jjStopAtPos(1, 31);
 641          else if ((active0 & 0x200000000L) != 0L)
 642             return jjStopAtPos(1, 33);
 643          else if ((active1 & 0x1000000000000L) != 0L)
 644          {
 645             jjmatchedKind = 112;
 646             jjmatchedPos = 1;
 647          }
 648          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x3002000000000000L);
 649       case 65:
 650       case 97:
 651          return jjMoveStringLiteralDfa2_1(active0, 0x20800040000L, active1, 0L);
 652       case 66:
 653       case 98:
 654          return jjMoveStringLiteralDfa2_1(active0, 0x40000000000000L, active1, 0L);
 655       case 67:
 656       case 99:
 657          return jjMoveStringLiteralDfa2_1(active0, 0x1000000L, active1, 0L);
 658       case 69:
 659       case 101:
 660          return jjMoveStringLiteralDfa2_1(active0, 0x200504014000000L, active1, 0L);
 661       case 70:
 662       case 102:
 663          if ((active0 & 0x80000L) != 0L)
 664             return jjStartNfaWithStates_1(1, 19, 14);
 665          break;
 666       case 72:
 667       case 104:
 668          return jjMoveStringLiteralDfa2_1(active0, 0xa000000000000L, active1, 0L);
 669       case 76:
 670       case 108:
 671          return jjMoveStringLiteralDfa2_1(active0, 0x800000020310000L, active1, 0L);
 672       case 78:
 673       case 110:
 674          return jjMoveStringLiteralDfa2_1(active0, 0xb01000000a000000L, active1, 0L);
 675       case 79:
 676       case 111:
 677          if ((active0 & 0x8000000000L) != 0L)
 678          {
 679             jjmatchedKind = 39;
 680             jjmatchedPos = 1;
 681          }
 682          return jjMoveStringLiteralDfa2_1(active0, 0x5800c3000000000L, active1, 0L);
 683       case 82:
 684       case 114:
 685          if ((active0 & 0x4000000000000000L) != 0L)
 686             return jjStartNfaWithStates_1(1, 62, 14);
 687          return jjMoveStringLiteralDfa2_1(active0, 0x4000400c00000L, active1, 0L);
 688       case 84:
 689       case 116:
 690          return jjMoveStringLiteralDfa2_1(active0, 0x20000040000000L, active1, 0L);
 691       case 85:
 692       case 117:
 693          return jjMoveStringLiteralDfa2_1(active0, 0xa00000020000L, active1, 0L);
 694       case 87:
 695       case 119:
 696          return jjMoveStringLiteralDfa2_1(active0, 0x1000000000000L, active1, 0L);
 697       case 88:
 698       case 120:
 699          return jjMoveStringLiteralDfa2_1(active0, 0x10000000000L, active1, 0L);
 700       case 124:
 701          if ((active1 & 0x800000000L) != 0L)
 702             return jjStopAtPos(1, 99);
 703          break;
 704       default :
 705          break;
 706    }
 707    return jjStartNfa_1(0, active0, active1);
 708 }
 709 static private final int jjMoveStringLiteralDfa2_1(long old0, long active0, long old1, long active1)
 710 {
 711    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 712       return jjStartNfa_1(0, old0, old1);
 713    try { curChar = input_stream.readChar(); }
 714    catch(java.io.IOException e) {
 715       jjStopStringLiteralDfa_1(1, active0, active1);
 716       return 2;
 717    }
 718    switch(curChar)
 719    {
 720       case 61:
 721          if ((active1 & 0x800000000000000L) != 0L)
 722             return jjStopAtPos(2, 123);
 723          else if ((active1 & 0x1000000000000000L) != 0L)
 724             return jjStopAtPos(2, 124);
 725          break;
 726       case 62:
 727          if ((active1 & 0x2000000000000L) != 0L)
 728          {
 729             jjmatchedKind = 113;
 730             jjmatchedPos = 2;
 731          }
 732          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x2000000000000000L);
 733       case 65:
 734       case 97:
 735          return jjMoveStringLiteralDfa3_1(active0, 0x200000040010000L, active1, 0L);
 736       case 67:
 737       case 99:
 738          return jjMoveStringLiteralDfa3_1(active0, 0xa000000L, active1, 0L);
 739       case 68:
 740       case 100:
 741          if ((active0 & 0x8000000000000000L) != 0L)
 742             return jjStartNfaWithStates_1(2, 63, 14);
 743          return jjMoveStringLiteralDfa3_1(active0, 0x10000000000000L, active1, 0L);
 744       case 69:
 745       case 101:
 746          return jjMoveStringLiteralDfa3_1(active0, 0x400000000L, active1, 0L);
 747       case 70:
 748       case 102:
 749          return jjMoveStringLiteralDfa3_1(active0, 0x4000000000L, active1, 0L);
 750       case 72:
 751       case 104:
 752          return jjMoveStringLiteralDfa3_1(active0, 0x1000000L, active1, 0L);
 753       case 73:
 754       case 105:
 755          return jjMoveStringLiteralDfa3_1(active0, 0xb000000800000L, active1, 0L);
 756       case 74:
 757       case 106:
 758          return jjMoveStringLiteralDfa3_1(active0, 0x40000000000000L, active1, 0L);
 759       case 76:
 760       case 108:
 761          return jjMoveStringLiteralDfa3_1(active0, 0x220000000000L, active1, 0L);
 762       case 78:
 763       case 110:
 764          return jjMoveStringLiteralDfa3_1(active0, 0x3000020000L, active1, 0L);
 765       case 79:
 766       case 111:
 767          return jjMoveStringLiteralDfa3_1(active0, 0x980000020000000L, active1, 0L);
 768       case 80:
 769       case 112:
 770          return jjMoveStringLiteralDfa3_1(active0, 0x800000000000L, active1, 0L);
 771       case 81:
 772       case 113:
 773          return jjMoveStringLiteralDfa3_1(active0, 0x14000000L, active1, 0L);
 774       case 82:
 775       case 114:
 776          if ((active0 & 0x40000L) != 0L)
 777             return jjStartNfaWithStates_1(2, 18, 14);
 778          else if ((active0 & 0x40000000000L) != 0L)
 779             return jjStartNfaWithStates_1(2, 42, 14);
 780          return jjMoveStringLiteralDfa3_1(active0, 0x20000000400000L, active1, 0L);
 781       case 83:
 782       case 115:
 783          return jjMoveStringLiteralDfa3_1(active0, 0x800300000L, active1, 0L);
 784       case 84:
 785       case 116:
 786          if ((active0 & 0x1000000000000000L) != 0L)
 787          {
 788             jjmatchedKind = 60;
 789             jjmatchedPos = 2;
 790          }
 791          return jjMoveStringLiteralDfa3_1(active0, 0x2000490000000000L, active1, 0L);
 792       case 85:
 793       case 117:
 794          return jjMoveStringLiteralDfa3_1(active0, 0x404000000000000L, active1, 0L);
 795       case 87:
 796       case 119:
 797          if ((active0 & 0x100000000000L) != 0L)
 798             return jjStartNfaWithStates_1(2, 44, 14);
 799          break;
 800       default :
 801          break;
 802    }
 803    return jjStartNfa_1(1, active0, active1);
 804 }
 805 static private final int jjMoveStringLiteralDfa3_1(long old0, long active0, long old1, long active1)
 806 {
 807    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 808       return jjStartNfa_1(1, old0, old1);
 809    try { curChar = input_stream.readChar(); }
 810    catch(java.io.IOException e) {
 811       jjStopStringLiteralDfa_1(2, active0, active1);
 812       return 3;
 813    }
 814    switch(curChar)
 815    {
 816       case 61:
 817          if ((active1 & 0x2000000000000000L) != 0L)
 818             return jjStopAtPos(3, 125);
 819          break;
 820       case 65:
 821       case 97:
 822          return jjMoveStringLiteralDfa4_1(active0, 0x800004400400000L, active1, 0L);
 823       case 66:
 824       case 98:
 825          return jjMoveStringLiteralDfa4_1(active0, 0x400000020000000L, active1, 0L);
 826       case 67:
 827       case 99:
 828          return jjMoveStringLiteralDfa4_1(active0, 0x20000L, active1, 0L);
 829       case 69:
 830       case 101:
 831          if ((active0 & 0x200000L) != 0L)
 832          {
 833             jjmatchedKind = 21;
 834             jjmatchedPos = 3;
 835          }
 836          else if ((active0 & 0x800000000L) != 0L)
 837             return jjStartNfaWithStates_1(3, 35, 14);
 838          else if ((active0 & 0x4000000000000L) != 0L)
 839             return jjStartNfaWithStates_1(3, 50, 14);
 840          return jjMoveStringLiteralDfa4_1(active0, 0x2040810000100000L, active1, 0L);
 841       case 73:
 842       case 105:
 843          return jjMoveStringLiteralDfa4_1(active0, 0x20000000000000L, active1, 0L);
 844       case 76:
 845       case 108:
 846          if ((active0 & 0x200000000000L) != 0L)
 847             return jjStartNfaWithStates_1(3, 45, 14);
 848          else if ((active0 & 0x80000000000000L) != 0L)
 849          {
 850             jjmatchedKind = 55;
 851             jjmatchedPos = 3;
 852          }
 853          else if ((active0 & 0x200000000000000L) != 0L)
 854             return jjStartNfaWithStates_1(3, 57, 14);
 855          return jjMoveStringLiteralDfa4_1(active0, 0x10800000a000000L, active1, 0L);
 856       case 78:
 857       case 110:
 858          return jjMoveStringLiteralDfa4_1(active0, 0x800000L, active1, 0L);
 859       case 79:
 860       case 111:
 861          if ((active0 & 0x1000000L) != 0L)
 862             return jjStartNfaWithStates_1(3, 24, 14);
 863          else if ((active0 & 0x80000000000L) != 0L)
 864             return jjStartNfaWithStates_1(3, 43, 14);
 865          break;
 866       case 83:
 867       case 115:
 868          if ((active0 & 0x2000000000000L) != 0L)
 869             return jjStartNfaWithStates_1(3, 49, 14);
 870          return jjMoveStringLiteralDfa4_1(active0, 0x21000010000L, active1, 0L);
 871       case 84:
 872       case 116:
 873          return jjMoveStringLiteralDfa4_1(active0, 0x1002040000000L, active1, 0L);
 874       case 85:
 875       case 117:
 876          return jjMoveStringLiteralDfa4_1(active0, 0x400014000000L, active1, 0L);
 877       case 87:
 878       case 119:
 879          return jjMoveStringLiteralDfa4_1(active0, 0x10000000000000L, active1, 0L);
 880       default :
 881          break;
 882    }
 883    return jjStartNfa_1(2, active0, active1);
 884 }
 885 static private final int jjMoveStringLiteralDfa4_1(long old0, long active0, long old1, long active1)
 886 {
 887    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 888       return jjStartNfa_1(2, old0, old1);
 889    try { curChar = input_stream.readChar(); }
 890    catch(java.io.IOException e) {
 891       jjStopStringLiteralDfa_1(3, active0, 0L);
 892       return 4;
 893    }
 894    switch(curChar)
 895    {
 896       case 65:
 897       case 97:
 898          return jjMoveStringLiteralDfa5_1(active0, 0x20000000L);
 899       case 67:
 900       case 99:
 901          return jjMoveStringLiteralDfa5_1(active0, 0x41000000000000L);
 902       case 69:
 903       case 101:
 904          if ((active0 & 0x20000000000L) != 0L)
 905             return jjStartNfaWithStates_1(4, 41, 14);
 906          else if ((active0 & 0x8000000000000L) != 0L)
 907             return jjStartNfaWithStates_1(4, 51, 14);
 908          return jjMoveStringLiteralDfa5_1(active0, 0x100000000000000L);
 909       case 71:
 910       case 103:
 911          return jjMoveStringLiteralDfa5_1(active0, 0x2000000000000000L);
 912       case 72:
 913       case 104:
 914          return jjMoveStringLiteralDfa5_1(active0, 0x10000000000000L);
 915       case 73:
 916       case 105:
 917          return jjMoveStringLiteralDfa5_1(active0, 0x2054100000L);
 918       case 75:
 919       case 107:
 920          if ((active0 & 0x400000000L) != 0L)
 921             return jjStartNfaWithStates_1(4, 34, 14);
 922          break;
 923       case 76:
 924       case 108:
 925          return jjMoveStringLiteralDfa5_1(active0, 0x400000000000000L);
 926       case 78:
 927       case 110:
 928          return jjMoveStringLiteralDfa5_1(active0, 0x20010000000000L);
 929       case 82:
 930       case 114:
 931          if ((active0 & 0x800000000000L) != 0L)
 932             return jjStartNfaWithStates_1(4, 47, 14);
 933          return jjMoveStringLiteralDfa5_1(active0, 0x400000000000L);
 934       case 83:
 935       case 115:
 936          if ((active0 & 0x10000L) != 0L)
 937             return jjStartNfaWithStates_1(4, 16, 14);
 938          break;
 939       case 84:
 940       case 116:
 941          if ((active0 & 0x800000L) != 0L)
 942             return jjStartNfaWithStates_1(4, 23, 14);
 943          else if ((active0 & 0x1000000000L) != 0L)
 944             return jjStartNfaWithStates_1(4, 36, 14);
 945          else if ((active0 & 0x800000000000000L) != 0L)
 946             return jjStartNfaWithStates_1(4, 59, 14);
 947          return jjMoveStringLiteralDfa5_1(active0, 0x20000L);
 948       case 85:
 949       case 117:
 950          return jjMoveStringLiteralDfa5_1(active0, 0x400a000000L);
 951       case 89:
 952       case 121:
 953          if ((active0 & 0x400000L) != 0L)
 954             return jjStartNfaWithStates_1(4, 22, 14);
 955          break;
 956       default :
 957          break;
 958    }
 959    return jjStartNfa_1(3, active0, 0L);
 960 }
 961 static private final int jjMoveStringLiteralDfa5_1(long old0, long active0)
 962 {
 963    if (((active0 &= old0)) == 0L)
 964       return jjStartNfa_1(3, old0, 0L);
 965    try { curChar = input_stream.readChar(); }
 966    catch(java.io.IOException e) {
 967       jjStopStringLiteralDfa_1(4, active0, 0L);
 968       return 5;
 969    }
 970    switch(curChar)
 971    {
 972       case 65:
 973       case 97:
 974          return jjMoveStringLiteralDfa6_1(active0, 0x100000000000000L);
 975       case 67:
 976       case 99:
 977          if ((active0 & 0x40000000L) != 0L)
 978             return jjStartNfaWithStates_1(5, 30, 14);
 979          break;
 980       case 68:
 981       case 100:
 982          return jjMoveStringLiteralDfa6_1(active0, 0x1000a000000L);
 983       case 69:
 984       case 101:
 985          if ((active0 & 0x400000000000000L) != 0L)
 986             return jjStartNfaWithStates_1(5, 58, 14);
 987          return jjMoveStringLiteralDfa6_1(active0, 0x2000000000000000L);
 988       case 70:
 989       case 102:
 990          if ((active0 & 0x100000L) != 0L)
 991             return jjStartNfaWithStates_1(5, 20, 14);
 992          break;
 993       case 71:
 994       case 103:
 995          if ((active0 & 0x20000000000000L) != 0L)
 996             return jjStartNfaWithStates_1(5, 53, 14);
 997          break;
 998       case 72:
 999       case 104:
1000          if ((active0 & 0x1000000000000L) != 0L)
1001             return jjStartNfaWithStates_1(5, 48, 14);
1002          break;
1003       case 73:
1004       case 105:
1005          return jjMoveStringLiteralDfa6_1(active0, 0x10000000020000L);
1006       case 76:
1007       case 108:
1008          if ((active0 & 0x20000000L) != 0L)
1009             return jjStartNfaWithStates_1(5, 29, 14);
1010          return jjMoveStringLiteralDfa6_1(active0, 0x4000000000L);
1011       case 78:
1012       case 110:
1013          if ((active0 & 0x400000000000L) != 0L)
1014             return jjStartNfaWithStates_1(5, 46, 14);
1015          return jjMoveStringLiteralDfa6_1(active0, 0x2000000000L);
1016       case 82:
1017       case 114:
1018          return jjMoveStringLiteralDfa6_1(active0, 0x14000000L);
1019       case 84:
1020       case 116:
1021          if ((active0 & 0x40000000000000L) != 0L)
1022             return jjStartNfaWithStates_1(5, 54, 14);
1023          break;
1024       default :
1025          break;
1026    }
1027    return jjStartNfa_1(4, active0, 0L);
1028 }
1029 static private final int jjMoveStringLiteralDfa6_1(long old0, long active0)
1030 {
1031    if (((active0 &= old0)) == 0L)
1032       return jjStartNfa_1(4, old0, 0L);
1033    try { curChar = input_stream.readChar(); }
1034    catch(java.io.IOException e) {
1035       jjStopStringLiteralDfa_1(5, active0, 0L);
1036       return 6;
1037    }
1038    switch(curChar)
1039    {
1040       case 69:
1041       case 101:
1042          if ((active0 & 0x2000000L) != 0L)
1043          {
1044             jjmatchedKind = 25;
1045             jjmatchedPos = 6;
1046          }
1047          else if ((active0 & 0x4000000L) != 0L)
1048          {
1049             jjmatchedKind = 26;
1050             jjmatchedPos = 6;
1051          }
1052          return jjMoveStringLiteralDfa7_1(active0, 0x18000000L);
1053       case 76:
1054       case 108:
1055          return jjMoveStringLiteralDfa7_1(active0, 0x10000000000000L);
1056       case 78:
1057       case 110:
1058          if ((active0 & 0x100000000000000L) != 0L)
1059             return jjStartNfaWithStates_1(6, 56, 14);
1060          break;
1061       case 79:
1062       case 111:
1063          return jjMoveStringLiteralDfa7_1(active0, 0x20000L);
1064       case 82:
1065       case 114:
1066          if ((active0 & 0x2000000000000000L) != 0L)
1067             return jjStartNfaWithStates_1(6, 61, 14);
1068          break;
1069       case 83:
1070       case 115:
1071          if ((active0 & 0x10000000000L) != 0L)
1072             return jjStartNfaWithStates_1(6, 40, 14);
1073          break;
1074       case 84:
1075       case 116:
1076          if ((active0 & 0x4000000000L) != 0L)
1077             return jjStartNfaWithStates_1(6, 38, 14);
1078          break;
1079       case 85:
1080       case 117:
1081          return jjMoveStringLiteralDfa7_1(active0, 0x2000000000L);
1082       default :
1083          break;
1084    }
1085    return jjStartNfa_1(5, active0, 0L);
1086 }
1087 static private final int jjMoveStringLiteralDfa7_1(long old0, long active0)
1088 {
1089    if (((active0 &= old0)) == 0L)
1090       return jjStartNfa_1(5, old0, 0L);
1091    try { curChar = input_stream.readChar(); }
1092    catch(java.io.IOException e) {
1093       jjStopStringLiteralDfa_1(6, active0, 0L);
1094       return 7;
1095    }
1096    switch(curChar)
1097    {
1098       case 95:
1099          return jjMoveStringLiteralDfa8_1(active0, 0x18000000L);
1100       case 69:
1101       case 101:
1102          if ((active0 & 0x2000000000L) != 0L)
1103             return jjStartNfaWithStates_1(7, 37, 14);
1104          else if ((active0 & 0x10000000000000L) != 0L)
1105             return jjStartNfaWithStates_1(7, 52, 14);
1106          break;
1107       case 78:
1108       case 110:
1109          if ((active0 & 0x20000L) != 0L)
1110             return jjStartNfaWithStates_1(7, 17, 14);
1111          break;
1112       default :
1113          break;
1114    }
1115    return jjStartNfa_1(6, active0, 0L);
1116 }
1117 static private final int jjMoveStringLiteralDfa8_1(long old0, long active0)
1118 {
1119    if (((active0 &= old0)) == 0L)
1120       return jjStartNfa_1(6, old0, 0L);
1121    try { curChar = input_stream.readChar(); }
1122    catch(java.io.IOException e) {
1123       jjStopStringLiteralDfa_1(7, active0, 0L);
1124       return 8;
1125    }
1126    switch(curChar)
1127    {
1128       case 79:
1129       case 111:
1130          return jjMoveStringLiteralDfa9_1(active0, 0x18000000L);
1131       default :
1132          break;
1133    }
1134    return jjStartNfa_1(7, active0, 0L);
1135 }
1136 static private final int jjMoveStringLiteralDfa9_1(long old0, long active0)
1137 {
1138    if (((active0 &= old0)) == 0L)
1139       return jjStartNfa_1(7, old0, 0L);
1140    try { curChar = input_stream.readChar(); }
1141    catch(java.io.IOException e) {
1142       jjStopStringLiteralDfa_1(8, active0, 0L);
1143       return 9;
1144    }
1145    switch(curChar)
1146    {
1147       case 78:
1148       case 110:
1149          return jjMoveStringLiteralDfa10_1(active0, 0x18000000L);
1150       default :
1151          break;
1152    }
1153    return jjStartNfa_1(8, active0, 0L);
1154 }
1155 static private final int jjMoveStringLiteralDfa10_1(long old0, long active0)
1156 {
1157    if (((active0 &= old0)) == 0L)
1158       return jjStartNfa_1(8, old0, 0L);
1159    try { curChar = input_stream.readChar(); }
1160    catch(java.io.IOException e) {
1161       jjStopStringLiteralDfa_1(9, active0, 0L);
1162       return 10;
1163    }
1164    switch(curChar)
1165    {
1166       case 67:
1167       case 99:
1168          return jjMoveStringLiteralDfa11_1(active0, 0x18000000L);
1169       default :
1170          break;
1171    }
1172    return jjStartNfa_1(9, active0, 0L);
1173 }
1174 static private final int jjMoveStringLiteralDfa11_1(long old0, long active0)
1175 {
1176    if (((active0 &= old0)) == 0L)
1177       return jjStartNfa_1(9, old0, 0L);
1178    try { curChar = input_stream.readChar(); }
1179    catch(java.io.IOException e) {
1180       jjStopStringLiteralDfa_1(10, active0, 0L);
1181       return 11;
1182    }
1183    switch(curChar)
1184    {
1185       case 69:
1186       case 101:
1187          if ((active0 & 0x8000000L) != 0L)
1188             return jjStartNfaWithStates_1(11, 27, 14);
1189          else if ((active0 & 0x10000000L) != 0L)
1190             return jjStartNfaWithStates_1(11, 28, 14);
1191          break;
1192       default :
1193          break;
1194    }
1195    return jjStartNfa_1(10, active0, 0L);
1196 }
1197 static final long[] jjbitVec0 = {
1198    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
1199 };
1200 static private final int jjMoveNfa_1(int startState, int curPos)
1201 {
1202    int[] nextStates;
1203    int startsAt = 0;
1204    jjnewStateCnt = 56;
1205    int i = 1;
1206    jjstateSet[0] = startState;
1207    int j, kind = 0x7fffffff;
1208    for (;;)
1209    {
1210       if (++jjround == 0x7fffffff)
1211          ReInitRounds();
1212       if (curChar < 64)
1213       {
1214          long l = 1L << curChar;
1215          MatchLoop: do
1216          {
1217             switch(jjstateSet[--i])
1218             {
1219                case 3:
1220                   if ((0x3ff000000000000L & l) != 0L)
1221                      jjCheckNAddStates(2, 8);
1222                   else if (curChar == 39)
1223                      jjCheckNAddStates(9, 12);
1224                   else if (curChar == 34)
1225                      jjCheckNAddStates(13, 18);
1226                   else if (curChar == 36)
1227                      jjstateSet[jjnewStateCnt++] = 16;
1228                   else if (curChar == 46)
1229                      jjCheckNAdd(8);
1230                   else if (curChar == 47)
1231                      jjstateSet[jjnewStateCnt++] = 2;
1232                   if ((0x3fe000000000000L & l) != 0L)
1233                   {
1234                      if (kind > 64)
1235                         kind = 64;
1236                      jjCheckNAddTwoStates(5, 6);
1237                   }
1238                   else if (curChar == 48)
1239                   {
1240                      if (kind > 64)
1241                         kind = 64;
1242                      jjCheckNAddStates(19, 21);
1243                   }
1244                   break;
1245                case 0:
1246                   if (curChar == 42)
1247                      jjstateSet[jjnewStateCnt++] = 1;
1248                   break;
1249                case 1:
1250                   if ((0xffff7fffffffffffL & l) != 0L && kind > 10)
1251                      kind = 10;
1252                   break;
1253                case 2:
1254                   if (curChar == 42)
1255                      jjstateSet[jjnewStateCnt++] = 0;
1256                   break;
1257                case 4:
1258                   if ((0x3fe000000000000L & l) == 0L)
1259                      break;
1260                   if (kind > 64)
1261                      kind = 64;
1262                   jjCheckNAddTwoStates(5, 6);
1263                   break;
1264                case 5:
1265                   if ((0x3ff000000000000L & l) == 0L)
1266                      break;
1267                   if (kind > 64)
1268                      kind = 64;
1269                   jjCheckNAddTwoStates(5, 6);
1270                   break;
1271                case 7:
1272                   if (curChar == 46)
1273                      jjCheckNAdd(8);
1274                   break;
1275                case 8:
1276                   if ((0x3ff000000000000L & l) == 0L)
1277                      break;
1278                   if (kind > 68)
1279                      kind = 68;
1280                   jjCheckNAddStates(22, 24);
1281                   break;
1282                case 10:
1283                   if ((0x280000000000L & l) != 0L)
1284                      jjCheckNAdd(11);
1285                   break;
1286                case 11:
1287                   if ((0x3ff000000000000L & l) == 0L)
1288                      break;
1289                   if (kind > 68)
1290                      kind = 68;
1291                   jjCheckNAddTwoStates(11, 12);
1292                   break;
1293                case 14:
1294                   if ((0x3ff000000000000L & l) == 0L)
1295                      break;
1296                   if (kind > 74)
1297                      kind = 74;
1298                   jjstateSet[jjnewStateCnt++] = 14;
1299                   break;
1300                case 15:
1301                   if (curChar == 36)
1302                      jjstateSet[jjnewStateCnt++] = 16;
1303                   break;
1304                case 17:
1305                   if ((0x3ff000000000000L & l) == 0L)
1306                      break;
1307                   if (kind > 126)
1308                      kind = 126;
1309                   jjstateSet[jjnewStateCnt++] = 17;
1310                   break;
1311                case 18:
1312                   if ((0x3ff000000000000L & l) != 0L)
1313                      jjCheckNAddStates(2, 8);
1314                   break;
1315                case 19:
1316                   if ((0x3ff000000000000L & l) != 0L)
1317                      jjCheckNAddTwoStates(19, 20);
1318                   break;
1319                case 20:
1320                   if (curChar != 46)
1321                      break;
1322                   if (kind > 68)
1323                      kind = 68;
1324                   jjCheckNAddStates(25, 27);
1325                   break;
1326                case 21:
1327                   if ((0x3ff000000000000L & l) == 0L)
1328                      break;
1329                   if (kind > 68)
1330                      kind = 68;
1331                   jjCheckNAddStates(25, 27);
1332                   break;
1333                case 23:
1334                   if ((0x280000000000L & l) != 0L)
1335                      jjCheckNAdd(24);
1336                   break;
1337                case 24:
1338                   if ((0x3ff000000000000L & l) == 0L)
1339                      break;
1340                   if (kind > 68)
1341                      kind = 68;
1342                   jjCheckNAddTwoStates(24, 12);
1343                   break;
1344                case 25:
1345                   if ((0x3ff000000000000L & l) != 0L)
1346                      jjCheckNAddTwoStates(25, 26);
1347                   break;
1348                case 27:
1349                   if ((0x280000000000L & l) != 0L)
1350                      jjCheckNAdd(28);
1351                   break;
1352                case 28:
1353                   if ((0x3ff000000000000L & l) == 0L)
1354                      break;
1355                   if (kind > 68)
1356                      kind = 68;
1357                   jjCheckNAddTwoStates(28, 12);
1358                   break;
1359                case 29:
1360                   if ((0x3ff000000000000L & l) != 0L)
1361                      jjCheckNAddStates(28, 30);
1362                   break;
1363                case 31:
1364                   if ((0x280000000000L & l) != 0L)
1365                      jjCheckNAdd(32);
1366                   break;
1367                case 32:
1368                   if ((0x3ff000000000000L & l) != 0L)
1369                      jjCheckNAddTwoStates(32, 12);
1370                   break;
1371                case 33:
1372                   if (curChar != 48)
1373                      break;
1374                   if (kind > 64)
1375                      kind = 64;
1376                   jjCheckNAddStates(19, 21);
1377                   break;
1378                case 35:
1379                   if ((0x3ff000000000000L & l) == 0L)
1380                      break;
1381                   if (kind > 64)
1382                      kind = 64;
1383                   jjCheckNAddTwoStates(35, 6);
1384                   break;
1385                case 36:
1386                   if ((0xff000000000000L & l) == 0L)
1387                      break;
1388                   if (kind > 64)
1389                      kind = 64;
1390                   jjCheckNAddTwoStates(36, 6);
1391                   break;
1392                case 37:
1393                   if (curChar == 34)
1394                      jjCheckNAddStates(13, 18);
1395                   break;
1396                case 38:
1397                   if ((0xfffffffbffffffffL & l) != 0L)
1398                      jjCheckNAddStates(31, 33);
1399                   break;
1400                case 39:
1401                   if (curChar == 34)
1402                      jjCheckNAddStates(31, 33);
1403                   break;
1404                case 41:
1405                   if (curChar == 34 && kind > 70)
1406                      kind = 70;
1407                   break;
1408                case 42:
1409                   if ((0xfffffffbffffffffL & l) != 0L)
1410                      jjCheckNAddStates(34, 36);
1411                   break;
1412                case 43:
1413                   if (curChar == 34)
1414                      jjCheckNAddStates(34, 36);
1415                   break;
1416                case 45:
1417                   if (curChar == 34 && kind > 71)
1418                      kind = 71;
1419                   break;
1420                case 46:
1421                   if (curChar == 39)
1422                      jjCheckNAddStates(9, 12);
1423                   break;
1424                case 47:
1425                   if ((0xffffff7fffffffffL & l) != 0L)
1426                      jjCheckNAddTwoStates(47, 48);
1427                   break;
1428                case 48:
1429                   if (curChar == 39 && kind > 70)
1430                      kind = 70;
1431                   break;
1432                case 49:
1433                   if ((0xffffff7fffffffffL & l) != 0L)
1434                      jjCheckNAddTwoStates(49, 50);
1435                   break;
1436                case 50:
1437                   if (curChar == 39 && kind > 72)
1438                      kind = 72;
1439                   break;
1440                case 52:
1441                   jjAddStates(37, 38);
1442                   break;
1443                case 54:
1444                   jjAddStates(39, 40);
1445                   break;
1446                default : break;
1447             }
1448          } while(i != startsAt);
1449       }
1450       else if (curChar < 128)
1451       {
1452          long l = 1L << (curChar & 077);
1453          MatchLoop: do
1454          {
1455             switch(jjstateSet[--i])
1456             {
1457                case 3:
1458                   if ((0x7fffffe87fffffeL & l) != 0L)
1459                   {
1460                      if (kind > 74)
1461                         kind = 74;
1462                      jjCheckNAdd(14);
1463                   }
1464                   else if (curChar == 96)
1465                      jjCheckNAddStates(41, 44);
1466                   break;
1467                case 1:
1468                   if (kind > 10)
1469                      kind = 10;
1470                   break;
1471                case 6:
1472                   if ((0x100000001000L & l) != 0L && kind > 64)
1473                      kind = 64;
1474                   break;
1475                case 9:
1476                   if ((0x2000000020L & l) != 0L)
1477                      jjAddStates(45, 46);
1478                   break;
1479                case 12:
1480                   if ((0x5000000050L & l) != 0L && kind > 68)
1481                      kind = 68;
1482                   break;
1483                case 13:
1484                case 14:
1485                   if ((0x7fffffe87fffffeL & l) == 0L)
1486                      break;
1487                   if (kind > 74)
1488                      kind = 74;
1489                   jjCheckNAdd(14);
1490                   break;
1491                case 16:
1492                case 17:
1493                   if ((0x7fffffe87fffffeL & l) == 0L)
1494                      break;
1495                   if (kind > 126)
1496                      kind = 126;
1497                   jjCheckNAdd(17);
1498                   break;
1499                case 22:
1500                   if ((0x2000000020L & l) != 0L)
1501                      jjAddStates(47, 48);
1502                   break;
1503                case 26:
1504                   if ((0x2000000020L & l) != 0L)
1505                      jjAddStates(49, 50);
1506                   break;
1507                case 30:
1508                   if ((0x2000000020L & l) != 0L)
1509                      jjAddStates(51, 52);
1510                   break;
1511                case 34:
1512                   if ((0x100000001000000L & l) != 0L)
1513                      jjCheckNAdd(35);
1514                   break;
1515                case 35:
1516                   if ((0x7e0000007eL & l) == 0L)
1517                      break;
1518                   if (kind > 64)
1519                      kind = 64;
1520                   jjCheckNAddTwoStates(35, 6);
1521                   break;
1522                case 38:
1523                   jjAddStates(31, 33);
1524                   break;
1525                case 40:
1526                   if (curChar == 92)
1527                      jjstateSet[jjnewStateCnt++] = 39;
1528                   break;
1529                case 42:
1530                   jjAddStates(34, 36);
1531                   break;
1532                case 44:
1533                   if (curChar == 92)
1534                      jjstateSet[jjnewStateCnt++] = 43;
1535                   break;
1536                case 47:
1537                   jjAddStates(53, 54);
1538                   break;
1539                case 49:
1540                   jjAddStates(55, 56);
1541                   break;
1542                case 51:
1543                   if (curChar == 96)
1544                      jjCheckNAddStates(41, 44);
1545                   break;
1546                case 52:
1547                   if ((0xfffffffeffffffffL & l) != 0L)
1548                      jjCheckNAddTwoStates(52, 53);
1549                   break;
1550                case 53:
1551                   if (curChar == 96 && kind > 70)
1552                      kind = 70;
1553                   break;
1554                case 54:
1555                   if ((0xfffffffeffffffffL & l) != 0L)
1556                      jjCheckNAddTwoStates(54, 55);
1557                   break;
1558                case 55:
1559                   if (curChar == 96 && kind > 73)
1560                      kind = 73;
1561                   break;
1562                default : break;
1563             }
1564          } while(i != startsAt);
1565       }
1566       else
1567       {
1568          int i2 = (curChar & 0xff) >> 6;
1569          long l2 = 1L << (curChar & 077);
1570          MatchLoop: do
1571          {
1572             switch(jjstateSet[--i])
1573             {
1574                case 1:
1575                   if ((jjbitVec0[i2] & l2) != 0L && kind > 10)
1576                      kind = 10;
1577                   break;
1578                case 38:
1579                   if ((jjbitVec0[i2] & l2) != 0L)
1580                      jjAddStates(31, 33);
1581                   break;
1582                case 42:
1583                   if ((jjbitVec0[i2] & l2) != 0L)
1584                      jjAddStates(34, 36);
1585                   break;
1586                case 47:
1587                   if ((jjbitVec0[i2] & l2) != 0L)
1588                      jjAddStates(53, 54);
1589                   break;
1590                case 49:
1591                   if ((jjbitVec0[i2] & l2) != 0L)
1592                      jjAddStates(55, 56);
1593                   break;
1594                case 52:
1595                   if ((jjbitVec0[i2] & l2) != 0L)
1596                      jjAddStates(37, 38);
1597                   break;
1598                case 54:
1599                   if ((jjbitVec0[i2] & l2) != 0L)
1600                      jjAddStates(39, 40);
1601                   break;
1602                default : break;
1603             }
1604          } while(i != startsAt);
1605       }
1606       if (kind != 0x7fffffff)
1607       {
1608          jjmatchedKind = kind;
1609          jjmatchedPos = curPos;
1610          kind = 0x7fffffff;
1611       }
1612       ++curPos;
1613       if ((i = jjnewStateCnt) == (startsAt = 56 - (jjnewStateCnt = startsAt)))
1614          return curPos;
1615       try { curChar = input_stream.readChar(); }
1616       catch(java.io.IOException e) { return curPos; }
1617    }
1618 }
1619 static private final int jjMoveStringLiteralDfa0_3()
1620 {
1621    switch(curChar)
1622    {
1623       case 42:
1624          return jjMoveStringLiteralDfa1_3(0x2000L);
1625       default :
1626          return 1;
1627    }
1628 }
1629 static private final int jjMoveStringLiteralDfa1_3(long active0)
1630 {
1631    try { curChar = input_stream.readChar(); }
1632    catch(java.io.IOException e) {
1633       return 1;
1634    }
1635    switch(curChar)
1636    {
1637       case 47:
1638          if ((active0 & 0x2000L) != 0L)
1639             return jjStopAtPos(1, 13);
1640          break;
1641       default :
1642          return 2;
1643    }
1644    return 2;
1645 }
1646 static final int[] jjnextStates = {
1647    4, 5, 19, 20, 25, 26, 29, 30, 12, 47, 48, 49, 50, 38, 40, 41,
1648    42, 44, 45, 34, 36, 6, 8, 9, 12, 21, 22, 12, 29, 30, 12, 38,
1649    40, 41, 42, 44, 45, 52, 53, 54, 55, 52, 53, 54, 55, 10, 11, 23,
1650    24, 27, 28, 31, 32, 47, 48, 49, 50,
1651 };
1652 public static final String[] jjstrLiteralImages = {
1653 "", null, "\77\76", null, null, null, null, null, null, null, null, null, null,
1654 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1655 null, null, null, null, "\55\76", "\72\72", "\75\76", null, null, null, null, null,
1656 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1657 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1658 null, null, null, null, null, null, null, null, null, null, null, "\50", "\51",
1659 "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\100", "\44", "\75", "\76",
1660 "\74", "\41", "\77", "\72", "\75\75", "\74\75", "\76\75", "\41\75", "\174\174",
1661 "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45",
1662 "\74\74", "\76\76", "\76\76\76", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75",
1663 "\174\75", "\136\75", "\56\75", "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75", null,
1664 "\77\76", };
1665 public static final String[] lexStateNames = {
1666    "DEFAULT",
1667    "PHPPARSING",
1668    "IN_SINGLE_LINE_COMMENT",
1669    "IN_FORMAL_COMMENT",
1670    "IN_MULTI_LINE_COMMENT",
1671 };
1672 public static final int[] jjnewLexState = {
1673    -1, 1, 0, -1, -1, -1, -1, -1, -1, 2, 3, 4, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1674    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1675    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1676    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1677    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1678    -1, -1, -1,
1679 };
1680 static final long[] jjtoToken = {
1681    0xffffffffffff0007L, 0xffffffffffffc7d1L, 0x0L,
1682 };
1683 static final long[] jjtoSkip = {
1684    0x71f8L, 0x0L, 0x0L,
1685 };
1686 static final long[] jjtoSpecial = {
1687    0x7000L, 0x0L, 0x0L,
1688 };
1689 static final long[] jjtoMore = {
1690    0x8e00L, 0x0L, 0x0L,
1691 };
1692 static private SimpleCharStream input_stream;
1693 static private final int[] jjrounds = new int[56];
1694 static private final int[] jjstateSet = new int[112];
1695 static StringBuffer image;
1696 static int jjimageLen;
1697 static int lengthOfMatch;
1698 static protected char curChar;
1699 public PHPParserTokenManager(SimpleCharStream stream)
1700 {
1701    if (input_stream != null)
1702       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
1703    input_stream = stream;
1704 }
1705 public PHPParserTokenManager(SimpleCharStream stream, int lexState)
1706 {
1707    this(stream);
1708    SwitchTo(lexState);
1709 }
1710 static public void ReInit(SimpleCharStream stream)
1711 {
1712    jjmatchedPos = jjnewStateCnt = 0;
1713    curLexState = defaultLexState;
1714    input_stream = stream;
1715    ReInitRounds();
1716 }
1717 static private final void ReInitRounds()
1718 {
1719    int i;
1720    jjround = 0x80000001;
1721    for (i = 56; i-- > 0;)
1722       jjrounds[i] = 0x80000000;
1723 }
1724 static public void ReInit(SimpleCharStream stream, int lexState)
1725 {
1726    ReInit(stream);
1727    SwitchTo(lexState);
1728 }
1729 static public void SwitchTo(int lexState)
1730 {
1731    if (lexState >= 5 || lexState < 0)
1732       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1733    else
1734       curLexState = lexState;
1735 }
1736
1737 static private final Token jjFillToken()
1738 {
1739    Token t = Token.newToken(jjmatchedKind);
1740    t.kind = jjmatchedKind;
1741    String im = jjstrLiteralImages[jjmatchedKind];
1742    t.image = (im == null) ? input_stream.GetImage() : im;
1743    t.beginLine = input_stream.getBeginLine();
1744    t.beginColumn = input_stream.getBeginColumn();
1745    t.endLine = input_stream.getEndLine();
1746    t.endColumn = input_stream.getEndColumn();
1747    return t;
1748 }
1749
1750 static int curLexState = 0;
1751 static int defaultLexState = 0;
1752 static int jjnewStateCnt;
1753 static int jjround;
1754 static int jjmatchedPos;
1755 static int jjmatchedKind;
1756
1757 public static final Token getNextToken()
1758 {
1759   int kind;
1760   Token specialToken = null;
1761   Token matchedToken;
1762   int curPos = 0;
1763
1764   EOFLoop :
1765   for (;;)
1766   {
1767    try
1768    {
1769       curChar = input_stream.BeginToken();
1770    }
1771    catch(java.io.IOException e)
1772    {
1773       jjmatchedKind = 0;
1774       matchedToken = jjFillToken();
1775       matchedToken.specialToken = specialToken;
1776       return matchedToken;
1777    }
1778    image = null;
1779    jjimageLen = 0;
1780
1781    for (;;)
1782    {
1783      switch(curLexState)
1784      {
1785        case 0:
1786          jjmatchedKind = 0x7fffffff;
1787          jjmatchedPos = 0;
1788          curPos = jjMoveStringLiteralDfa0_0();
1789          if (jjmatchedPos == 0 && jjmatchedKind > 3)
1790          {
1791             jjmatchedKind = 3;
1792          }
1793          break;
1794        case 1:
1795          try { input_stream.backup(0);
1796             while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1797                curChar = input_stream.BeginToken();
1798          }
1799          catch (java.io.IOException e1) { continue EOFLoop; }
1800          jjmatchedKind = 0x7fffffff;
1801          jjmatchedPos = 0;
1802          curPos = jjMoveStringLiteralDfa0_1();
1803          break;
1804        case 2:
1805          jjmatchedKind = 0x7fffffff;
1806          jjmatchedPos = 0;
1807          curPos = jjMoveStringLiteralDfa0_2();
1808          if (jjmatchedPos == 0 && jjmatchedKind > 15)
1809          {
1810             jjmatchedKind = 15;
1811          }
1812          break;
1813        case 3:
1814          jjmatchedKind = 0x7fffffff;
1815          jjmatchedPos = 0;
1816          curPos = jjMoveStringLiteralDfa0_3();
1817          if (jjmatchedPos == 0 && jjmatchedKind > 15)
1818          {
1819             jjmatchedKind = 15;
1820          }
1821          break;
1822        case 4:
1823          jjmatchedKind = 0x7fffffff;
1824          jjmatchedPos = 0;
1825          curPos = jjMoveStringLiteralDfa0_4();
1826          if (jjmatchedPos == 0 && jjmatchedKind > 15)
1827          {
1828             jjmatchedKind = 15;
1829          }
1830          break;
1831      }
1832      if (jjmatchedKind != 0x7fffffff)
1833      {
1834         if (jjmatchedPos + 1 < curPos)
1835            input_stream.backup(curPos - jjmatchedPos - 1);
1836         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1837         {
1838            matchedToken = jjFillToken();
1839            matchedToken.specialToken = specialToken;
1840        if (jjnewLexState[jjmatchedKind] != -1)
1841          curLexState = jjnewLexState[jjmatchedKind];
1842            return matchedToken;
1843         }
1844         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1845         {
1846            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1847            {
1848               matchedToken = jjFillToken();
1849               if (specialToken == null)
1850                  specialToken = matchedToken;
1851               else
1852               {
1853                  matchedToken.specialToken = specialToken;
1854                  specialToken = (specialToken.next = matchedToken);
1855               }
1856               SkipLexicalActions(matchedToken);
1857            }
1858            else
1859               SkipLexicalActions(null);
1860          if (jjnewLexState[jjmatchedKind] != -1)
1861            curLexState = jjnewLexState[jjmatchedKind];
1862            continue EOFLoop;
1863         }
1864         MoreLexicalActions();
1865       if (jjnewLexState[jjmatchedKind] != -1)
1866         curLexState = jjnewLexState[jjmatchedKind];
1867         curPos = 0;
1868         jjmatchedKind = 0x7fffffff;
1869         try {
1870            curChar = input_stream.readChar();
1871            continue;
1872         }
1873         catch (java.io.IOException e1) { }
1874      }
1875      int error_line = input_stream.getEndLine();
1876      int error_column = input_stream.getEndColumn();
1877      String error_after = null;
1878      boolean EOFSeen = false;
1879      try { input_stream.readChar(); input_stream.backup(1); }
1880      catch (java.io.IOException e1) {
1881         EOFSeen = true;
1882         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1883         if (curChar == '\n' || curChar == '\r') {
1884            error_line++;
1885            error_column = 0;
1886         }
1887         else
1888            error_column++;
1889      }
1890      if (!EOFSeen) {
1891         input_stream.backup(1);
1892         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1893      }
1894      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1895    }
1896   }
1897 }
1898
1899 static final void SkipLexicalActions(Token matchedToken)
1900 {
1901    switch(jjmatchedKind)
1902    {
1903       default :
1904          break;
1905    }
1906 }
1907 static final void MoreLexicalActions()
1908 {
1909    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1910    switch(jjmatchedKind)
1911    {
1912       case 10 :
1913          if (image == null)
1914               image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
1915          else
1916             image.append(new String(input_stream.GetSuffix(jjimageLen)));
1917          jjimageLen = 0;
1918                    input_stream.backup(1);
1919          break;
1920       default :
1921          break;
1922    }
1923 }
1924 }