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