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