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