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