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