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                   if (curChar == 34)
1545                      jjCheckNAddStates(31, 33);
1546                   break;
1547                case 41:
1548                   if (curChar == 34 && kind > 103)
1549                      kind = 103;
1550                   break;
1551                case 42:
1552                   if ((0xfffffffbffffffffL & l) != 0L)
1553                      jjCheckNAddStates(34, 36);
1554                   break;
1555                case 44:
1556                   if (curChar == 34)
1557                      jjCheckNAddStates(34, 36);
1558                   break;
1559                case 45:
1560                   if (curChar == 34 && kind > 104)
1561                      kind = 104;
1562                   break;
1563                case 46:
1564                   if (curChar == 39)
1565                      jjCheckNAddStates(7, 12);
1566                   break;
1567                case 47:
1568                   if ((0xffffff7fffffffffL & l) != 0L)
1569                      jjCheckNAddStates(37, 39);
1570                   break;
1571                case 49:
1572                   if (curChar == 39)
1573                      jjCheckNAddStates(37, 39);
1574                   break;
1575                case 50:
1576                   if (curChar == 39 && kind > 103)
1577                      kind = 103;
1578                   break;
1579                case 51:
1580                   if ((0xffffff7fffffffffL & l) != 0L)
1581                      jjCheckNAddStates(40, 42);
1582                   break;
1583                case 53:
1584                   if (curChar == 39)
1585                      jjCheckNAddStates(40, 42);
1586                   break;
1587                case 54:
1588                   if (curChar == 39 && kind > 105)
1589                      kind = 105;
1590                   break;
1591                case 56:
1592                   jjAddStates(43, 45);
1593                   break;
1594                case 60:
1595                   jjAddStates(46, 48);
1596                   break;
1597                default : break;
1598             }
1599          } while(i != startsAt);
1600       }
1601       else if (curChar < 128)
1602       {
1603          long l = 1L << (curChar & 077);
1604          MatchLoop: do
1605          {
1606             switch(jjstateSet[--i])
1607             {
1608                case 3:
1609                   if ((0x87fffffe87fffffeL & l) != 0L)
1610                   {
1611                      if (kind > 107)
1612                         kind = 107;
1613                      jjCheckNAdd(14);
1614                   }
1615                   else if (curChar == 96)
1616                      jjCheckNAddStates(49, 54);
1617                   break;
1618                case 1:
1619                   if (kind > 13)
1620                      kind = 13;
1621                   break;
1622                case 6:
1623                   if ((0x100000001000L & l) != 0L && kind > 97)
1624                      kind = 97;
1625                   break;
1626                case 9:
1627                   if ((0x2000000020L & l) != 0L)
1628                      jjAddStates(55, 56);
1629                   break;
1630                case 12:
1631                   if ((0x5000000050L & l) != 0L && kind > 101)
1632                      kind = 101;
1633                   break;
1634                case 13:
1635                case 14:
1636                   if ((0x87fffffe87fffffeL & l) == 0L)
1637                      break;
1638                   if (kind > 107)
1639                      kind = 107;
1640                   jjCheckNAdd(14);
1641                   break;
1642                case 16:
1643                case 17:
1644                   if ((0x87fffffe87fffffeL & l) == 0L)
1645                      break;
1646                   if (kind > 142)
1647                      kind = 142;
1648                   jjCheckNAdd(17);
1649                   break;
1650                case 22:
1651                   if ((0x2000000020L & l) != 0L)
1652                      jjAddStates(57, 58);
1653                   break;
1654                case 26:
1655                   if ((0x2000000020L & l) != 0L)
1656                      jjAddStates(59, 60);
1657                   break;
1658                case 30:
1659                   if ((0x2000000020L & l) != 0L)
1660                      jjAddStates(61, 62);
1661                   break;
1662                case 34:
1663                   if ((0x100000001000000L & l) != 0L)
1664                      jjCheckNAdd(35);
1665                   break;
1666                case 35:
1667                   if ((0x7e0000007eL & l) == 0L)
1668                      break;
1669                   if (kind > 97)
1670                      kind = 97;
1671                   jjCheckNAddTwoStates(35, 6);
1672                   break;
1673                case 38:
1674                   if ((0xffffffffefffffffL & l) != 0L)
1675                      jjCheckNAddStates(31, 33);
1676                   break;
1677                case 39:
1678                   if (curChar == 92)
1679                      jjstateSet[jjnewStateCnt++] = 40;
1680                   break;
1681                case 40:
1682                   if (curChar == 92)
1683                      jjCheckNAddStates(31, 33);
1684                   break;
1685                case 42:
1686                   if ((0xffffffffefffffffL & l) != 0L)
1687                      jjCheckNAddStates(34, 36);
1688                   break;
1689                case 43:
1690                   if (curChar == 92)
1691                      jjstateSet[jjnewStateCnt++] = 44;
1692                   break;
1693                case 44:
1694                   if (curChar == 92)
1695                      jjCheckNAddStates(34, 36);
1696                   break;
1697                case 47:
1698                   if ((0xffffffffefffffffL & l) != 0L)
1699                      jjCheckNAddStates(37, 39);
1700                   break;
1701                case 48:
1702                   if (curChar == 92)
1703                      jjstateSet[jjnewStateCnt++] = 49;
1704                   break;
1705                case 49:
1706                   if (curChar == 92)
1707                      jjCheckNAddStates(37, 39);
1708                   break;
1709                case 51:
1710                   if ((0xffffffffefffffffL & l) != 0L)
1711                      jjCheckNAddStates(40, 42);
1712                   break;
1713                case 52:
1714                   if (curChar == 92)
1715                      jjstateSet[jjnewStateCnt++] = 53;
1716                   break;
1717                case 53:
1718                   if (curChar == 92)
1719                      jjCheckNAddStates(40, 42);
1720                   break;
1721                case 55:
1722                   if (curChar == 96)
1723                      jjCheckNAddStates(49, 54);
1724                   break;
1725                case 56:
1726                   if ((0xfffffffeefffffffL & l) != 0L)
1727                      jjCheckNAddStates(43, 45);
1728                   break;
1729                case 57:
1730                   if (curChar == 92)
1731                      jjstateSet[jjnewStateCnt++] = 58;
1732                   break;
1733                case 58:
1734                   if ((0x110000000L & l) != 0L)
1735                      jjCheckNAddStates(43, 45);
1736                   break;
1737                case 59:
1738                   if (curChar == 96 && kind > 103)
1739                      kind = 103;
1740                   break;
1741                case 60:
1742                   if ((0xfffffffeefffffffL & l) != 0L)
1743                      jjCheckNAddStates(46, 48);
1744                   break;
1745                case 61:
1746                   if (curChar == 92)
1747                      jjstateSet[jjnewStateCnt++] = 62;
1748                   break;
1749                case 62:
1750                   if ((0x110000000L & l) != 0L)
1751                      jjCheckNAddStates(46, 48);
1752                   break;
1753                case 63:
1754                   if (curChar == 96 && kind > 106)
1755                      kind = 106;
1756                   break;
1757                default : break;
1758             }
1759          } while(i != startsAt);
1760       }
1761       else
1762       {
1763          int i2 = (curChar & 0xff) >> 6;
1764          long l2 = 1L << (curChar & 077);
1765          MatchLoop: do
1766          {
1767             switch(jjstateSet[--i])
1768             {
1769                case 3:
1770                case 14:
1771                   if ((jjbitVec0[i2] & l2) == 0L)
1772                      break;
1773                   if (kind > 107)
1774                      kind = 107;
1775                   jjCheckNAdd(14);
1776                   break;
1777                case 1:
1778                   if ((jjbitVec0[i2] & l2) != 0L && kind > 13)
1779                      kind = 13;
1780                   break;
1781                case 16:
1782                case 17:
1783                   if ((jjbitVec0[i2] & l2) == 0L)
1784                      break;
1785                   if (kind > 142)
1786                      kind = 142;
1787                   jjCheckNAdd(17);
1788                   break;
1789                case 38:
1790                   if ((jjbitVec0[i2] & l2) != 0L)
1791                      jjAddStates(31, 33);
1792                   break;
1793                case 42:
1794                   if ((jjbitVec0[i2] & l2) != 0L)
1795                      jjAddStates(34, 36);
1796                   break;
1797                case 47:
1798                   if ((jjbitVec0[i2] & l2) != 0L)
1799                      jjAddStates(37, 39);
1800                   break;
1801                case 51:
1802                   if ((jjbitVec0[i2] & l2) != 0L)
1803                      jjAddStates(40, 42);
1804                   break;
1805                case 56:
1806                   if ((jjbitVec0[i2] & l2) != 0L)
1807                      jjAddStates(43, 45);
1808                   break;
1809                case 60:
1810                   if ((jjbitVec0[i2] & l2) != 0L)
1811                      jjAddStates(46, 48);
1812                   break;
1813                default : break;
1814             }
1815          } while(i != startsAt);
1816       }
1817       if (kind != 0x7fffffff)
1818       {
1819          jjmatchedKind = kind;
1820          jjmatchedPos = curPos;
1821          kind = 0x7fffffff;
1822       }
1823       ++curPos;
1824       if ((i = jjnewStateCnt) == (startsAt = 64 - (jjnewStateCnt = startsAt)))
1825          return curPos;
1826       try { curChar = input_stream.readChar(); }
1827       catch(java.io.IOException e) { return curPos; }
1828    }
1829 }
1830 static private final int jjMoveStringLiteralDfa0_3()
1831 {
1832    switch(curChar)
1833    {
1834       case 42:
1835          return jjMoveStringLiteralDfa1_3(0x40000L);
1836       case 84:
1837       case 116:
1838          return jjMoveStringLiteralDfa1_3(0x20000L);
1839       default :
1840          return 1;
1841    }
1842 }
1843 static private final int jjMoveStringLiteralDfa1_3(long active0)
1844 {
1845    try { curChar = input_stream.readChar(); }
1846    catch(java.io.IOException e) {
1847       return 1;
1848    }
1849    switch(curChar)
1850    {
1851       case 47:
1852          if ((active0 & 0x40000L) != 0L)
1853             return jjStopAtPos(1, 18);
1854          break;
1855       case 79:
1856       case 111:
1857          return jjMoveStringLiteralDfa2_3(active0, 0x20000L);
1858       default :
1859          return 2;
1860    }
1861    return 2;
1862 }
1863 static private final int jjMoveStringLiteralDfa2_3(long old0, long active0)
1864 {
1865    if (((active0 &= old0)) == 0L)
1866       return 2;
1867    try { curChar = input_stream.readChar(); }
1868    catch(java.io.IOException e) {
1869       return 2;
1870    }
1871    switch(curChar)
1872    {
1873       case 68:
1874       case 100:
1875          return jjMoveStringLiteralDfa3_3(active0, 0x20000L);
1876       default :
1877          return 3;
1878    }
1879 }
1880 static private final int jjMoveStringLiteralDfa3_3(long old0, long active0)
1881 {
1882    if (((active0 &= old0)) == 0L)
1883       return 3;
1884    try { curChar = input_stream.readChar(); }
1885    catch(java.io.IOException e) {
1886       return 3;
1887    }
1888    switch(curChar)
1889    {
1890       case 79:
1891       case 111:
1892          if ((active0 & 0x20000L) != 0L)
1893             return jjStopAtPos(3, 17);
1894          break;
1895       default :
1896          return 4;
1897    }
1898    return 4;
1899 }
1900 static final int[] jjnextStates = {
1901    19, 20, 25, 26, 29, 30, 12, 47, 48, 50, 51, 52, 54, 38, 39, 41,
1902    42, 43, 45, 34, 36, 6, 8, 9, 12, 21, 22, 12, 29, 30, 12, 38,
1903    39, 41, 42, 43, 45, 47, 48, 50, 51, 52, 54, 56, 57, 59, 60, 61,
1904    63, 56, 57, 59, 60, 61, 63, 10, 11, 23, 24, 27, 28, 31, 32,
1905 };
1906 public static final String[] jjstrLiteralImages = {
1907 "", "\74\77", null, "\74\77\75", "\77\76", null, null, null, null, null, null,
1908 null, null, null, null, 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 "\55\76", "\72\72", "\75\76", null, null, null, null, null, null, null, null, null, null,
1911 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1912 null, null, null, null, null, null, null, null, "\100", "\44", "\41", "\176", "\77",
1913 "\72", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46",
1914 "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76", null, null, null, null, null,
1915 null, null, null, null, null, null, null, null, null, null, null, "\50", "\51",
1916 "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\76", "\74", "\75\75", "\74\75",
1917 "\76\75", "\41\75", "\74\76", "\41\75\75", "\75\75\75", "\75", "\53\75", "\55\75",
1918 "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\56\75", "\45\75", "\176\75",
1919 "\74\74\75", "\76\76\75", null, };
1920 public static final String[] lexStateNames = {
1921    "DEFAULT",
1922    "PHPPARSING",
1923    "IN_SINGLE_LINE_COMMENT",
1924    "IN_FORMAL_COMMENT",
1925    "IN_MULTI_LINE_COMMENT",
1926 };
1927 public static final int[] jjnewLexState = {
1928    -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,
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, -1, -1, -1, -1, -1, -1, -1,
1932    -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,
1933    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1934 };
1935 static final long[] jjtoToken = {
1936    0xffffffffffe0001fL, 0xffff8fa3ffffffffL, 0x7fffL,
1937 };
1938 static final long[] jjtoSkip = {
1939    0xfffe0L, 0x0L, 0x0L,
1940 };
1941 static final long[] jjtoSpecial = {
1942    0xff800L, 0x0L, 0x0L,
1943 };
1944 static final long[] jjtoMore = {
1945    0x100000L, 0x0L, 0x0L,
1946 };
1947 static protected SimpleCharStream input_stream;
1948 static private final int[] jjrounds = new int[64];
1949 static private final int[] jjstateSet = new int[128];
1950 static StringBuffer image;
1951 static int jjimageLen;
1952 static int lengthOfMatch;
1953 static protected char curChar;
1954 public PHPParserTokenManager(SimpleCharStream stream)
1955 {
1956    if (input_stream != null)
1957       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
1958    input_stream = stream;
1959 }
1960 public PHPParserTokenManager(SimpleCharStream stream, int lexState)
1961 {
1962    this(stream);
1963    SwitchTo(lexState);
1964 }
1965 static public void ReInit(SimpleCharStream stream)
1966 {
1967    jjmatchedPos = jjnewStateCnt = 0;
1968    curLexState = defaultLexState;
1969    input_stream = stream;
1970    ReInitRounds();
1971 }
1972 static private final void ReInitRounds()
1973 {
1974    int i;
1975    jjround = 0x80000001;
1976    for (i = 64; i-- > 0;)
1977       jjrounds[i] = 0x80000000;
1978 }
1979 static public void ReInit(SimpleCharStream stream, int lexState)
1980 {
1981    ReInit(stream);
1982    SwitchTo(lexState);
1983 }
1984 static public void SwitchTo(int lexState)
1985 {
1986    if (lexState >= 5 || lexState < 0)
1987       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1988    else
1989       curLexState = lexState;
1990 }
1991
1992 static protected Token jjFillToken()
1993 {
1994    Token t = Token.newToken(jjmatchedKind);
1995    t.kind = jjmatchedKind;
1996    String im = jjstrLiteralImages[jjmatchedKind];
1997    t.image = (im == null) ? input_stream.GetImage() : im;
1998    t.beginLine = input_stream.getBeginLine();
1999    t.beginColumn = input_stream.getBeginColumn();
2000    t.endLine = input_stream.getEndLine();
2001    t.endColumn = input_stream.getEndColumn();
2002    return t;
2003 }
2004
2005 static int curLexState = 0;
2006 static int defaultLexState = 0;
2007 static int jjnewStateCnt;
2008 static int jjround;
2009 static int jjmatchedPos;
2010 static int jjmatchedKind;
2011
2012 public static Token getNextToken()
2013 {
2014   int kind;
2015   Token specialToken = null;
2016   Token matchedToken;
2017   int curPos = 0;
2018
2019   EOFLoop :
2020   for (;;)
2021   {
2022    try
2023    {
2024       curChar = input_stream.BeginToken();
2025    }
2026    catch(java.io.IOException e)
2027    {
2028       jjmatchedKind = 0;
2029       matchedToken = jjFillToken();
2030       matchedToken.specialToken = specialToken;
2031       return matchedToken;
2032    }
2033    image = null;
2034    jjimageLen = 0;
2035
2036    for (;;)
2037    {
2038      switch(curLexState)
2039      {
2040        case 0:
2041          jjmatchedKind = 0x7fffffff;
2042          jjmatchedPos = 0;
2043          curPos = jjMoveStringLiteralDfa0_0();
2044          if (jjmatchedPos == 0 && jjmatchedKind > 5)
2045          {
2046             jjmatchedKind = 5;
2047          }
2048          break;
2049        case 1:
2050          try { input_stream.backup(0);
2051             while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
2052                curChar = input_stream.BeginToken();
2053          }
2054          catch (java.io.IOException e1) { continue EOFLoop; }
2055          jjmatchedKind = 0x7fffffff;
2056          jjmatchedPos = 0;
2057          curPos = jjMoveStringLiteralDfa0_1();
2058          break;
2059        case 2:
2060          jjmatchedKind = 0x7fffffff;
2061          jjmatchedPos = 0;
2062          curPos = jjMoveStringLiteralDfa0_2();
2063          if (jjmatchedPos == 0 && jjmatchedKind > 20)
2064          {
2065             jjmatchedKind = 20;
2066          }
2067          break;
2068        case 3:
2069          jjmatchedKind = 0x7fffffff;
2070          jjmatchedPos = 0;
2071          curPos = jjMoveStringLiteralDfa0_3();
2072          if (jjmatchedPos == 0 && jjmatchedKind > 20)
2073          {
2074             jjmatchedKind = 20;
2075          }
2076          break;
2077        case 4:
2078          jjmatchedKind = 0x7fffffff;
2079          jjmatchedPos = 0;
2080          curPos = jjMoveStringLiteralDfa0_4();
2081          if (jjmatchedPos == 0 && jjmatchedKind > 20)
2082          {
2083             jjmatchedKind = 20;
2084          }
2085          break;
2086      }
2087      if (jjmatchedKind != 0x7fffffff)
2088      {
2089         if (jjmatchedPos + 1 < curPos)
2090            input_stream.backup(curPos - jjmatchedPos - 1);
2091         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2092         {
2093            matchedToken = jjFillToken();
2094            matchedToken.specialToken = specialToken;
2095            TokenLexicalActions(matchedToken);
2096        if (jjnewLexState[jjmatchedKind] != -1)
2097          curLexState = jjnewLexState[jjmatchedKind];
2098            return matchedToken;
2099         }
2100         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2101         {
2102            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2103            {
2104               matchedToken = jjFillToken();
2105               if (specialToken == null)
2106                  specialToken = matchedToken;
2107               else
2108               {
2109                  matchedToken.specialToken = specialToken;
2110                  specialToken = (specialToken.next = matchedToken);
2111               }
2112               SkipLexicalActions(matchedToken);
2113            }
2114            else
2115               SkipLexicalActions(null);
2116          if (jjnewLexState[jjmatchedKind] != -1)
2117            curLexState = jjnewLexState[jjmatchedKind];
2118            continue EOFLoop;
2119         }
2120         jjimageLen += jjmatchedPos + 1;
2121       if (jjnewLexState[jjmatchedKind] != -1)
2122         curLexState = jjnewLexState[jjmatchedKind];
2123         curPos = 0;
2124         jjmatchedKind = 0x7fffffff;
2125         try {
2126            curChar = input_stream.readChar();
2127            continue;
2128         }
2129         catch (java.io.IOException e1) { }
2130      }
2131      int error_line = input_stream.getEndLine();
2132      int error_column = input_stream.getEndColumn();
2133      String error_after = null;
2134      boolean EOFSeen = false;
2135      try { input_stream.readChar(); input_stream.backup(1); }
2136      catch (java.io.IOException e1) {
2137         EOFSeen = true;
2138         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2139         if (curChar == '\n' || curChar == '\r') {
2140            error_line++;
2141            error_column = 0;
2142         }
2143         else
2144            error_column++;
2145      }
2146      if (!EOFSeen) {
2147         input_stream.backup(1);
2148         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2149      }
2150      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2151    }
2152   }
2153 }
2154
2155 static void SkipLexicalActions(Token matchedToken)
2156 {
2157    switch(jjmatchedKind)
2158    {
2159       case 13 :
2160          if (image == null)
2161             image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2162          else
2163             image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2164                    input_stream.backup(1);
2165          break;
2166       case 17 :
2167          if (image == null)
2168             image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2169          else
2170             image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2171          PHPParser.createNewTask();
2172          break;
2173       default :
2174          break;
2175    }
2176 }
2177 static void TokenLexicalActions(Token matchedToken)
2178 {
2179    switch(jjmatchedKind)
2180    {
2181       case 1 :
2182         if (image == null)
2183             image = new StringBuffer(jjstrLiteralImages[1]);
2184          else
2185             image.append(jjstrLiteralImages[1]);
2186                              PHPParser.createNewHTMLCode();
2187          break;
2188       case 2 :
2189         if (image == null)
2190             image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2191          else
2192             image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2193                              PHPParser.createNewHTMLCode();
2194          break;
2195       case 3 :
2196         if (image == null)
2197             image = new StringBuffer(jjstrLiteralImages[3]);
2198          else
2199             image.append(jjstrLiteralImages[3]);
2200                              PHPParser.createNewHTMLCode();
2201          break;
2202       case 4 :
2203         if (image == null)
2204             image = new StringBuffer(jjstrLiteralImages[4]);
2205          else
2206             image.append(jjstrLiteralImages[4]);
2207                   PHPParser.htmlStart = SimpleCharStream.getPosition();
2208          break;
2209       default :
2210          break;
2211    }
2212 }
2213 }