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