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