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