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 = 56;
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, 12);
1226                   else if (curChar == 34)
1227                      jjCheckNAddStates(13, 18);
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(19, 21);
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(22, 24);
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(25, 27);
1327                   break;
1328                case 21:
1329                   if ((0x3ff000000000000L & l) == 0L)
1330                      break;
1331                   if (kind > 68)
1332                      kind = 68;
1333                   jjCheckNAddStates(25, 27);
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(28, 30);
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(19, 21);
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(13, 18);
1397                   break;
1398                case 38:
1399                   if ((0xfffffffbffffffffL & l) != 0L)
1400                      jjCheckNAddStates(31, 33);
1401                   break;
1402                case 39:
1403                   if (curChar == 34)
1404                      jjCheckNAddStates(31, 33);
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(34, 36);
1413                   break;
1414                case 43:
1415                   if (curChar == 34)
1416                      jjCheckNAddStates(34, 36);
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, 12);
1425                   break;
1426                case 47:
1427                   if ((0xffffff7fffffffffL & l) != 0L)
1428                      jjCheckNAddTwoStates(47, 48);
1429                   break;
1430                case 48:
1431                   if (curChar == 39 && kind > 70)
1432                      kind = 70;
1433                   break;
1434                case 49:
1435                   if ((0xffffff7fffffffffL & l) != 0L)
1436                      jjCheckNAddTwoStates(49, 50);
1437                   break;
1438                case 50:
1439                   if (curChar == 39 && kind > 72)
1440                      kind = 72;
1441                   break;
1442                case 52:
1443                   jjAddStates(37, 38);
1444                   break;
1445                case 54:
1446                   jjAddStates(39, 40);
1447                   break;
1448                default : break;
1449             }
1450          } while(i != startsAt);
1451       }
1452       else if (curChar < 128)
1453       {
1454          long l = 1L << (curChar & 077);
1455          MatchLoop: do
1456          {
1457             switch(jjstateSet[--i])
1458             {
1459                case 3:
1460                   if ((0x7fffffe87fffffeL & l) != 0L)
1461                   {
1462                      if (kind > 74)
1463                         kind = 74;
1464                      jjCheckNAdd(14);
1465                   }
1466                   else if (curChar == 96)
1467                      jjCheckNAddStates(41, 44);
1468                   break;
1469                case 1:
1470                   if (kind > 10)
1471                      kind = 10;
1472                   break;
1473                case 6:
1474                   if ((0x100000001000L & l) != 0L && kind > 64)
1475                      kind = 64;
1476                   break;
1477                case 9:
1478                   if ((0x2000000020L & l) != 0L)
1479                      jjAddStates(45, 46);
1480                   break;
1481                case 12:
1482                   if ((0x5000000050L & l) != 0L && kind > 68)
1483                      kind = 68;
1484                   break;
1485                case 13:
1486                case 14:
1487                   if ((0x7fffffe87fffffeL & l) == 0L)
1488                      break;
1489                   if (kind > 74)
1490                      kind = 74;
1491                   jjCheckNAdd(14);
1492                   break;
1493                case 16:
1494                case 17:
1495                   if ((0x7fffffe87fffffeL & l) == 0L)
1496                      break;
1497                   if (kind > 126)
1498                      kind = 126;
1499                   jjCheckNAdd(17);
1500                   break;
1501                case 22:
1502                   if ((0x2000000020L & l) != 0L)
1503                      jjAddStates(47, 48);
1504                   break;
1505                case 26:
1506                   if ((0x2000000020L & l) != 0L)
1507                      jjAddStates(49, 50);
1508                   break;
1509                case 30:
1510                   if ((0x2000000020L & l) != 0L)
1511                      jjAddStates(51, 52);
1512                   break;
1513                case 34:
1514                   if ((0x100000001000000L & l) != 0L)
1515                      jjCheckNAdd(35);
1516                   break;
1517                case 35:
1518                   if ((0x7e0000007eL & l) == 0L)
1519                      break;
1520                   if (kind > 64)
1521                      kind = 64;
1522                   jjCheckNAddTwoStates(35, 6);
1523                   break;
1524                case 38:
1525                   jjAddStates(31, 33);
1526                   break;
1527                case 40:
1528                   if (curChar == 92)
1529                      jjstateSet[jjnewStateCnt++] = 39;
1530                   break;
1531                case 42:
1532                   jjAddStates(34, 36);
1533                   break;
1534                case 44:
1535                   if (curChar == 92)
1536                      jjstateSet[jjnewStateCnt++] = 43;
1537                   break;
1538                case 47:
1539                   jjAddStates(53, 54);
1540                   break;
1541                case 49:
1542                   jjAddStates(55, 56);
1543                   break;
1544                case 51:
1545                   if (curChar == 96)
1546                      jjCheckNAddStates(41, 44);
1547                   break;
1548                case 52:
1549                   if ((0xfffffffeffffffffL & l) != 0L)
1550                      jjCheckNAddTwoStates(52, 53);
1551                   break;
1552                case 53:
1553                   if (curChar == 96 && kind > 70)
1554                      kind = 70;
1555                   break;
1556                case 54:
1557                   if ((0xfffffffeffffffffL & l) != 0L)
1558                      jjCheckNAddTwoStates(54, 55);
1559                   break;
1560                case 55:
1561                   if (curChar == 96 && kind > 73)
1562                      kind = 73;
1563                   break;
1564                default : break;
1565             }
1566          } while(i != startsAt);
1567       }
1568       else
1569       {
1570          int i2 = (curChar & 0xff) >> 6;
1571          long l2 = 1L << (curChar & 077);
1572          MatchLoop: do
1573          {
1574             switch(jjstateSet[--i])
1575             {
1576                case 1:
1577                   if ((jjbitVec0[i2] & l2) != 0L && kind > 10)
1578                      kind = 10;
1579                   break;
1580                case 38:
1581                   if ((jjbitVec0[i2] & l2) != 0L)
1582                      jjAddStates(31, 33);
1583                   break;
1584                case 42:
1585                   if ((jjbitVec0[i2] & l2) != 0L)
1586                      jjAddStates(34, 36);
1587                   break;
1588                case 47:
1589                   if ((jjbitVec0[i2] & l2) != 0L)
1590                      jjAddStates(53, 54);
1591                   break;
1592                case 49:
1593                   if ((jjbitVec0[i2] & l2) != 0L)
1594                      jjAddStates(55, 56);
1595                   break;
1596                case 52:
1597                   if ((jjbitVec0[i2] & l2) != 0L)
1598                      jjAddStates(37, 38);
1599                   break;
1600                case 54:
1601                   if ((jjbitVec0[i2] & l2) != 0L)
1602                      jjAddStates(39, 40);
1603                   break;
1604                default : break;
1605             }
1606          } while(i != startsAt);
1607       }
1608       if (kind != 0x7fffffff)
1609       {
1610          jjmatchedKind = kind;
1611          jjmatchedPos = curPos;
1612          kind = 0x7fffffff;
1613       }
1614       ++curPos;
1615       if ((i = jjnewStateCnt) == (startsAt = 56 - (jjnewStateCnt = startsAt)))
1616          return curPos;
1617       try { curChar = input_stream.readChar(); }
1618       catch(java.io.IOException e) { return curPos; }
1619    }
1620 }
1621 static private final int jjMoveStringLiteralDfa0_3()
1622 {
1623    switch(curChar)
1624    {
1625       case 42:
1626          return jjMoveStringLiteralDfa1_3(0x2000L);
1627       default :
1628          return 1;
1629    }
1630 }
1631 static private final int jjMoveStringLiteralDfa1_3(long active0)
1632 {
1633    try { curChar = input_stream.readChar(); }
1634    catch(java.io.IOException e) {
1635       return 1;
1636    }
1637    switch(curChar)
1638    {
1639       case 47:
1640          if ((active0 & 0x2000L) != 0L)
1641             return jjStopAtPos(1, 13);
1642          break;
1643       default :
1644          return 2;
1645    }
1646    return 2;
1647 }
1648 static final int[] jjnextStates = {
1649    4, 5, 19, 20, 25, 26, 29, 30, 12, 47, 48, 49, 50, 38, 40, 41,
1650    42, 44, 45, 34, 36, 6, 8, 9, 12, 21, 22, 12, 29, 30, 12, 38,
1651    40, 41, 42, 44, 45, 52, 53, 54, 55, 52, 53, 54, 55, 10, 11, 23,
1652    24, 27, 28, 31, 32, 47, 48, 49, 50,
1653 };
1654 public static final String[] jjstrLiteralImages = {
1655 "", null, "\77\76", null, null, null, null, null, null, null, null, null, null,
1656 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1657 null, null, null, null, "\55\76", "\72\72", "\75\76", null, null, null, null, null,
1658 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1659 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1660 null, null, null, null, null, null, null, null, null, null, null, "\50", "\51",
1661 "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\100", "\44", "\75", "\76",
1662 "\74", "\41", "\77", "\72", "\75\75", "\74\75", "\76\75", "\41\75", "\174\174",
1663 "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45",
1664 "\74\74", "\76\76", "\76\76\76", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75",
1665 "\174\75", "\136\75", "\56\75", "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75", null,
1666 "\77\76", };
1667 public static final String[] lexStateNames = {
1668    "DEFAULT",
1669    "PHPPARSING",
1670    "IN_SINGLE_LINE_COMMENT",
1671    "IN_FORMAL_COMMENT",
1672    "IN_MULTI_LINE_COMMENT",
1673 };
1674 public static final int[] jjnewLexState = {
1675    -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,
1676    -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,
1677    -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,
1678    -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,
1679    -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,
1680    -1, -1, -1,
1681 };
1682 static final long[] jjtoToken = {
1683    0xffffffffffff0007L, 0xffffffffffffc7d1L, 0x0L,
1684 };
1685 static final long[] jjtoSkip = {
1686    0x71f8L, 0x0L, 0x0L,
1687 };
1688 static final long[] jjtoSpecial = {
1689    0x7000L, 0x0L, 0x0L,
1690 };
1691 static final long[] jjtoMore = {
1692    0x8e00L, 0x0L, 0x0L,
1693 };
1694 static protected SimpleCharStream input_stream;
1695 static private final int[] jjrounds = new int[56];
1696 static private final int[] jjstateSet = new int[112];
1697 static StringBuffer image;
1698 static int jjimageLen;
1699 static int lengthOfMatch;
1700 static protected char curChar;
1701 public PHPParserTokenManager(SimpleCharStream stream)
1702 {
1703    if (input_stream != null)
1704       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
1705    input_stream = stream;
1706 }
1707 public PHPParserTokenManager(SimpleCharStream stream, int lexState)
1708 {
1709    this(stream);
1710    SwitchTo(lexState);
1711 }
1712 static public void ReInit(SimpleCharStream stream)
1713 {
1714    jjmatchedPos = jjnewStateCnt = 0;
1715    curLexState = defaultLexState;
1716    input_stream = stream;
1717    ReInitRounds();
1718 }
1719 static private final void ReInitRounds()
1720 {
1721    int i;
1722    jjround = 0x80000001;
1723    for (i = 56; i-- > 0;)
1724       jjrounds[i] = 0x80000000;
1725 }
1726 static public void ReInit(SimpleCharStream stream, int lexState)
1727 {
1728    ReInit(stream);
1729    SwitchTo(lexState);
1730 }
1731 static public void SwitchTo(int lexState)
1732 {
1733    if (lexState >= 5 || lexState < 0)
1734       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1735    else
1736       curLexState = lexState;
1737 }
1738
1739 static protected Token jjFillToken()
1740 {
1741    Token t = Token.newToken(jjmatchedKind);
1742    t.kind = jjmatchedKind;
1743    String im = jjstrLiteralImages[jjmatchedKind];
1744    t.image = (im == null) ? input_stream.GetImage() : im;
1745    t.beginLine = input_stream.getBeginLine();
1746    t.beginColumn = input_stream.getBeginColumn();
1747    t.endLine = input_stream.getEndLine();
1748    t.endColumn = input_stream.getEndColumn();
1749    return t;
1750 }
1751
1752 static int curLexState = 0;
1753 static int defaultLexState = 0;
1754 static int jjnewStateCnt;
1755 static int jjround;
1756 static int jjmatchedPos;
1757 static int jjmatchedKind;
1758
1759 public static Token getNextToken()
1760 {
1761   int kind;
1762   Token specialToken = null;
1763   Token matchedToken;
1764   int curPos = 0;
1765
1766   EOFLoop :
1767   for (;;)
1768   {
1769    try
1770    {
1771       curChar = input_stream.BeginToken();
1772    }
1773    catch(java.io.IOException e)
1774    {
1775       jjmatchedKind = 0;
1776       matchedToken = jjFillToken();
1777       matchedToken.specialToken = specialToken;
1778       return matchedToken;
1779    }
1780    image = null;
1781    jjimageLen = 0;
1782
1783    for (;;)
1784    {
1785      switch(curLexState)
1786      {
1787        case 0:
1788          jjmatchedKind = 0x7fffffff;
1789          jjmatchedPos = 0;
1790          curPos = jjMoveStringLiteralDfa0_0();
1791          if (jjmatchedPos == 0 && jjmatchedKind > 3)
1792          {
1793             jjmatchedKind = 3;
1794          }
1795          break;
1796        case 1:
1797          try { input_stream.backup(0);
1798             while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1799                curChar = input_stream.BeginToken();
1800          }
1801          catch (java.io.IOException e1) { continue EOFLoop; }
1802          jjmatchedKind = 0x7fffffff;
1803          jjmatchedPos = 0;
1804          curPos = jjMoveStringLiteralDfa0_1();
1805          break;
1806        case 2:
1807          jjmatchedKind = 0x7fffffff;
1808          jjmatchedPos = 0;
1809          curPos = jjMoveStringLiteralDfa0_2();
1810          if (jjmatchedPos == 0 && jjmatchedKind > 15)
1811          {
1812             jjmatchedKind = 15;
1813          }
1814          break;
1815        case 3:
1816          jjmatchedKind = 0x7fffffff;
1817          jjmatchedPos = 0;
1818          curPos = jjMoveStringLiteralDfa0_3();
1819          if (jjmatchedPos == 0 && jjmatchedKind > 15)
1820          {
1821             jjmatchedKind = 15;
1822          }
1823          break;
1824        case 4:
1825          jjmatchedKind = 0x7fffffff;
1826          jjmatchedPos = 0;
1827          curPos = jjMoveStringLiteralDfa0_4();
1828          if (jjmatchedPos == 0 && jjmatchedKind > 15)
1829          {
1830             jjmatchedKind = 15;
1831          }
1832          break;
1833      }
1834      if (jjmatchedKind != 0x7fffffff)
1835      {
1836         if (jjmatchedPos + 1 < curPos)
1837            input_stream.backup(curPos - jjmatchedPos - 1);
1838         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1839         {
1840            matchedToken = jjFillToken();
1841            matchedToken.specialToken = specialToken;
1842        if (jjnewLexState[jjmatchedKind] != -1)
1843          curLexState = jjnewLexState[jjmatchedKind];
1844            return matchedToken;
1845         }
1846         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1847         {
1848            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1849            {
1850               matchedToken = jjFillToken();
1851               if (specialToken == null)
1852                  specialToken = matchedToken;
1853               else
1854               {
1855                  matchedToken.specialToken = specialToken;
1856                  specialToken = (specialToken.next = matchedToken);
1857               }
1858               SkipLexicalActions(matchedToken);
1859            }
1860            else
1861               SkipLexicalActions(null);
1862          if (jjnewLexState[jjmatchedKind] != -1)
1863            curLexState = jjnewLexState[jjmatchedKind];
1864            continue EOFLoop;
1865         }
1866         MoreLexicalActions();
1867       if (jjnewLexState[jjmatchedKind] != -1)
1868         curLexState = jjnewLexState[jjmatchedKind];
1869         curPos = 0;
1870         jjmatchedKind = 0x7fffffff;
1871         try {
1872            curChar = input_stream.readChar();
1873            continue;
1874         }
1875         catch (java.io.IOException e1) { }
1876      }
1877      int error_line = input_stream.getEndLine();
1878      int error_column = input_stream.getEndColumn();
1879      String error_after = null;
1880      boolean EOFSeen = false;
1881      try { input_stream.readChar(); input_stream.backup(1); }
1882      catch (java.io.IOException e1) {
1883         EOFSeen = true;
1884         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1885         if (curChar == '\n' || curChar == '\r') {
1886            error_line++;
1887            error_column = 0;
1888         }
1889         else
1890            error_column++;
1891      }
1892      if (!EOFSeen) {
1893         input_stream.backup(1);
1894         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1895      }
1896      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1897    }
1898   }
1899 }
1900
1901 static void SkipLexicalActions(Token matchedToken)
1902 {
1903    switch(jjmatchedKind)
1904    {
1905       default :
1906          break;
1907    }
1908 }
1909 static void MoreLexicalActions()
1910 {
1911    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1912    switch(jjmatchedKind)
1913    {
1914       case 10 :
1915          if (image == null)
1916               image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
1917          else
1918             image.append(new String(input_stream.GetSuffix(jjimageLen)));
1919          jjimageLen = 0;
1920                    input_stream.backup(1);
1921          break;
1922       default :
1923          break;
1924    }
1925 }
1926 }