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