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