net.sourceforge.phpeclipse/src/test/PHPParserTokenManager.java

   1 /* Generated By:JavaCC: Do not edit this line. PHPParserTokenManager.java */
   2 package test;
   3 import org.eclipse.core.resources.IFile;
   4 import org.eclipse.core.resources.IMarker;
   5 import org.eclipse.core.runtime.CoreException;
   6 import org.eclipse.ui.texteditor.MarkerUtilities;
   7 import org.eclipse.jface.preference.IPreferenceStore;
   8 import java.util.Hashtable;
   9 import java.util.ArrayList;
  10 import java.io.StringReader;
  11 import java.io.*;
  12 import java.text.MessageFormat;
  13 import net.sourceforge.phpeclipse.actions.PHPStartApacheAction;
  14 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  15 import net.sourceforge.phpdt.internal.compiler.ast.*;
  16 import net.sourceforge.phpdt.internal.compiler.parser.OutlineableWithChildren;
  17 import net.sourceforge.phpdt.internal.compiler.parser.Outlineable;
  18 import net.sourceforge.phpdt.internal.compiler.parser.PHPOutlineInfo;
  19 import net.sourceforge.phpdt.internal.corext.Assert;
  20
  21 public class PHPParserTokenManager implements PHPParserConstants
  22 {
  23   // CommonTokenAction: use the begins/ends fields added to the Jack
  24   // CharStream class to set corresponding fields in each Token (which was
  25   // also extended with new fields). By default Jack doesn't supply absolute
  26   // offsets, just line/column offsets
  27   static void CommonTokenAction(Token t) {
  28     t.sourceStart = input_stream.beginOffset;
  29     t.sourceEnd = input_stream.endOffset;
  30   }
  31   public static  java.io.PrintStream debugStream = System.out;
  32   public static  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  33 static private final int jjStopAtPos(int pos, int kind)
  34 {
  35    jjmatchedKind = kind;
  36    jjmatchedPos = pos;
  37    return pos + 1;
  38 }
  39 static private final int jjMoveStringLiteralDfa0_5()
  40 {
  41    switch(curChar)
  42    {
  43       case 42:
  44          return jjMoveStringLiteralDfa1_5(0x2000000L);
  45       case 84:
  46       case 116:
  47          return jjMoveStringLiteralDfa1_5(0x400000L);
  48       default :
  49          return 1;
  50    }
  51 }
  52 static private final int jjMoveStringLiteralDfa1_5(long active0)
  53 {
  54    try { curChar = input_stream.readChar(); }
  55    catch(java.io.IOException e) {
  56       return 1;
  57    }
  58    switch(curChar)
  59    {
  60       case 47:
  61          if ((active0 & 0x2000000L) != 0L)
  62             return jjStopAtPos(1, 25);
  63          break;
  64       case 79:
  65       case 111:
  66          return jjMoveStringLiteralDfa2_5(active0, 0x400000L);
  67       default :
  68          return 2;
  69    }
  70    return 2;
  71 }
  72 static private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
  73 {
  74    if (((active0 &= old0)) == 0L)
  75       return 2;
  76    try { curChar = input_stream.readChar(); }
  77    catch(java.io.IOException e) {
  78       return 2;
  79    }
  80    switch(curChar)
  81    {
  82       case 68:
  83       case 100:
  84          return jjMoveStringLiteralDfa3_5(active0, 0x400000L);
  85       default :
  86          return 3;
  87    }
  88 }
  89 static private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
  90 {
  91    if (((active0 &= old0)) == 0L)
  92       return 3;
  93    try { curChar = input_stream.readChar(); }
  94    catch(java.io.IOException e) {
  95       return 3;
  96    }
  97    switch(curChar)
  98    {
  99       case 79:
 100       case 111:
 101          if ((active0 & 0x400000L) != 0L)
 102             return jjStopAtPos(3, 22);
 103          break;
 104       default :
 105          return 4;
 106    }
 107    return 4;
 108 }
 109 static private final int jjMoveStringLiteralDfa0_8()
 110 {
 111    switch(curChar)
 112    {
 113       case 125:
 114          return jjStopAtPos(0, 117);
 115       default :
 116          return 1;
 117    }
 118 }
 119 private static final int jjStopStringLiteralDfa_9(int pos, long active0, long active1)
 120 {
 121    switch (pos)
 122    {
 123       default :
 124          return -1;
 125    }
 126 }
 127 private static final int jjStartNfa_9(int pos, long active0, long active1)
 128 {
 129    return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0, active1), pos + 1);
 130 }
 131 static private final int jjStartNfaWithStates_9(int pos, int kind, int state)
 132 {
 133    jjmatchedKind = kind;
 134    jjmatchedPos = pos;
 135    try { curChar = input_stream.readChar(); }
 136    catch(java.io.IOException e) { return pos + 1; }
 137    return jjMoveNfa_9(state, pos + 1);
 138 }
 139 static private final int jjMoveStringLiteralDfa0_9()
 140 {
 141    switch(curChar)
 142    {
 143       case 125:
 144          return jjStopAtPos(0, 119);
 145       default :
 146          return jjMoveNfa_9(0, 0);
 147    }
 148 }
 149 static private final void jjCheckNAdd(int state)
 150 {
 151    if (jjrounds[state] != jjround)
 152    {
 153       jjstateSet[jjnewStateCnt++] = state;
 154       jjrounds[state] = jjround;
 155    }
 156 }
 157 static private final void jjAddStates(int start, int end)
 158 {
 159    do {
 160       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 161    } while (start++ != end);
 162 }
 163 static private final void jjCheckNAddTwoStates(int state1, int state2)
 164 {
 165    jjCheckNAdd(state1);
 166    jjCheckNAdd(state2);
 167 }
 168 static private final void jjCheckNAddStates(int start, int end)
 169 {
 170    do {
 171       jjCheckNAdd(jjnextStates[start]);
 172    } while (start++ != end);
 173 }
 174 static private final void jjCheckNAddStates(int start)
 175 {
 176    jjCheckNAdd(jjnextStates[start]);
 177    jjCheckNAdd(jjnextStates[start + 1]);
 178 }
 179 static final long[] jjbitVec0 = {
 180    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 181 };
 182 static private final int jjMoveNfa_9(int startState, int curPos)
 183 {
 184    int[] nextStates;
 185    int startsAt = 0;
 186    jjnewStateCnt = 1;
 187    int i = 1;
 188    jjstateSet[0] = startState;
 189    int j, kind = 0x7fffffff;
 190    for (;;)
 191    {
 192       if (++jjround == 0x7fffffff)
 193          ReInitRounds();
 194       if (curChar < 64)
 195       {
 196          long l = 1L << curChar;
 197          MatchLoop: do
 198          {
 199             switch(jjstateSet[--i])
 200             {
 201                case 0:
 202                   kind = 120;
 203                   jjstateSet[jjnewStateCnt++] = 0;
 204                   break;
 205                default : break;
 206             }
 207          } while(i != startsAt);
 208       }
 209       else if (curChar < 128)
 210       {
 211          long l = 1L << (curChar & 077);
 212          MatchLoop: do
 213          {
 214             switch(jjstateSet[--i])
 215             {
 216                case 0:
 217                   if ((0xdfffffffffffffffL & l) == 0L)
 218                      break;
 219                   kind = 120;
 220                   jjstateSet[jjnewStateCnt++] = 0;
 221                   break;
 222                default : break;
 223             }
 224          } while(i != startsAt);
 225       }
 226       else
 227       {
 228          int i2 = (curChar & 0xff) >> 6;
 229          long l2 = 1L << (curChar & 077);
 230          MatchLoop: do
 231          {
 232             switch(jjstateSet[--i])
 233             {
 234                case 0:
 235                   if ((jjbitVec0[i2] & l2) == 0L)
 236                      break;
 237                   if (kind > 120)
 238                      kind = 120;
 239                   jjstateSet[jjnewStateCnt++] = 0;
 240                   break;
 241                default : break;
 242             }
 243          } while(i != startsAt);
 244       }
 245       if (kind != 0x7fffffff)
 246       {
 247          jjmatchedKind = kind;
 248          jjmatchedPos = curPos;
 249          kind = 0x7fffffff;
 250       }
 251       ++curPos;
 252       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
 253          return curPos;
 254       try { curChar = input_stream.readChar(); }
 255       catch(java.io.IOException e) { return curPos; }
 256    }
 257 }
 258 static private final int jjMoveStringLiteralDfa0_0()
 259 {
 260    switch(curChar)
 261    {
 262       case 60:
 263          return jjMoveStringLiteralDfa1_0(0xeL);
 264       case 84:
 265       case 116:
 266          return jjMoveStringLiteralDfa1_0(0x800000L);
 267       default :
 268          return 1;
 269    }
 270 }
 271 static private final int jjMoveStringLiteralDfa1_0(long active0)
 272 {
 273    try { curChar = input_stream.readChar(); }
 274    catch(java.io.IOException e) {
 275       return 1;
 276    }
 277    switch(curChar)
 278    {
 279       case 63:
 280          if ((active0 & 0x2L) != 0L)
 281          {
 282             jjmatchedKind = 1;
 283             jjmatchedPos = 1;
 284          }
 285          return jjMoveStringLiteralDfa2_0(active0, 0xcL);
 286       case 79:
 287       case 111:
 288          return jjMoveStringLiteralDfa2_0(active0, 0x800000L);
 289       default :
 290          return 2;
 291    }
 292 }
 293 static private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
 294 {
 295    if (((active0 &= old0)) == 0L)
 296       return 2;
 297    try { curChar = input_stream.readChar(); }
 298    catch(java.io.IOException e) {
 299       return 2;
 300    }
 301    switch(curChar)
 302    {
 303       case 61:
 304          if ((active0 & 0x8L) != 0L)
 305             return jjStopAtPos(2, 3);
 306          break;
 307       case 68:
 308       case 100:
 309          return jjMoveStringLiteralDfa3_0(active0, 0x800000L);
 310       case 80:
 311       case 112:
 312          return jjMoveStringLiteralDfa3_0(active0, 0x4L);
 313       default :
 314          return 3;
 315    }
 316    return 3;
 317 }
 318 static private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
 319 {
 320    if (((active0 &= old0)) == 0L)
 321       return 3;
 322    try { curChar = input_stream.readChar(); }
 323    catch(java.io.IOException e) {
 324       return 3;
 325    }
 326    switch(curChar)
 327    {
 328       case 72:
 329       case 104:
 330          return jjMoveStringLiteralDfa4_0(active0, 0x4L);
 331       case 79:
 332       case 111:
 333          if ((active0 & 0x800000L) != 0L)
 334             return jjStopAtPos(3, 23);
 335          break;
 336       default :
 337          return 4;
 338    }
 339    return 4;
 340 }
 341 static private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
 342 {
 343    if (((active0 &= old0)) == 0L)
 344       return 4;
 345    try { curChar = input_stream.readChar(); }
 346    catch(java.io.IOException e) {
 347       return 4;
 348    }
 349    switch(curChar)
 350    {
 351       case 80:
 352       case 112:
 353          if ((active0 & 0x4L) != 0L)
 354             return jjStopAtPos(4, 2);
 355          break;
 356       default :
 357          return 5;
 358    }
 359    return 5;
 360 }
 361 static private final int jjMoveStringLiteralDfa0_4()
 362 {
 363    switch(curChar)
 364    {
 365       case 42:
 366          return jjMoveStringLiteralDfa1_4(0x1000000L);
 367       case 84:
 368       case 116:
 369          return jjMoveStringLiteralDfa1_4(0x400000L);
 370       default :
 371          return 1;
 372    }
 373 }
 374 static private final int jjMoveStringLiteralDfa1_4(long active0)
 375 {
 376    try { curChar = input_stream.readChar(); }
 377    catch(java.io.IOException e) {
 378       return 1;
 379    }
 380    switch(curChar)
 381    {
 382       case 47:
 383          if ((active0 & 0x1000000L) != 0L)
 384             return jjStopAtPos(1, 24);
 385          break;
 386       case 79:
 387       case 111:
 388          return jjMoveStringLiteralDfa2_4(active0, 0x400000L);
 389       default :
 390          return 2;
 391    }
 392    return 2;
 393 }
 394 static private final int jjMoveStringLiteralDfa2_4(long old0, long active0)
 395 {
 396    if (((active0 &= old0)) == 0L)
 397       return 2;
 398    try { curChar = input_stream.readChar(); }
 399    catch(java.io.IOException e) {
 400       return 2;
 401    }
 402    switch(curChar)
 403    {
 404       case 68:
 405       case 100:
 406          return jjMoveStringLiteralDfa3_4(active0, 0x400000L);
 407       default :
 408          return 3;
 409    }
 410 }
 411 static private final int jjMoveStringLiteralDfa3_4(long old0, long active0)
 412 {
 413    if (((active0 &= old0)) == 0L)
 414       return 3;
 415    try { curChar = input_stream.readChar(); }
 416    catch(java.io.IOException e) {
 417       return 3;
 418    }
 419    switch(curChar)
 420    {
 421       case 79:
 422       case 111:
 423          if ((active0 & 0x400000L) != 0L)
 424             return jjStopAtPos(3, 22);
 425          break;
 426       default :
 427          return 4;
 428    }
 429    return 4;
 430 }
 431 private static final int jjStopStringLiteralDfa_3(int pos, long active0, long active1, long active2)
 432 {
 433    switch (pos)
 434    {
 435       case 0:
 436          if ((active1 & 0x3000000000L) != 0L)
 437          {
 438             jjmatchedKind = 124;
 439             return 1;
 440          }
 441          return -1;
 442       case 1:
 443          if ((active1 & 0x1000000000L) != 0L)
 444             return 1;
 445          if ((active1 & 0x2000000000L) != 0L)
 446          {
 447             if (jjmatchedPos != 1)
 448             {
 449                jjmatchedKind = 124;
 450                jjmatchedPos = 1;
 451             }
 452             return 1;
 453          }
 454          return -1;
 455       default :
 456          return -1;
 457    }
 458 }
 459 private static final int jjStartNfa_3(int pos, long active0, long active1, long active2)
 460 {
 461    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1, active2), pos + 1);
 462 }
 463 static private final int jjStartNfaWithStates_3(int pos, int kind, int state)
 464 {
 465    jjmatchedKind = kind;
 466    jjmatchedPos = pos;
 467    try { curChar = input_stream.readChar(); }
 468    catch(java.io.IOException e) { return pos + 1; }
 469    return jjMoveNfa_3(state, pos + 1);
 470 }
 471 static private final int jjMoveStringLiteralDfa0_3()
 472 {
 473    switch(curChar)
 474    {
 475       case 9:
 476          return jjStopAtPos(0, 12);
 477       case 10:
 478          return jjStopAtPos(0, 13);
 479       case 12:
 480          return jjStopAtPos(0, 15);
 481       case 13:
 482          return jjStopAtPos(0, 14);
 483       case 32:
 484          return jjStopAtPos(0, 11);
 485       case 33:
 486          jjmatchedKind = 81;
 487          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x28000L);
 488       case 36:
 489          return jjStopAtPos(0, 123);
 490       case 37:
 491          jjmatchedKind = 96;
 492          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x10000000L);
 493       case 38:
 494          jjmatchedKind = 93;
 495          return jjMoveStringLiteralDfa1_3(0x0L, 0x400000L, 0x1000000L);
 496       case 40:
 497          return jjStopAtPos(0, 129);
 498       case 41:
 499          return jjStopAtPos(0, 130);
 500       case 42:
 501          jjmatchedKind = 91;
 502          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x400000L);
 503       case 43:
 504          jjmatchedKind = 89;
 505          return jjMoveStringLiteralDfa1_3(0x0L, 0x800000L, 0x100000L);
 506       case 44:
 507          return jjStopAtPos(0, 136);
 508       case 45:
 509          jjmatchedKind = 90;
 510          return jjMoveStringLiteralDfa1_3(0x200000000000L, 0x1000000L, 0x200000L);
 511       case 46:
 512          jjmatchedKind = 137;
 513          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x8000000L);
 514       case 47:
 515          jjmatchedKind = 92;
 516          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x800000L);
 517       case 58:
 518          jjmatchedKind = 84;
 519          return jjMoveStringLiteralDfa1_3(0x400000000000L, 0x0L, 0x0L);
 520       case 59:
 521          return jjStopAtPos(0, 135);
 522       case 60:
 523          jjmatchedKind = 139;
 524          return jjMoveStringLiteralDfa1_3(0x0L, 0x200000000L, 0x40012000L);
 525       case 61:
 526          jjmatchedKind = 147;
 527          return jjMoveStringLiteralDfa1_3(0x800000000000L, 0x0L, 0x41000L);
 528       case 62:
 529          jjmatchedKind = 138;
 530          return jjMoveStringLiteralDfa1_3(0x0L, 0xc00000000L, 0x80004000L);
 531       case 63:
 532          jjmatchedKind = 83;
 533          return jjMoveStringLiteralDfa1_3(0x10L, 0x0L, 0x0L);
 534       case 64:
 535          return jjStopAtPos(0, 80);
 536       case 91:
 537          return jjStopAtPos(0, 133);
 538       case 93:
 539          return jjStopAtPos(0, 134);
 540       case 94:
 541          jjmatchedKind = 95;
 542          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x4000000L);
 543       case 65:
 544       case 97:
 545          return jjMoveStringLiteralDfa1_3(0x0L, 0x2000000000L, 0x0L);
 546       case 79:
 547       case 111:
 548          return jjMoveStringLiteralDfa1_3(0x0L, 0x1000000000L, 0x0L);
 549       case 123:
 550          return jjStopAtPos(0, 131);
 551       case 124:
 552          jjmatchedKind = 94;
 553          return jjMoveStringLiteralDfa1_3(0x0L, 0x200000L, 0x2000000L);
 554       case 125:
 555          return jjStopAtPos(0, 132);
 556       case 126:
 557          jjmatchedKind = 82;
 558          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x20000000L);
 559       default :
 560          return jjMoveNfa_3(0, 0);
 561    }
 562 }
 563 static private final int jjMoveStringLiteralDfa1_3(long active0, long active1, long active2)
 564 {
 565    try { curChar = input_stream.readChar(); }
 566    catch(java.io.IOException e) {
 567       jjStopStringLiteralDfa_3(0, active0, active1, active2);
 568       return 1;
 569    }
 570    switch(curChar)
 571    {
 572       case 38:
 573          if ((active1 & 0x400000L) != 0L)
 574             return jjStopAtPos(1, 86);
 575          break;
 576       case 43:
 577          if ((active1 & 0x800000L) != 0L)
 578             return jjStopAtPos(1, 87);
 579          break;
 580       case 45:
 581          if ((active1 & 0x1000000L) != 0L)
 582             return jjStopAtPos(1, 88);
 583          break;
 584       case 58:
 585          if ((active0 & 0x400000000000L) != 0L)
 586             return jjStopAtPos(1, 46);
 587          break;
 588       case 60:
 589          if ((active1 & 0x200000000L) != 0L)
 590          {
 591             jjmatchedKind = 97;
 592             jjmatchedPos = 1;
 593          }
 594          return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0x40000000L);
 595       case 61:
 596          if ((active2 & 0x1000L) != 0L)
 597          {
 598             jjmatchedKind = 140;
 599             jjmatchedPos = 1;
 600          }
 601          else if ((active2 & 0x2000L) != 0L)
 602             return jjStopAtPos(1, 141);
 603          else if ((active2 & 0x4000L) != 0L)
 604             return jjStopAtPos(1, 142);
 605          else if ((active2 & 0x8000L) != 0L)
 606          {
 607             jjmatchedKind = 143;
 608             jjmatchedPos = 1;
 609          }
 610          else if ((active2 & 0x100000L) != 0L)
 611             return jjStopAtPos(1, 148);
 612          else if ((active2 & 0x200000L) != 0L)
 613             return jjStopAtPos(1, 149);
 614          else if ((active2 & 0x400000L) != 0L)
 615             return jjStopAtPos(1, 150);
 616          else if ((active2 & 0x800000L) != 0L)
 617             return jjStopAtPos(1, 151);
 618          else if ((active2 & 0x1000000L) != 0L)
 619             return jjStopAtPos(1, 152);
 620          else if ((active2 & 0x2000000L) != 0L)
 621             return jjStopAtPos(1, 153);
 622          else if ((active2 & 0x4000000L) != 0L)
 623             return jjStopAtPos(1, 154);
 624          else if ((active2 & 0x8000000L) != 0L)
 625             return jjStopAtPos(1, 155);
 626          else if ((active2 & 0x10000000L) != 0L)
 627             return jjStopAtPos(1, 156);
 628          else if ((active2 & 0x20000000L) != 0L)
 629             return jjStopAtPos(1, 157);
 630          return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0x60000L);
 631       case 62:
 632          if ((active0 & 0x10L) != 0L)
 633             return jjStopAtPos(1, 4);
 634          else if ((active0 & 0x200000000000L) != 0L)
 635             return jjStopAtPos(1, 45);
 636          else if ((active0 & 0x800000000000L) != 0L)
 637             return jjStopAtPos(1, 47);
 638          else if ((active1 & 0x400000000L) != 0L)
 639          {
 640             jjmatchedKind = 98;
 641             jjmatchedPos = 1;
 642          }
 643          else if ((active2 & 0x10000L) != 0L)
 644             return jjStopAtPos(1, 144);
 645          return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0x800000000L, active2, 0x80000000L);
 646       case 78:
 647       case 110:
 648          return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0x2000000000L, active2, 0L);
 649       case 82:
 650       case 114:
 651          if ((active1 & 0x1000000000L) != 0L)
 652             return jjStartNfaWithStates_3(1, 100, 1);
 653          break;
 654       case 124:
 655          if ((active1 & 0x200000L) != 0L)
 656             return jjStopAtPos(1, 85);
 657          break;
 658       default :
 659          break;
 660    }
 661    return jjStartNfa_3(0, active0, active1, active2);
 662 }
 663 static private final int jjMoveStringLiteralDfa2_3(long old0, long active0, long old1, long active1, long old2, long active2)
 664 {
 665    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
 666       return jjStartNfa_3(0, old0, old1, old2);
 667    try { curChar = input_stream.readChar(); }
 668    catch(java.io.IOException e) {
 669       jjStopStringLiteralDfa_3(1, 0L, active1, active2);
 670       return 2;
 671    }
 672    switch(curChar)
 673    {
 674       case 61:
 675          if ((active2 & 0x20000L) != 0L)
 676             return jjStopAtPos(2, 145);
 677          else if ((active2 & 0x40000L) != 0L)
 678             return jjStopAtPos(2, 146);
 679          else if ((active2 & 0x40000000L) != 0L)
 680             return jjStopAtPos(2, 158);
 681          else if ((active2 & 0x80000000L) != 0L)
 682             return jjStopAtPos(2, 159);
 683          break;
 684       case 62:
 685          if ((active1 & 0x800000000L) != 0L)
 686             return jjStopAtPos(2, 99);
 687          break;
 688       case 68:
 689       case 100:
 690          if ((active1 & 0x2000000000L) != 0L)
 691             return jjStartNfaWithStates_3(2, 101, 1);
 692          break;
 693       default :
 694          break;
 695    }
 696    return jjStartNfa_3(1, 0L, active1, active2);
 697 }
 698 static private final int jjMoveNfa_3(int startState, int curPos)
 699 {
 700    int[] nextStates;
 701    int startsAt = 0;
 702    jjnewStateCnt = 2;
 703    int i = 1;
 704    jjstateSet[0] = startState;
 705    int j, kind = 0x7fffffff;
 706    for (;;)
 707    {
 708       if (++jjround == 0x7fffffff)
 709          ReInitRounds();
 710       if (curChar < 64)
 711       {
 712          long l = 1L << curChar;
 713          MatchLoop: do
 714          {
 715             switch(jjstateSet[--i])
 716             {
 717                case 1:
 718                   if ((0x3ff000000000000L & l) == 0L)
 719                      break;
 720                   kind = 124;
 721                   jjstateSet[jjnewStateCnt++] = 1;
 722                   break;
 723                default : break;
 724             }
 725          } while(i != startsAt);
 726       }
 727       else if (curChar < 128)
 728       {
 729          long l = 1L << (curChar & 077);
 730          MatchLoop: do
 731          {
 732             switch(jjstateSet[--i])
 733             {
 734                case 0:
 735                case 1:
 736                   if ((0x87fffffe87fffffeL & l) == 0L)
 737                      break;
 738                   if (kind > 124)
 739                      kind = 124;
 740                   jjCheckNAdd(1);
 741                   break;
 742                default : break;
 743             }
 744          } while(i != startsAt);
 745       }
 746       else
 747       {
 748          int i2 = (curChar & 0xff) >> 6;
 749          long l2 = 1L << (curChar & 077);
 750          MatchLoop: do
 751          {
 752             switch(jjstateSet[--i])
 753             {
 754                case 0:
 755                case 1:
 756                   if ((jjbitVec0[i2] & l2) == 0L)
 757                      break;
 758                   if (kind > 124)
 759                      kind = 124;
 760                   jjCheckNAdd(1);
 761                   break;
 762                default : break;
 763             }
 764          } while(i != startsAt);
 765       }
 766       if (kind != 0x7fffffff)
 767       {
 768          jjmatchedKind = kind;
 769          jjmatchedPos = curPos;
 770          kind = 0x7fffffff;
 771       }
 772       ++curPos;
 773       if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
 774          return curPos;
 775       try { curChar = input_stream.readChar(); }
 776       catch(java.io.IOException e) { return curPos; }
 777    }
 778 }
 779 private static final int jjStopStringLiteralDfa_6(int pos, long active0, long active1)
 780 {
 781    switch (pos)
 782    {
 783       default :
 784          return -1;
 785    }
 786 }
 787 private static final int jjStartNfa_6(int pos, long active0, long active1)
 788 {
 789    return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1);
 790 }
 791 static private final int jjStartNfaWithStates_6(int pos, int kind, int state)
 792 {
 793    jjmatchedKind = kind;
 794    jjmatchedPos = pos;
 795    try { curChar = input_stream.readChar(); }
 796    catch(java.io.IOException e) { return pos + 1; }
 797    return jjMoveNfa_6(state, pos + 1);
 798 }
 799 static private final int jjMoveStringLiteralDfa0_6()
 800 {
 801    switch(curChar)
 802    {
 803       case 34:
 804          return jjStopAtPos(0, 114);
 805       case 36:
 806          return jjStopAtPos(0, 113);
 807       case 123:
 808          return jjStopAtPos(0, 116);
 809       default :
 810          return jjMoveNfa_6(0, 0);
 811    }
 812 }
 813 static private final int jjMoveNfa_6(int startState, int curPos)
 814 {
 815    int[] nextStates;
 816    int startsAt = 0;
 817    jjnewStateCnt = 2;
 818    int i = 1;
 819    jjstateSet[0] = startState;
 820    int j, kind = 0x7fffffff;
 821    for (;;)
 822    {
 823       if (++jjround == 0x7fffffff)
 824          ReInitRounds();
 825       if (curChar < 64)
 826       {
 827          long l = 1L << curChar;
 828          MatchLoop: do
 829          {
 830             switch(jjstateSet[--i])
 831             {
 832                case 1:
 833                   kind = 111;
 834                   break;
 835                default : break;
 836             }
 837          } while(i != startsAt);
 838       }
 839       else if (curChar < 128)
 840       {
 841          long l = 1L << (curChar & 077);
 842          MatchLoop: do
 843          {
 844             switch(jjstateSet[--i])
 845             {
 846                case 0:
 847                   if (curChar == 92)
 848                      jjstateSet[jjnewStateCnt++] = 1;
 849                   break;
 850                case 1:
 851                   if (kind > 111)
 852                      kind = 111;
 853                   break;
 854                default : break;
 855             }
 856          } while(i != startsAt);
 857       }
 858       else
 859       {
 860          int i2 = (curChar & 0xff) >> 6;
 861          long l2 = 1L << (curChar & 077);
 862          MatchLoop: do
 863          {
 864             switch(jjstateSet[--i])
 865             {
 866                case 1:
 867                   if ((jjbitVec0[i2] & l2) != 0L && kind > 111)
 868                      kind = 111;
 869                   break;
 870                default : break;
 871             }
 872          } while(i != startsAt);
 873       }
 874       if (kind != 0x7fffffff)
 875       {
 876          jjmatchedKind = kind;
 877          jjmatchedPos = curPos;
 878          kind = 0x7fffffff;
 879       }
 880       ++curPos;
 881       if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
 882          return curPos;
 883       try { curChar = input_stream.readChar(); }
 884       catch(java.io.IOException e) { return curPos; }
 885    }
 886 }
 887 private static final int jjStopStringLiteralDfa_2(int pos, long active0)
 888 {
 889    switch (pos)
 890    {
 891       default :
 892          return -1;
 893    }
 894 }
 895 private static final int jjStartNfa_2(int pos, long active0)
 896 {
 897    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
 898 }
 899 static private final int jjStartNfaWithStates_2(int pos, int kind, int state)
 900 {
 901    jjmatchedKind = kind;
 902    jjmatchedPos = pos;
 903    try { curChar = input_stream.readChar(); }
 904    catch(java.io.IOException e) { return pos + 1; }
 905    return jjMoveNfa_2(state, pos + 1);
 906 }
 907 static private final int jjMoveStringLiteralDfa0_2()
 908 {
 909    switch(curChar)
 910    {
 911       case 63:
 912          return jjMoveStringLiteralDfa1_2(0x10L);
 913       case 84:
 914       case 116:
 915          return jjMoveStringLiteralDfa1_2(0x400000L);
 916       default :
 917          return jjMoveNfa_2(0, 0);
 918    }
 919 }
 920 static private final int jjMoveStringLiteralDfa1_2(long active0)
 921 {
 922    try { curChar = input_stream.readChar(); }
 923    catch(java.io.IOException e) {
 924       jjStopStringLiteralDfa_2(0, active0);
 925       return 1;
 926    }
 927    switch(curChar)
 928    {
 929       case 62:
 930          if ((active0 & 0x10L) != 0L)
 931             return jjStopAtPos(1, 4);
 932          break;
 933       case 79:
 934       case 111:
 935          return jjMoveStringLiteralDfa2_2(active0, 0x400000L);
 936       default :
 937          break;
 938    }
 939    return jjStartNfa_2(0, active0);
 940 }
 941 static private final int jjMoveStringLiteralDfa2_2(long old0, long active0)
 942 {
 943    if (((active0 &= old0)) == 0L)
 944       return jjStartNfa_2(0, old0);
 945    try { curChar = input_stream.readChar(); }
 946    catch(java.io.IOException e) {
 947       jjStopStringLiteralDfa_2(1, active0);
 948       return 2;
 949    }
 950    switch(curChar)
 951    {
 952       case 68:
 953       case 100:
 954          return jjMoveStringLiteralDfa3_2(active0, 0x400000L);
 955       default :
 956          break;
 957    }
 958    return jjStartNfa_2(1, active0);
 959 }
 960 static private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
 961 {
 962    if (((active0 &= old0)) == 0L)
 963       return jjStartNfa_2(1, old0);
 964    try { curChar = input_stream.readChar(); }
 965    catch(java.io.IOException e) {
 966       jjStopStringLiteralDfa_2(2, active0);
 967       return 3;
 968    }
 969    switch(curChar)
 970    {
 971       case 79:
 972       case 111:
 973          if ((active0 & 0x400000L) != 0L)
 974             return jjStopAtPos(3, 22);
 975          break;
 976       default :
 977          break;
 978    }
 979    return jjStartNfa_2(2, active0);
 980 }
 981 static private final int jjMoveNfa_2(int startState, int curPos)
 982 {
 983    int[] nextStates;
 984    int startsAt = 0;
 985    jjnewStateCnt = 3;
 986    int i = 1;
 987    jjstateSet[0] = startState;
 988    int j, kind = 0x7fffffff;
 989    for (;;)
 990    {
 991       if (++jjround == 0x7fffffff)
 992          ReInitRounds();
 993       if (curChar < 64)
 994       {
 995          long l = 1L << curChar;
 996          MatchLoop: do
 997          {
 998             switch(jjstateSet[--i])
 999             {
1000                case 0:
1001                   if ((0x2400L & l) != 0L)
1002                   {
1003                      if (kind > 20)
1004                         kind = 20;
1005                   }
1006                   if (curChar == 13)
1007                      jjstateSet[jjnewStateCnt++] = 1;
1008                   break;
1009                case 1:
1010                   if (curChar == 10 && kind > 20)
1011                      kind = 20;
1012                   break;
1013                case 2:
1014                   if (curChar == 13)
1015                      jjstateSet[jjnewStateCnt++] = 1;
1016                   break;
1017                default : break;
1018             }
1019          } while(i != startsAt);
1020       }
1021       else if (curChar < 128)
1022       {
1023          long l = 1L << (curChar & 077);
1024          MatchLoop: do
1025          {
1026             switch(jjstateSet[--i])
1027             {
1028                default : break;
1029             }
1030          } while(i != startsAt);
1031       }
1032       else
1033       {
1034          int i2 = (curChar & 0xff) >> 6;
1035          long l2 = 1L << (curChar & 077);
1036          MatchLoop: do
1037          {
1038             switch(jjstateSet[--i])
1039             {
1040                default : break;
1041             }
1042          } while(i != startsAt);
1043       }
1044       if (kind != 0x7fffffff)
1045       {
1046          jjmatchedKind = kind;
1047          jjmatchedPos = curPos;
1048          kind = 0x7fffffff;
1049       }
1050       ++curPos;
1051       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1052          return curPos;
1053       try { curChar = input_stream.readChar(); }
1054       catch(java.io.IOException e) { return curPos; }
1055    }
1056 }
1057 private static final int jjStopStringLiteralDfa_1(int pos, long active0, long active1, long active2)
1058 {
1059    switch (pos)
1060    {
1061       case 0:
1062          if ((active0 & 0xffff1ffff8000000L) != 0L || (active1 & 0x300000ffffL) != 0L)
1063          {
1064             jjmatchedKind = 124;
1065             return 14;
1066          }
1067          if ((active0 & 0x90000L) != 0L || (active1 & 0x10000000L) != 0L || (active2 & 0x800000L) != 0L)
1068             return 2;
1069          if ((active2 & 0x8000200L) != 0L)
1070             return 8;
1071          return -1;
1072       case 1:
1073          if ((active0 & 0x80000L) != 0L)
1074             return 0;
1075          if ((active0 & 0x10000040000000L) != 0L || (active1 & 0x1000001040L) != 0L)
1076             return 14;
1077          if ((active0 & 0xffef1fffb8000000L) != 0L || (active1 & 0x200000efbfL) != 0L)
1078          {
1079             if (jjmatchedPos != 1)
1080             {
1081                jjmatchedKind = 124;
1082                jjmatchedPos = 1;
1083             }
1084             return 14;
1085          }
1086          return -1;
1087       case 2:
1088          if ((active0 & 0x140000020000000L) != 0L || (active1 & 0x200000c020L) != 0L)
1089             return 14;
1090          if ((active0 & 0xfeaf1fff98000000L) != 0L || (active1 & 0x3f9fL) != 0L)
1091          {
1092             if (jjmatchedPos != 2)
1093             {
1094                jjmatchedKind = 124;
1095                jjmatchedPos = 2;
1096             }
1097             return 14;
1098          }
1099          return -1;
1100       case 3:
1101          if ((active0 & 0x9c2e1fd618000000L) != 0L || (active1 & 0xb1bfL) != 0L)
1102          {
1103             if (jjmatchedPos != 3)
1104             {
1105                jjmatchedKind = 124;
1106                jjmatchedPos = 3;
1107             }
1108             return 14;
1109          }
1110          if ((active0 & 0x6281002980000000L) != 0L || (active1 & 0xe00L) != 0L)
1111             return 14;
1112          return -1;
1113       case 4:
1114          if ((active0 & 0x8802001608000000L) != 0L || (active1 & 0x2009L) != 0L)
1115             return 14;
1116          if ((active0 & 0x142c1fc090000000L) != 0L || (active1 & 0x95b6L) != 0L)
1117          {
1118             jjmatchedKind = 124;
1119             jjmatchedPos = 4;
1120             return 14;
1121          }
1122          return -1;
1123       case 5:
1124          if ((active0 & 0x14001c0080000000L) != 0L || (active1 & 0x1190L) != 0L)
1125             return 14;
1126          if ((active0 & 0x2c03c010000000L) != 0L || (active1 & 0x8426L) != 0L)
1127          {
1128             jjmatchedKind = 124;
1129             jjmatchedPos = 5;
1130             return 14;
1131          }
1132          return -1;
1133       case 6:
1134          if ((active0 & 0x2803c000000000L) != 0L || (active1 & 0x8420L) != 0L)
1135             return 14;
1136          if ((active0 & 0x4000010000000L) != 0L || (active1 & 0x6L) != 0L)
1137          {
1138             if (jjmatchedPos != 6)
1139             {
1140                jjmatchedKind = 124;
1141                jjmatchedPos = 6;
1142             }
1143             return 14;
1144          }
1145          return -1;
1146       case 7:
1147          if ((active0 & 0x30000000000L) != 0L || (active1 & 0x4L) != 0L)
1148          {
1149             jjmatchedKind = 124;
1150             jjmatchedPos = 7;
1151             return 14;
1152          }
1153          if ((active0 & 0x4000010000000L) != 0L || (active1 & 0x2L) != 0L)
1154             return 14;
1155          return -1;
1156       case 8:
1157          if ((active1 & 0x4L) != 0L)
1158             return 14;
1159          if ((active0 & 0x30000000000L) != 0L)
1160          {
1161             jjmatchedKind = 124;
1162             jjmatchedPos = 8;
1163             return 14;
1164          }
1165          return -1;
1166       case 9:
1167          if ((active0 & 0x30000000000L) != 0L)
1168          {
1169             jjmatchedKind = 124;
1170             jjmatchedPos = 9;
1171             return 14;
1172          }
1173          return -1;
1174       case 10:
1175          if ((active0 & 0x30000000000L) != 0L)
1176          {
1177             jjmatchedKind = 124;
1178             jjmatchedPos = 10;
1179             return 14;
1180          }
1181          return -1;
1182       default :
1183          return -1;
1184    }
1185 }
1186 private static final int jjStartNfa_1(int pos, long active0, long active1, long active2)
1187 {
1188    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1, active2), pos + 1);
1189 }
1190 static private final int jjStartNfaWithStates_1(int pos, int kind, int state)
1191 {
1192    jjmatchedKind = kind;
1193    jjmatchedPos = pos;
1194    try { curChar = input_stream.readChar(); }
1195    catch(java.io.IOException e) { return pos + 1; }
1196    return jjMoveNfa_1(state, pos + 1);
1197 }
1198 static private final int jjMoveStringLiteralDfa0_1()
1199 {
1200    switch(curChar)
1201    {
1202       case 33:
1203          jjmatchedKind = 81;
1204          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x28000L);
1205       case 34:
1206          return jjStopAtPos(0, 112);
1207       case 35:
1208          return jjStopAtPos(0, 17);
1209       case 36:
1210          return jjStopAtPos(0, 123);
1211       case 37:
1212          jjmatchedKind = 96;
1213          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x10000000L);
1214       case 38:
1215          jjmatchedKind = 93;
1216          return jjMoveStringLiteralDfa1_1(0x0L, 0x400000L, 0x1000000L);
1217       case 40:
1218          return jjStopAtPos(0, 129);
1219       case 41:
1220          return jjStopAtPos(0, 130);
1221       case 42:
1222          jjmatchedKind = 91;
1223          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x400000L);
1224       case 43:
1225          jjmatchedKind = 89;
1226          return jjMoveStringLiteralDfa1_1(0x0L, 0x800000L, 0x100000L);
1227       case 44:
1228          return jjStopAtPos(0, 136);
1229       case 45:
1230          jjmatchedKind = 90;
1231          return jjMoveStringLiteralDfa1_1(0x200000000000L, 0x1000000L, 0x200000L);
1232       case 46:
1233          jjmatchedKind = 137;
1234          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x8000000L);
1235       case 47:
1236          jjmatchedKind = 92;
1237          return jjMoveStringLiteralDfa1_1(0x90000L, 0x0L, 0x800000L);
1238       case 58:
1239          jjmatchedKind = 84;
1240          return jjMoveStringLiteralDfa1_1(0x400000000000L, 0x0L, 0x0L);
1241       case 59:
1242          return jjStopAtPos(0, 135);
1243       case 60:
1244          jjmatchedKind = 139;
1245          return jjMoveStringLiteralDfa1_1(0x0L, 0x200000000L, 0x40012000L);
1246       case 61:
1247          jjmatchedKind = 147;
1248          return jjMoveStringLiteralDfa1_1(0x800000000000L, 0x0L, 0x41000L);
1249       case 62:
1250          jjmatchedKind = 138;
1251          return jjMoveStringLiteralDfa1_1(0x0L, 0xc00000000L, 0x80004000L);
1252       case 63:
1253          jjmatchedKind = 83;
1254          return jjMoveStringLiteralDfa1_1(0x10L, 0x0L, 0x0L);
1255       case 64:
1256          return jjStopAtPos(0, 80);
1257       case 91:
1258          return jjStopAtPos(0, 133);
1259       case 93:
1260          return jjStopAtPos(0, 134);
1261       case 94:
1262          jjmatchedKind = 95;
1263          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x4000000L);
1264       case 65:
1265       case 97:
1266          return jjMoveStringLiteralDfa1_1(0x200000000L, 0x2000000040L, 0x0L);
1267       case 66:
1268       case 98:
1269          return jjMoveStringLiteralDfa1_1(0x400000000L, 0x600L, 0x0L);
1270       case 67:
1271       case 99:
1272          return jjMoveStringLiteralDfa1_1(0x7000008000000L, 0x0L, 0x0L);
1273       case 68:
1274       case 100:
1275          return jjMoveStringLiteralDfa1_1(0x18080000000000L, 0x1000L, 0x0L);
1276       case 69:
1277       case 101:
1278          return jjMoveStringLiteralDfa1_1(0x20002180000000L, 0x1eL, 0x0L);
1279       case 70:
1280       case 102:
1281          return jjMoveStringLiteralDfa1_1(0x8040000010000000L, 0x2020L, 0x0L);
1282       case 71:
1283       case 103:
1284          return jjMoveStringLiteralDfa1_1(0x80040000000000L, 0x0L, 0x0L);
1285       case 73:
1286       case 105:
1287          return jjMoveStringLiteralDfa1_1(0x14040000000L, 0xc000L, 0x0L);
1288       case 76:
1289       case 108:
1290          return jjMoveStringLiteralDfa1_1(0x800000000L, 0x0L, 0x0L);
1291       case 78:
1292       case 110:
1293          return jjMoveStringLiteralDfa1_1(0x300000000000000L, 0x0L, 0x0L);
1294       case 79:
1295       case 111:
1296          return jjMoveStringLiteralDfa1_1(0x0L, 0x1000000100L, 0x0L);
1297       case 80:
1298       case 112:
1299          return jjMoveStringLiteralDfa1_1(0x1000000000L, 0x0L, 0x0L);
1300       case 82:
1301       case 114:
1302          return jjMoveStringLiteralDfa1_1(0x400028000000000L, 0x800L, 0x0L);
1303       case 83:
1304       case 115:
1305          return jjMoveStringLiteralDfa1_1(0x1800100000000000L, 0x80L, 0x0L);
1306       case 84:
1307       case 116:
1308          return jjMoveStringLiteralDfa1_1(0x6000000000000000L, 0x0L, 0x0L);
1309       case 86:
1310       case 118:
1311          return jjMoveStringLiteralDfa1_1(0x20000000L, 0x0L, 0x0L);
1312       case 87:
1313       case 119:
1314          return jjMoveStringLiteralDfa1_1(0x0L, 0x1L, 0x0L);
1315       case 123:
1316          return jjStopAtPos(0, 131);
1317       case 124:
1318          jjmatchedKind = 94;
1319          return jjMoveStringLiteralDfa1_1(0x0L, 0x200000L, 0x2000000L);
1320       case 125:
1321          return jjStopAtPos(0, 132);
1322       case 126:
1323          jjmatchedKind = 82;
1324          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x20000000L);
1325       default :
1326          return jjMoveNfa_1(3, 0);
1327    }
1328 }
1329 static private final int jjMoveStringLiteralDfa1_1(long active0, long active1, long active2)
1330 {
1331    try { curChar = input_stream.readChar(); }
1332    catch(java.io.IOException e) {
1333       jjStopStringLiteralDfa_1(0, active0, active1, active2);
1334       return 1;
1335    }
1336    switch(curChar)
1337    {
1338       case 38:
1339          if ((active1 & 0x400000L) != 0L)
1340             return jjStopAtPos(1, 86);
1341          break;
1342       case 42:
1343          if ((active0 & 0x80000L) != 0L)
1344             return jjStartNfaWithStates_1(1, 19, 0);
1345          break;
1346       case 43:
1347          if ((active1 & 0x800000L) != 0L)
1348             return jjStopAtPos(1, 87);
1349          break;
1350       case 45:
1351          if ((active1 & 0x1000000L) != 0L)
1352             return jjStopAtPos(1, 88);
1353          break;
1354       case 47:
1355          if ((active0 & 0x10000L) != 0L)
1356             return jjStopAtPos(1, 16);
1357          break;
1358       case 58:
1359          if ((active0 & 0x400000000000L) != 0L)
1360             return jjStopAtPos(1, 46);
1361          break;
1362       case 60:
1363          if ((active1 & 0x200000000L) != 0L)
1364          {
1365             jjmatchedKind = 97;
1366             jjmatchedPos = 1;
1367          }
1368          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0x40000000L);
1369       case 61:
1370          if ((active2 & 0x1000L) != 0L)
1371          {
1372             jjmatchedKind = 140;
1373             jjmatchedPos = 1;
1374          }
1375          else if ((active2 & 0x2000L) != 0L)
1376             return jjStopAtPos(1, 141);
1377          else if ((active2 & 0x4000L) != 0L)
1378             return jjStopAtPos(1, 142);
1379          else if ((active2 & 0x8000L) != 0L)
1380          {
1381             jjmatchedKind = 143;
1382             jjmatchedPos = 1;
1383          }
1384          else if ((active2 & 0x100000L) != 0L)
1385             return jjStopAtPos(1, 148);
1386          else if ((active2 & 0x200000L) != 0L)
1387             return jjStopAtPos(1, 149);
1388          else if ((active2 & 0x400000L) != 0L)
1389             return jjStopAtPos(1, 150);
1390          else if ((active2 & 0x800000L) != 0L)
1391             return jjStopAtPos(1, 151);
1392          else if ((active2 & 0x1000000L) != 0L)
1393             return jjStopAtPos(1, 152);
1394          else if ((active2 & 0x2000000L) != 0L)
1395             return jjStopAtPos(1, 153);
1396          else if ((active2 & 0x4000000L) != 0L)
1397             return jjStopAtPos(1, 154);
1398          else if ((active2 & 0x8000000L) != 0L)
1399             return jjStopAtPos(1, 155);
1400          else if ((active2 & 0x10000000L) != 0L)
1401             return jjStopAtPos(1, 156);
1402          else if ((active2 & 0x20000000L) != 0L)
1403             return jjStopAtPos(1, 157);
1404          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0x60000L);
1405       case 62:
1406          if ((active0 & 0x10L) != 0L)
1407             return jjStopAtPos(1, 4);
1408          else if ((active0 & 0x200000000000L) != 0L)
1409             return jjStopAtPos(1, 45);
1410          else if ((active0 & 0x800000000000L) != 0L)
1411             return jjStopAtPos(1, 47);
1412          else if ((active1 & 0x400000000L) != 0L)
1413          {
1414             jjmatchedKind = 98;
1415             jjmatchedPos = 1;
1416          }
1417          else if ((active2 & 0x10000L) != 0L)
1418             return jjStopAtPos(1, 144);
1419          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x800000000L, active2, 0x80000000L);
1420       case 65:
1421       case 97:
1422          return jjMoveStringLiteralDfa2_1(active0, 0x8001000020000000L, active1, 0L, active2, 0L);
1423       case 66:
1424       case 98:
1425          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x100L, active2, 0L);
1426       case 67:
1427       case 99:
1428          return jjMoveStringLiteralDfa2_1(active0, 0x2000000000L, active1, 0L, active2, 0L);
1429       case 69:
1430       case 101:
1431          return jjMoveStringLiteralDfa2_1(active0, 0x5080a8000000000L, active1, 0x800L, active2, 0L);
1432       case 70:
1433       case 102:
1434          if ((active0 & 0x40000000L) != 0L)
1435             return jjStartNfaWithStates_1(1, 30, 14);
1436          break;
1437       case 72:
1438       case 104:
1439          return jjMoveStringLiteralDfa2_1(active0, 0x2000000000000000L, active1, 0x1L, active2, 0L);
1440       case 73:
1441       case 105:
1442          return jjMoveStringLiteralDfa2_1(active0, 0x800000000L, active1, 0L, active2, 0L);
1443       case 76:
1444       case 108:
1445          return jjMoveStringLiteralDfa2_1(active0, 0x40188000000L, active1, 0x2000L, active2, 0L);
1446       case 78:
1447       case 110:
1448          return jjMoveStringLiteralDfa2_1(active0, 0x14000000000L, active1, 0x200000c01eL, active2, 0L);
1449       case 79:
1450       case 111:
1451          if ((active0 & 0x10000000000000L) != 0L)
1452          {
1453             jjmatchedKind = 52;
1454             jjmatchedPos = 1;
1455          }
1456          return jjMoveStringLiteralDfa2_1(active0, 0xc6000000000000L, active1, 0x1620L, active2, 0L);
1457       case 82:
1458       case 114:
1459          if ((active1 & 0x1000000000L) != 0L)
1460             return jjStartNfaWithStates_1(1, 100, 14);
1461          return jjMoveStringLiteralDfa2_1(active0, 0x4000001600000000L, active1, 0L, active2, 0L);
1462       case 83:
1463       case 115:
1464          if ((active1 & 0x40L) != 0L)
1465             return jjStartNfaWithStates_1(1, 70, 14);
1466          break;
1467       case 84:
1468       case 116:
1469          return jjMoveStringLiteralDfa2_1(active0, 0x100000000000L, active1, 0x80L, active2, 0L);
1470       case 85:
1471       case 117:
1472          return jjMoveStringLiteralDfa2_1(active0, 0xa00000010000000L, active1, 0L, active2, 0L);
1473       case 87:
1474       case 119:
1475          return jjMoveStringLiteralDfa2_1(active0, 0x1000000000000000L, active1, 0L, active2, 0L);
1476       case 88:
1477       case 120:
1478          return jjMoveStringLiteralDfa2_1(active0, 0x20000000000000L, active1, 0L, active2, 0L);
1479       case 124:
1480          if ((active1 & 0x200000L) != 0L)
1481             return jjStopAtPos(1, 85);
1482          break;
1483       default :
1484          break;
1485    }
1486    return jjStartNfa_1(0, active0, active1, active2);
1487 }
1488 static private final int jjMoveStringLiteralDfa2_1(long old0, long active0, long old1, long active1, long old2, long active2)
1489 {
1490    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1491       return jjStartNfa_1(0, old0, old1, old2);
1492    try { curChar = input_stream.readChar(); }
1493    catch(java.io.IOException e) {
1494       jjStopStringLiteralDfa_1(1, active0, active1, active2);
1495       return 2;
1496    }
1497    switch(curChar)
1498    {
1499       case 61:
1500          if ((active2 & 0x20000L) != 0L)
1501             return jjStopAtPos(2, 145);
1502          else if ((active2 & 0x40000L) != 0L)
1503             return jjStopAtPos(2, 146);
1504          else if ((active2 & 0x40000000L) != 0L)
1505             return jjStopAtPos(2, 158);
1506          else if ((active2 & 0x80000000L) != 0L)
1507             return jjStopAtPos(2, 159);
1508          break;
1509       case 62:
1510          if ((active1 & 0x800000000L) != 0L)
1511             return jjStopAtPos(2, 99);
1512          break;
1513       case 65:
1514       case 97:
1515          return jjMoveStringLiteralDfa3_1(active0, 0x100008000000L, active1, 0x800L, active2, 0L);
1516       case 67:
1517       case 99:
1518          return jjMoveStringLiteralDfa3_1(active0, 0x14000000000L, active1, 0L, active2, 0L);
1519       case 68:
1520       case 100:
1521          if ((active1 & 0x2000000000L) != 0L)
1522             return jjStartNfaWithStates_1(2, 101, 14);
1523          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x1eL, active2, 0L);
1524       case 69:
1525       case 101:
1526          return jjMoveStringLiteralDfa3_1(active0, 0x400000000L, active1, 0L, active2, 0L);
1527       case 70:
1528       case 102:
1529          return jjMoveStringLiteralDfa3_1(active0, 0x8080000000000L, active1, 0L, active2, 0L);
1530       case 72:
1531       case 104:
1532          return jjMoveStringLiteralDfa3_1(active0, 0x2000000000L, active1, 0L, active2, 0L);
1533       case 73:
1534       case 105:
1535          return jjMoveStringLiteralDfa3_1(active0, 0x3000001000000000L, active1, 0x1L, active2, 0L);
1536       case 74:
1537       case 106:
1538          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x100L, active2, 0L);
1539       case 76:
1540       case 108:
1541          return jjMoveStringLiteralDfa3_1(active0, 0x8200000000000000L, active1, 0L, active2, 0L);
1542       case 78:
1543       case 110:
1544          return jjMoveStringLiteralDfa3_1(active0, 0x6000010000000L, active1, 0L, active2, 0L);
1545       case 79:
1546       case 111:
1547          return jjMoveStringLiteralDfa3_1(active0, 0x40000000000L, active1, 0x2600L, active2, 0L);
1548       case 80:
1549       case 112:
1550          return jjMoveStringLiteralDfa3_1(active0, 0x800000000000000L, active1, 0L, active2, 0L);
1551       case 81:
1552       case 113:
1553          return jjMoveStringLiteralDfa3_1(active0, 0x28000000000L, active1, 0L, active2, 0L);
1554       case 82:
1555       case 114:
1556          if ((active0 & 0x20000000L) != 0L)
1557             return jjStartNfaWithStates_1(2, 29, 14);
1558          else if ((active0 & 0x40000000000000L) != 0L)
1559          {
1560             jjmatchedKind = 54;
1561             jjmatchedPos = 2;
1562          }
1563          return jjMoveStringLiteralDfa3_1(active0, 0x200000000L, active1, 0xa0L, active2, 0L);
1564       case 83:
1565       case 115:
1566          return jjMoveStringLiteralDfa3_1(active0, 0x1000980000000L, active1, 0L, active2, 0L);
1567       case 84:
1568       case 116:
1569          if ((active1 & 0x4000L) != 0L)
1570          {
1571             jjmatchedKind = 78;
1572             jjmatchedPos = 2;
1573          }
1574          return jjMoveStringLiteralDfa3_1(active0, 0x4a0000000000000L, active1, 0x8000L, active2, 0L);
1575       case 85:
1576       case 117:
1577          return jjMoveStringLiteralDfa3_1(active0, 0x4000000000000000L, active1, 0x1000L, active2, 0L);
1578       case 87:
1579       case 119:
1580          if ((active0 & 0x100000000000000L) != 0L)
1581             return jjStartNfaWithStates_1(2, 56, 14);
1582          break;
1583       default :
1584          break;
1585    }
1586    return jjStartNfa_1(1, active0, active1, active2);
1587 }
1588 static private final int jjMoveStringLiteralDfa3_1(long old0, long active0, long old1, long active1, long old2, long active2)
1589 {
1590    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1591       return jjStartNfa_1(1, old0, old1, old2);
1592    try { curChar = input_stream.readChar(); }
1593    catch(java.io.IOException e) {
1594       jjStopStringLiteralDfa_1(2, active0, active1, 0L);
1595       return 3;
1596    }
1597    switch(curChar)
1598    {
1599       case 65:
1600       case 97:
1601          return jjMoveStringLiteralDfa4_1(active0, 0x8000600000000L, active1, 0x2000L);
1602       case 66:
1603       case 98:
1604          return jjMoveStringLiteralDfa4_1(active0, 0x40000000000L, active1, 0x1000L);
1605       case 67:
1606       case 99:
1607          return jjMoveStringLiteralDfa4_1(active0, 0x10000000L, active1, 0L);
1608       case 69:
1609       case 101:
1610          if ((active0 & 0x100000000L) != 0L)
1611          {
1612             jjmatchedKind = 32;
1613             jjmatchedPos = 3;
1614          }
1615          else if ((active0 & 0x1000000000000L) != 0L)
1616             return jjStartNfaWithStates_1(3, 48, 14);
1617          else if ((active0 & 0x4000000000000000L) != 0L)
1618             return jjStartNfaWithStates_1(3, 62, 14);
1619          return jjMoveStringLiteralDfa4_1(active0, 0x820000080000000L, active1, 0x8120L);
1620       case 70:
1621       case 102:
1622          return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0x10L);
1623       case 73:
1624       case 105:
1625          return jjMoveStringLiteralDfa4_1(active0, 0x80000000000L, active1, 0x88L);
1626       case 76:
1627       case 108:
1628          if ((active0 & 0x200000000000000L) != 0L)
1629             return jjStartNfaWithStates_1(3, 57, 14);
1630          else if ((active1 & 0x200L) != 0L)
1631          {
1632             jjmatchedKind = 73;
1633             jjmatchedPos = 3;
1634          }
1635          else if ((active1 & 0x800L) != 0L)
1636             return jjStartNfaWithStates_1(3, 75, 14);
1637          return jjMoveStringLiteralDfa4_1(active0, 0x14000000000L, active1, 0x401L);
1638       case 78:
1639       case 110:
1640          return jjMoveStringLiteralDfa4_1(active0, 0x1000000000L, active1, 0L);
1641       case 79:
1642       case 111:
1643          if ((active0 & 0x2000000000L) != 0L)
1644             return jjStartNfaWithStates_1(3, 37, 14);
1645          else if ((active0 & 0x80000000000000L) != 0L)
1646             return jjStartNfaWithStates_1(3, 55, 14);
1647          break;
1648       case 83:
1649       case 115:
1650          if ((active0 & 0x2000000000000000L) != 0L)
1651             return jjStartNfaWithStates_1(3, 61, 14);
1652          return jjMoveStringLiteralDfa4_1(active0, 0x8002000008000000L, active1, 0x4L);
1653       case 84:
1654       case 116:
1655          if ((active0 & 0x800000000L) != 0L)
1656             return jjStartNfaWithStates_1(3, 35, 14);
1657          return jjMoveStringLiteralDfa4_1(active0, 0x1004100000000000L, active1, 0L);
1658       case 85:
1659       case 117:
1660          return jjMoveStringLiteralDfa4_1(active0, 0x400028000000000L, active1, 0L);
1661       case 87:
1662       case 119:
1663          return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0x2L);
1664       default :
1665          break;
1666    }
1667    return jjStartNfa_1(2, active0, active1, 0L);
1668 }
1669 static private final int jjMoveStringLiteralDfa4_1(long old0, long active0, long old1, long active1)
1670 {
1671    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1672       return jjStartNfa_1(2, old0, old1, 0L);
1673    try { curChar = input_stream.readChar(); }
1674    catch(java.io.IOException e) {
1675       jjStopStringLiteralDfa_1(3, active0, active1, 0L);
1676       return 4;
1677    }
1678    switch(curChar)
1679    {
1680       case 65:
1681       case 97:
1682          return jjMoveStringLiteralDfa5_1(active0, 0x40000000000L, active1, 0x20L);
1683       case 67:
1684       case 99:
1685          return jjMoveStringLiteralDfa5_1(active0, 0x1000000000000000L, active1, 0x100L);
1686       case 69:
1687       case 101:
1688          if ((active0 & 0x8000000000000000L) != 0L)
1689             return jjStartNfaWithStates_1(4, 63, 14);
1690          else if ((active1 & 0x1L) != 0L)
1691             return jjStartNfaWithStates_1(4, 64, 14);
1692          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x400L);
1693       case 70:
1694       case 102:
1695          if ((active1 & 0x8L) != 0L)
1696             return jjStartNfaWithStates_1(4, 67, 14);
1697          break;
1698       case 71:
1699       case 103:
1700          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x8000L);
1701       case 72:
1702       case 104:
1703          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x2L);
1704       case 73:
1705       case 105:
1706          return jjMoveStringLiteralDfa5_1(active0, 0x4128080000000L, active1, 0L);
1707       case 75:
1708       case 107:
1709          if ((active0 & 0x400000000L) != 0L)
1710             return jjStartNfaWithStates_1(4, 34, 14);
1711          break;
1712       case 76:
1713       case 108:
1714          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x1000L);
1715       case 78:
1716       case 110:
1717          return jjMoveStringLiteralDfa5_1(active0, 0x20080000000000L, active1, 0x80L);
1718       case 79:
1719       case 111:
1720          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x10L);
1721       case 82:
1722       case 114:
1723          if ((active0 & 0x800000000000000L) != 0L)
1724             return jjStartNfaWithStates_1(4, 59, 14);
1725          return jjMoveStringLiteralDfa5_1(active0, 0x400000000000000L, active1, 0L);
1726       case 83:
1727       case 115:
1728          if ((active0 & 0x8000000L) != 0L)
1729             return jjStartNfaWithStates_1(4, 27, 14);
1730          break;
1731       case 84:
1732       case 116:
1733          if ((active0 & 0x1000000000L) != 0L)
1734             return jjStartNfaWithStates_1(4, 36, 14);
1735          else if ((active0 & 0x2000000000000L) != 0L)
1736             return jjStartNfaWithStates_1(4, 49, 14);
1737          else if ((active1 & 0x2000L) != 0L)
1738             return jjStartNfaWithStates_1(4, 77, 14);
1739          return jjMoveStringLiteralDfa5_1(active0, 0x10000000L, active1, 0L);
1740       case 85:
1741       case 117:
1742          return jjMoveStringLiteralDfa5_1(active0, 0x8014000000000L, active1, 0L);
1743       case 87:
1744       case 119:
1745          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x4L);
1746       case 89:
1747       case 121:
1748          if ((active0 & 0x200000000L) != 0L)
1749             return jjStartNfaWithStates_1(4, 33, 14);
1750          break;
1751       default :
1752          break;
1753    }
1754    return jjStartNfa_1(3, active0, active1, 0L);
1755 }
1756 static private final int jjMoveStringLiteralDfa5_1(long old0, long active0, long old1, long active1)
1757 {
1758    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1759       return jjStartNfa_1(3, old0, old1, 0L);
1760    try { curChar = input_stream.readChar(); }
1761    catch(java.io.IOException e) {
1762       jjStopStringLiteralDfa_1(4, active0, active1, 0L);
1763       return 5;
1764    }
1765    switch(curChar)
1766    {
1767       case 65:
1768       case 97:
1769          return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x400L);
1770       case 67:
1771       case 99:
1772          if ((active0 & 0x100000000000L) != 0L)
1773             return jjStartNfaWithStates_1(5, 44, 14);
1774          return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x20L);
1775       case 68:
1776       case 100:
1777          return jjMoveStringLiteralDfa6_1(active0, 0x20014000000000L, active1, 0L);
1778       case 69:
1779       case 101:
1780          if ((active0 & 0x80000000000L) != 0L)
1781             return jjStartNfaWithStates_1(5, 43, 14);
1782          else if ((active1 & 0x1000L) != 0L)
1783             return jjStartNfaWithStates_1(5, 76, 14);
1784          return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x8000L);
1785       case 70:
1786       case 102:
1787          if ((active0 & 0x80000000L) != 0L)
1788             return jjStartNfaWithStates_1(5, 31, 14);
1789          break;
1790       case 71:
1791       case 103:
1792          if ((active1 & 0x80L) != 0L)
1793             return jjStartNfaWithStates_1(5, 71, 14);
1794          break;
1795       case 72:
1796       case 104:
1797          if ((active0 & 0x1000000000000000L) != 0L)
1798             return jjStartNfaWithStates_1(5, 60, 14);
1799          break;
1800       case 73:
1801       case 105:
1802          return jjMoveStringLiteralDfa6_1(active0, 0x10000000L, active1, 0x6L);
1803       case 76:
1804       case 108:
1805          if ((active0 & 0x40000000000L) != 0L)
1806             return jjStartNfaWithStates_1(5, 42, 14);
1807          return jjMoveStringLiteralDfa6_1(active0, 0x8000000000000L, active1, 0L);
1808       case 78:
1809       case 110:
1810          if ((active0 & 0x400000000000000L) != 0L)
1811             return jjStartNfaWithStates_1(5, 58, 14);
1812          return jjMoveStringLiteralDfa6_1(active0, 0x4000000000000L, active1, 0L);
1813       case 82:
1814       case 114:
1815          if ((active1 & 0x10L) != 0L)
1816             return jjStartNfaWithStates_1(5, 68, 14);
1817          return jjMoveStringLiteralDfa6_1(active0, 0x28000000000L, active1, 0L);
1818       case 84:
1819       case 116:
1820          if ((active1 & 0x100L) != 0L)
1821             return jjStartNfaWithStates_1(5, 72, 14);
1822          break;
1823       default :
1824          break;
1825    }
1826    return jjStartNfa_1(4, active0, active1, 0L);
1827 }
1828 static private final int jjMoveStringLiteralDfa6_1(long old0, long active0, long old1, long active1)
1829 {
1830    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1831       return jjStartNfa_1(4, old0, old1, 0L);
1832    try { curChar = input_stream.readChar(); }
1833    catch(java.io.IOException e) {
1834       jjStopStringLiteralDfa_1(5, active0, active1, 0L);
1835       return 6;
1836    }
1837    switch(curChar)
1838    {
1839       case 69:
1840       case 101:
1841          if ((active0 & 0x4000000000L) != 0L)
1842          {
1843             jjmatchedKind = 38;
1844             jjmatchedPos = 6;
1845          }
1846          else if ((active0 & 0x8000000000L) != 0L)
1847          {
1848             jjmatchedKind = 39;
1849             jjmatchedPos = 6;
1850          }
1851          return jjMoveStringLiteralDfa7_1(active0, 0x30000000000L, active1, 0L);
1852       case 72:
1853       case 104:
1854          if ((active1 & 0x20L) != 0L)
1855             return jjStartNfaWithStates_1(6, 69, 14);
1856          break;
1857       case 76:
1858       case 108:
1859          return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x2L);
1860       case 78:
1861       case 110:
1862          if ((active1 & 0x400L) != 0L)
1863             return jjStartNfaWithStates_1(6, 74, 14);
1864          break;
1865       case 79:
1866       case 111:
1867          return jjMoveStringLiteralDfa7_1(active0, 0x10000000L, active1, 0L);
1868       case 82:
1869       case 114:
1870          if ((active1 & 0x8000L) != 0L)
1871             return jjStartNfaWithStates_1(6, 79, 14);
1872          break;
1873       case 83:
1874       case 115:
1875          if ((active0 & 0x20000000000000L) != 0L)
1876             return jjStartNfaWithStates_1(6, 53, 14);
1877          break;
1878       case 84:
1879       case 116:
1880          if ((active0 & 0x8000000000000L) != 0L)
1881             return jjStartNfaWithStates_1(6, 51, 14);
1882          return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x4L);
1883       case 85:
1884       case 117:
1885          return jjMoveStringLiteralDfa7_1(active0, 0x4000000000000L, active1, 0L);
1886       default :
1887          break;
1888    }
1889    return jjStartNfa_1(5, active0, active1, 0L);
1890 }
1891 static private final int jjMoveStringLiteralDfa7_1(long old0, long active0, long old1, long active1)
1892 {
1893    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1894       return jjStartNfa_1(5, old0, old1, 0L);
1895    try { curChar = input_stream.readChar(); }
1896    catch(java.io.IOException e) {
1897       jjStopStringLiteralDfa_1(6, active0, active1, 0L);
1898       return 7;
1899    }
1900    switch(curChar)
1901    {
1902       case 95:
1903          return jjMoveStringLiteralDfa8_1(active0, 0x30000000000L, active1, 0L);
1904       case 67:
1905       case 99:
1906          return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0x4L);
1907       case 69:
1908       case 101:
1909          if ((active0 & 0x4000000000000L) != 0L)
1910             return jjStartNfaWithStates_1(7, 50, 14);
1911          else if ((active1 & 0x2L) != 0L)
1912             return jjStartNfaWithStates_1(7, 65, 14);
1913          break;
1914       case 78:
1915       case 110:
1916          if ((active0 & 0x10000000L) != 0L)
1917             return jjStartNfaWithStates_1(7, 28, 14);
1918          break;
1919       default :
1920          break;
1921    }
1922    return jjStartNfa_1(6, active0, active1, 0L);
1923 }
1924 static private final int jjMoveStringLiteralDfa8_1(long old0, long active0, long old1, long active1)
1925 {
1926    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1927       return jjStartNfa_1(6, old0, old1, 0L);
1928    try { curChar = input_stream.readChar(); }
1929    catch(java.io.IOException e) {
1930       jjStopStringLiteralDfa_1(7, active0, active1, 0L);
1931       return 8;
1932    }
1933    switch(curChar)
1934    {
1935       case 72:
1936       case 104:
1937          if ((active1 & 0x4L) != 0L)
1938             return jjStartNfaWithStates_1(8, 66, 14);
1939          break;
1940       case 79:
1941       case 111:
1942          return jjMoveStringLiteralDfa9_1(active0, 0x30000000000L, active1, 0L);
1943       default :
1944          break;
1945    }
1946    return jjStartNfa_1(7, active0, active1, 0L);
1947 }
1948 static private final int jjMoveStringLiteralDfa9_1(long old0, long active0, long old1, long active1)
1949 {
1950    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1951       return jjStartNfa_1(7, old0, old1, 0L);
1952    try { curChar = input_stream.readChar(); }
1953    catch(java.io.IOException e) {
1954       jjStopStringLiteralDfa_1(8, active0, 0L, 0L);
1955       return 9;
1956    }
1957    switch(curChar)
1958    {
1959       case 78:
1960       case 110:
1961          return jjMoveStringLiteralDfa10_1(active0, 0x30000000000L);
1962       default :
1963          break;
1964    }
1965    return jjStartNfa_1(8, active0, 0L, 0L);
1966 }
1967 static private final int jjMoveStringLiteralDfa10_1(long old0, long active0)
1968 {
1969    if (((active0 &= old0)) == 0L)
1970       return jjStartNfa_1(8, old0, 0L, 0L);
1971    try { curChar = input_stream.readChar(); }
1972    catch(java.io.IOException e) {
1973       jjStopStringLiteralDfa_1(9, active0, 0L, 0L);
1974       return 10;
1975    }
1976    switch(curChar)
1977    {
1978       case 67:
1979       case 99:
1980          return jjMoveStringLiteralDfa11_1(active0, 0x30000000000L);
1981       default :
1982          break;
1983    }
1984    return jjStartNfa_1(9, active0, 0L, 0L);
1985 }
1986 static private final int jjMoveStringLiteralDfa11_1(long old0, long active0)
1987 {
1988    if (((active0 &= old0)) == 0L)
1989       return jjStartNfa_1(9, old0, 0L, 0L);
1990    try { curChar = input_stream.readChar(); }
1991    catch(java.io.IOException e) {
1992       jjStopStringLiteralDfa_1(10, active0, 0L, 0L);
1993       return 11;
1994    }
1995    switch(curChar)
1996    {
1997       case 69:
1998       case 101:
1999          if ((active0 & 0x10000000000L) != 0L)
2000             return jjStartNfaWithStates_1(11, 40, 14);
2001          else if ((active0 & 0x20000000000L) != 0L)
2002             return jjStartNfaWithStates_1(11, 41, 14);
2003          break;
2004       default :
2005          break;
2006    }
2007    return jjStartNfa_1(10, active0, 0L, 0L);
2008 }
2009 static private final int jjMoveNfa_1(int startState, int curPos)
2010 {
2011    int[] nextStates;
2012    int startsAt = 0;
2013    jjnewStateCnt = 52;
2014    int i = 1;
2015    jjstateSet[0] = startState;
2016    int j, kind = 0x7fffffff;
2017    for (;;)
2018    {
2019       if (++jjround == 0x7fffffff)
2020          ReInitRounds();
2021       if (curChar < 64)
2022       {
2023          long l = 1L << curChar;
2024          MatchLoop: do
2025          {
2026             switch(jjstateSet[--i])
2027             {
2028                case 3:
2029                   if ((0x3ff000000000000L & l) != 0L)
2030                      jjCheckNAddStates(0, 6);
2031                   else if (curChar == 39)
2032                      jjCheckNAddStates(7, 12);
2033                   else if (curChar == 46)
2034                      jjCheckNAdd(8);
2035                   else if (curChar == 47)
2036                      jjstateSet[jjnewStateCnt++] = 2;
2037                   if ((0x3fe000000000000L & l) != 0L)
2038                   {
2039                      if (kind > 102)
2040                         kind = 102;
2041                      jjCheckNAddTwoStates(5, 6);
2042                   }
2043                   else if (curChar == 48)
2044                   {
2045                      if (kind > 102)
2046                         kind = 102;
2047                      jjCheckNAddStates(13, 15);
2048                   }
2049                   break;
2050                case 0:
2051                   if (curChar == 42)
2052                      jjstateSet[jjnewStateCnt++] = 1;
2053                   break;
2054                case 1:
2055                   if ((0xffff7fffffffffffL & l) != 0L && kind > 18)
2056                      kind = 18;
2057                   break;
2058                case 2:
2059                   if (curChar == 42)
2060                      jjstateSet[jjnewStateCnt++] = 0;
2061                   break;
2062                case 4:
2063                   if ((0x3fe000000000000L & l) == 0L)
2064                      break;
2065                   if (kind > 102)
2066                      kind = 102;
2067                   jjCheckNAddTwoStates(5, 6);
2068                   break;
2069                case 5:
2070                   if ((0x3ff000000000000L & l) == 0L)
2071                      break;
2072                   if (kind > 102)
2073                      kind = 102;
2074                   jjCheckNAddTwoStates(5, 6);
2075                   break;
2076                case 7:
2077                   if (curChar == 46)
2078                      jjCheckNAdd(8);
2079                   break;
2080                case 8:
2081                   if ((0x3ff000000000000L & l) == 0L)
2082                      break;
2083                   if (kind > 106)
2084                      kind = 106;
2085                   jjCheckNAddStates(16, 18);
2086                   break;
2087                case 10:
2088                   if ((0x280000000000L & l) != 0L)
2089                      jjCheckNAdd(11);
2090                   break;
2091                case 11:
2092                   if ((0x3ff000000000000L & l) == 0L)
2093                      break;
2094                   if (kind > 106)
2095                      kind = 106;
2096                   jjCheckNAddTwoStates(11, 12);
2097                   break;
2098                case 14:
2099                   if ((0x3ff000000000000L & l) == 0L)
2100                      break;
2101                   if (kind > 124)
2102                      kind = 124;
2103                   jjstateSet[jjnewStateCnt++] = 14;
2104                   break;
2105                case 15:
2106                   if ((0x3ff000000000000L & l) != 0L)
2107                      jjCheckNAddStates(0, 6);
2108                   break;
2109                case 16:
2110                   if ((0x3ff000000000000L & l) != 0L)
2111                      jjCheckNAddTwoStates(16, 17);
2112                   break;
2113                case 17:
2114                   if (curChar != 46)
2115                      break;
2116                   if (kind > 106)
2117                      kind = 106;
2118                   jjCheckNAddStates(19, 21);
2119                   break;
2120                case 18:
2121                   if ((0x3ff000000000000L & l) == 0L)
2122                      break;
2123                   if (kind > 106)
2124                      kind = 106;
2125                   jjCheckNAddStates(19, 21);
2126                   break;
2127                case 20:
2128                   if ((0x280000000000L & l) != 0L)
2129                      jjCheckNAdd(21);
2130                   break;
2131                case 21:
2132                   if ((0x3ff000000000000L & l) == 0L)
2133                      break;
2134                   if (kind > 106)
2135                      kind = 106;
2136                   jjCheckNAddTwoStates(21, 12);
2137                   break;
2138                case 22:
2139                   if ((0x3ff000000000000L & l) != 0L)
2140                      jjCheckNAddTwoStates(22, 23);
2141                   break;
2142                case 24:
2143                   if ((0x280000000000L & l) != 0L)
2144                      jjCheckNAdd(25);
2145                   break;
2146                case 25:
2147                   if ((0x3ff000000000000L & l) == 0L)
2148                      break;
2149                   if (kind > 106)
2150                      kind = 106;
2151                   jjCheckNAddTwoStates(25, 12);
2152                   break;
2153                case 26:
2154                   if ((0x3ff000000000000L & l) != 0L)
2155                      jjCheckNAddStates(22, 24);
2156                   break;
2157                case 28:
2158                   if ((0x280000000000L & l) != 0L)
2159                      jjCheckNAdd(29);
2160                   break;
2161                case 29:
2162                   if ((0x3ff000000000000L & l) != 0L)
2163                      jjCheckNAddTwoStates(29, 12);
2164                   break;
2165                case 30:
2166                   if (curChar != 48)
2167                      break;
2168                   if (kind > 102)
2169                      kind = 102;
2170                   jjCheckNAddStates(13, 15);
2171                   break;
2172                case 32:
2173                   if ((0x3ff000000000000L & l) == 0L)
2174                      break;
2175                   if (kind > 102)
2176                      kind = 102;
2177                   jjCheckNAddTwoStates(32, 6);
2178                   break;
2179                case 33:
2180                   if ((0xff000000000000L & l) == 0L)
2181                      break;
2182                   if (kind > 102)
2183                      kind = 102;
2184                   jjCheckNAddTwoStates(33, 6);
2185                   break;
2186                case 34:
2187                   if (curChar == 39)
2188                      jjCheckNAddStates(7, 12);
2189                   break;
2190                case 35:
2191                   if ((0xffffff7fffffffffL & l) != 0L)
2192                      jjCheckNAddStates(25, 27);
2193                   break;
2194                case 37:
2195                   jjCheckNAddStates(25, 27);
2196                   break;
2197                case 38:
2198                   if (curChar == 39 && kind > 108)
2199                      kind = 108;
2200                   break;
2201                case 39:
2202                   if ((0xffffff7fffffffffL & l) != 0L)
2203                      jjCheckNAddStates(28, 30);
2204                   break;
2205                case 41:
2206                   jjCheckNAddStates(28, 30);
2207                   break;
2208                case 42:
2209                   if (curChar == 39 && kind > 109)
2210                      kind = 109;
2211                   break;
2212                case 44:
2213                case 46:
2214                   jjCheckNAddStates(31, 33);
2215                   break;
2216                case 48:
2217                case 50:
2218                   jjCheckNAddStates(34, 36);
2219                   break;
2220                default : break;
2221             }
2222          } while(i != startsAt);
2223       }
2224       else if (curChar < 128)
2225       {
2226          long l = 1L << (curChar & 077);
2227          MatchLoop: do
2228          {
2229             switch(jjstateSet[--i])
2230             {
2231                case 3:
2232                   if ((0x87fffffe87fffffeL & l) != 0L)
2233                   {
2234                      if (kind > 124)
2235                         kind = 124;
2236                      jjCheckNAdd(14);
2237                   }
2238                   else if (curChar == 96)
2239                      jjCheckNAddStates(37, 42);
2240                   break;
2241                case 1:
2242                   if (kind > 18)
2243                      kind = 18;
2244                   break;
2245                case 6:
2246                   if ((0x100000001000L & l) != 0L && kind > 102)
2247                      kind = 102;
2248                   break;
2249                case 9:
2250                   if ((0x2000000020L & l) != 0L)
2251                      jjAddStates(43, 44);
2252                   break;
2253                case 12:
2254                   if ((0x5000000050L & l) != 0L && kind > 106)
2255                      kind = 106;
2256                   break;
2257                case 13:
2258                case 14:
2259                   if ((0x87fffffe87fffffeL & l) == 0L)
2260                      break;
2261                   if (kind > 124)
2262                      kind = 124;
2263                   jjCheckNAdd(14);
2264                   break;
2265                case 19:
2266                   if ((0x2000000020L & l) != 0L)
2267                      jjAddStates(45, 46);
2268                   break;
2269                case 23:
2270                   if ((0x2000000020L & l) != 0L)
2271                      jjAddStates(47, 48);
2272                   break;
2273                case 27:
2274                   if ((0x2000000020L & l) != 0L)
2275                      jjAddStates(49, 50);
2276                   break;
2277                case 31:
2278                   if ((0x100000001000000L & l) != 0L)
2279                      jjCheckNAdd(32);
2280                   break;
2281                case 32:
2282                   if ((0x7e0000007eL & l) == 0L)
2283                      break;
2284                   if (kind > 102)
2285                      kind = 102;
2286                   jjCheckNAddTwoStates(32, 6);
2287                   break;
2288                case 35:
2289                   if ((0xffffffffefffffffL & l) != 0L)
2290                      jjCheckNAddStates(25, 27);
2291                   break;
2292                case 36:
2293                   if (curChar == 92)
2294                      jjstateSet[jjnewStateCnt++] = 37;
2295                   break;
2296                case 37:
2297                   jjCheckNAddStates(25, 27);
2298                   break;
2299                case 39:
2300                   if ((0xffffffffefffffffL & l) != 0L)
2301                      jjCheckNAddStates(28, 30);
2302                   break;
2303                case 40:
2304                   if (curChar == 92)
2305                      jjstateSet[jjnewStateCnt++] = 41;
2306                   break;
2307                case 41:
2308                   jjCheckNAddStates(28, 30);
2309                   break;
2310                case 43:
2311                   if (curChar == 96)
2312                      jjCheckNAddStates(37, 42);
2313                   break;
2314                case 44:
2315                   if ((0xfffffffeefffffffL & l) != 0L)
2316                      jjCheckNAddStates(31, 33);
2317                   break;
2318                case 45:
2319                   if (curChar == 92)
2320                      jjstateSet[jjnewStateCnt++] = 46;
2321                   break;
2322                case 46:
2323                   jjCheckNAddStates(31, 33);
2324                   break;
2325                case 47:
2326                   if (curChar == 96 && kind > 108)
2327                      kind = 108;
2328                   break;
2329                case 48:
2330                   if ((0xfffffffeefffffffL & l) != 0L)
2331                      jjCheckNAddStates(34, 36);
2332                   break;
2333                case 49:
2334                   if (curChar == 92)
2335                      jjstateSet[jjnewStateCnt++] = 50;
2336                   break;
2337                case 50:
2338                   jjCheckNAddStates(34, 36);
2339                   break;
2340                case 51:
2341                   if (curChar == 96 && kind > 110)
2342                      kind = 110;
2343                   break;
2344                default : break;
2345             }
2346          } while(i != startsAt);
2347       }
2348       else
2349       {
2350          int i2 = (curChar & 0xff) >> 6;
2351          long l2 = 1L << (curChar & 077);
2352          MatchLoop: do
2353          {
2354             switch(jjstateSet[--i])
2355             {
2356                case 3:
2357                case 14:
2358                   if ((jjbitVec0[i2] & l2) == 0L)
2359                      break;
2360                   if (kind > 124)
2361                      kind = 124;
2362                   jjCheckNAdd(14);
2363                   break;
2364                case 1:
2365                   if ((jjbitVec0[i2] & l2) != 0L && kind > 18)
2366                      kind = 18;
2367                   break;
2368                case 35:
2369                case 37:
2370                   if ((jjbitVec0[i2] & l2) != 0L)
2371                      jjCheckNAddStates(25, 27);
2372                   break;
2373                case 39:
2374                case 41:
2375                   if ((jjbitVec0[i2] & l2) != 0L)
2376                      jjCheckNAddStates(28, 30);
2377                   break;
2378                case 44:
2379                case 46:
2380                   if ((jjbitVec0[i2] & l2) != 0L)
2381                      jjCheckNAddStates(31, 33);
2382                   break;
2383                case 48:
2384                case 50:
2385                   if ((jjbitVec0[i2] & l2) != 0L)
2386                      jjCheckNAddStates(34, 36);
2387                   break;
2388                default : break;
2389             }
2390          } while(i != startsAt);
2391       }
2392       if (kind != 0x7fffffff)
2393       {
2394          jjmatchedKind = kind;
2395          jjmatchedPos = curPos;
2396          kind = 0x7fffffff;
2397       }
2398       ++curPos;
2399       if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt)))
2400          return curPos;
2401       try { curChar = input_stream.readChar(); }
2402       catch(java.io.IOException e) { return curPos; }
2403    }
2404 }
2405 private static final int jjStopStringLiteralDfa_7(int pos, long active0, long active1)
2406 {
2407    switch (pos)
2408    {
2409       default :
2410          return -1;
2411    }
2412 }
2413 private static final int jjStartNfa_7(int pos, long active0, long active1)
2414 {
2415    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0, active1), pos + 1);
2416 }
2417 static private final int jjStartNfaWithStates_7(int pos, int kind, int state)
2418 {
2419    jjmatchedKind = kind;
2420    jjmatchedPos = pos;
2421    try { curChar = input_stream.readChar(); }
2422    catch(java.io.IOException e) { return pos + 1; }
2423    return jjMoveNfa_7(state, pos + 1);
2424 }
2425 static private final int jjMoveStringLiteralDfa0_7()
2426 {
2427    switch(curChar)
2428    {
2429       case 34:
2430          return jjStopAtPos(0, 114);
2431       case 123:
2432          return jjStopAtPos(0, 115);
2433       default :
2434          return jjMoveNfa_7(0, 0);
2435    }
2436 }
2437 static private final int jjMoveNfa_7(int startState, int curPos)
2438 {
2439    int[] nextStates;
2440    int startsAt = 0;
2441    jjnewStateCnt = 4;
2442    int i = 1;
2443    jjstateSet[0] = startState;
2444    int j, kind = 0x7fffffff;
2445    for (;;)
2446    {
2447       if (++jjround == 0x7fffffff)
2448          ReInitRounds();
2449       if (curChar < 64)
2450       {
2451          long l = 1L << curChar;
2452          MatchLoop: do
2453          {
2454             switch(jjstateSet[--i])
2455             {
2456                case 1:
2457                   if (kind > 111)
2458                      kind = 111;
2459                   break;
2460                case 3:
2461                   if ((0x3ff000000000000L & l) == 0L)
2462                      break;
2463                   if (kind > 124)
2464                      kind = 124;
2465                   jjstateSet[jjnewStateCnt++] = 3;
2466                   break;
2467                default : break;
2468             }
2469          } while(i != startsAt);
2470       }
2471       else if (curChar < 128)
2472       {
2473          long l = 1L << (curChar & 077);
2474          MatchLoop: do
2475          {
2476             switch(jjstateSet[--i])
2477             {
2478                case 0:
2479                   if ((0x87fffffe87fffffeL & l) != 0L)
2480                   {
2481                      if (kind > 124)
2482                         kind = 124;
2483                      jjCheckNAdd(3);
2484                   }
2485                   else if (curChar == 92)
2486                      jjstateSet[jjnewStateCnt++] = 1;
2487                   break;
2488                case 1:
2489                   if (kind > 111)
2490                      kind = 111;
2491                   break;
2492                case 2:
2493                case 3:
2494                   if ((0x87fffffe87fffffeL & l) == 0L)
2495                      break;
2496                   if (kind > 124)
2497                      kind = 124;
2498                   jjCheckNAdd(3);
2499                   break;
2500                default : break;
2501             }
2502          } while(i != startsAt);
2503       }
2504       else
2505       {
2506          int i2 = (curChar & 0xff) >> 6;
2507          long l2 = 1L << (curChar & 077);
2508          MatchLoop: do
2509          {
2510             switch(jjstateSet[--i])
2511             {
2512                case 0:
2513                case 3:
2514                   if ((jjbitVec0[i2] & l2) == 0L)
2515                      break;
2516                   if (kind > 124)
2517                      kind = 124;
2518                   jjCheckNAdd(3);
2519                   break;
2520                case 1:
2521                   if ((jjbitVec0[i2] & l2) != 0L && kind > 111)
2522                      kind = 111;
2523                   break;
2524                default : break;
2525             }
2526          } while(i != startsAt);
2527       }
2528       if (kind != 0x7fffffff)
2529       {
2530          jjmatchedKind = kind;
2531          jjmatchedPos = curPos;
2532          kind = 0x7fffffff;
2533       }
2534       ++curPos;
2535       if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
2536          return curPos;
2537       try { curChar = input_stream.readChar(); }
2538       catch(java.io.IOException e) { return curPos; }
2539    }
2540 }
2541 static final int[] jjnextStates = {
2542    16, 17, 22, 23, 26, 27, 12, 35, 36, 38, 39, 40, 42, 31, 33, 6,
2543    8, 9, 12, 18, 19, 12, 26, 27, 12, 35, 36, 38, 39, 40, 42, 44,
2544    45, 47, 48, 49, 51, 44, 45, 47, 48, 49, 51, 10, 11, 20, 21, 24,
2545    25, 28, 29,
2546 };
2547 public static final String[] jjstrLiteralImages = {
2548 "", "\74\77", null, "\74\77\75", "\77\76", null, null, null, null, null, null,
2549 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2550 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2551 null, null, null, null, null, null, "\55\76", "\72\72", "\75\76", null, null, null,
2552 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2553 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2554 null, "\100", "\41", "\176", "\77", "\72", "\174\174", "\46\46", "\53\53", "\55\55",
2555 "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76",
2556 "\76\76\76", null, null, null, null, null, null, null, null, null, null, null, null, "\42",
2557 "\44", "\42", "\173", null, null, null, "\175", null, null, null, "\44", null, null,
2558 null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56",
2559 "\76", "\74", "\75\75", "\74\75", "\76\75", "\41\75", "\74\76", "\41\75\75",
2560 "\75\75\75", "\75", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75",
2561 "\56\75", "\45\75", "\176\75", "\74\74\75", "\76\76\75", };
2562 public static final String[] lexStateNames = {
2563    "DEFAULT",
2564    "PHPPARSING",
2565    "IN_SINGLE_LINE_COMMENT",
2566    "IN_VARIABLE",
2567    "IN_FORMAL_COMMENT",
2568    "IN_MULTI_LINE_COMMENT",
2569    "IN_STRING",
2570    "DOLLAR_IN_STRING",
2571    "SKIPSTRING",
2572    "DOLLAR_IN_STRING_EXPR",
2573 };
2574 public static final int[] jjnewLexState = {
2575    -1, 1, 1, 1, 0, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 2, 2, 4, 5, 1, -1, -1, -1, 1,
2576    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,
2577    -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,
2578    -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,
2579    1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6, 6, 7, 1, 9, 8, 6, -1, 7, -1, -1, -1, 3, -1,
2580    -1, -1, -1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2581    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2582 };
2583 static final long[] jjtoToken = {
2584    0xfffffffff880001fL, 0x198f747fffffffffL, 0xfffffffeL,
2585 };
2586 static final long[] jjtoSkip = {
2587    0x37fffe0L, 0x670800000000000L, 0x1L,
2588 };
2589 static final long[] jjtoSpecial = {
2590    0x37ff800L, 0x30000000000000L, 0x1L,
2591 };
2592 static final long[] jjtoMore = {
2593    0x4000000L, 0x0L, 0x0L,
2594 };
2595 static protected SimpleCharStream input_stream;
2596 static private final int[] jjrounds = new int[52];
2597 static private final int[] jjstateSet = new int[104];
2598 static StringBuffer image;
2599 static int jjimageLen;
2600 static int lengthOfMatch;
2601 static protected char curChar;
2602 public PHPParserTokenManager(SimpleCharStream stream)
2603 {
2604    if (input_stream != null)
2605       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
2606    input_stream = stream;
2607 }
2608 public PHPParserTokenManager(SimpleCharStream stream, int lexState)
2609 {
2610    this(stream);
2611    SwitchTo(lexState);
2612 }
2613 static public void ReInit(SimpleCharStream stream)
2614 {
2615    jjmatchedPos = jjnewStateCnt = 0;
2616    curLexState = defaultLexState;
2617    input_stream = stream;
2618    ReInitRounds();
2619 }
2620 static private final void ReInitRounds()
2621 {
2622    int i;
2623    jjround = 0x80000001;
2624    for (i = 52; i-- > 0;)
2625       jjrounds[i] = 0x80000000;
2626 }
2627 static public void ReInit(SimpleCharStream stream, int lexState)
2628 {
2629    ReInit(stream);
2630    SwitchTo(lexState);
2631 }
2632 static public void SwitchTo(int lexState)
2633 {
2634    if (lexState >= 10 || lexState < 0)
2635       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2636    else
2637       curLexState = lexState;
2638 }
2639
2640 static protected Token jjFillToken()
2641 {
2642    Token t = Token.newToken(jjmatchedKind);
2643    t.kind = jjmatchedKind;
2644    if (jjmatchedPos < 0)
2645    {
2646       t.image = "";
2647       t.beginLine = t.endLine = input_stream.getBeginLine();
2648       t.beginColumn = t.endColumn = input_stream.getBeginColumn();
2649    }
2650    else
2651    {
2652       String im = jjstrLiteralImages[jjmatchedKind];
2653       t.image = (im == null) ? input_stream.GetImage() : im;
2654       t.beginLine = input_stream.getBeginLine();
2655       t.beginColumn = input_stream.getBeginColumn();
2656       t.endLine = input_stream.getEndLine();
2657       t.endColumn = input_stream.getEndColumn();
2658    }
2659    return t;
2660 }
2661
2662 static int curLexState = 0;
2663 static int defaultLexState = 0;
2664 static int jjnewStateCnt;
2665 static int jjround;
2666 static int jjmatchedPos;
2667 static int jjmatchedKind;
2668
2669 public static Token getNextToken()
2670 {
2671   int kind;
2672   Token specialToken = null;
2673   Token matchedToken;
2674   int curPos = 0;
2675
2676   EOFLoop :
2677   for (;;)
2678   {
2679    try
2680    {
2681       curChar = input_stream.BeginToken();
2682    }
2683    catch(java.io.IOException e)
2684    {
2685       jjmatchedKind = 0;
2686       matchedToken = jjFillToken();
2687       matchedToken.specialToken = specialToken;
2688       CommonTokenAction(matchedToken);
2689       return matchedToken;
2690    }
2691    image = null;
2692    jjimageLen = 0;
2693
2694    for (;;)
2695    {
2696      switch(curLexState)
2697      {
2698        case 0:
2699          jjmatchedKind = 0x7fffffff;
2700          jjmatchedPos = 0;
2701          curPos = jjMoveStringLiteralDfa0_0();
2702          if (jjmatchedPos == 0 && jjmatchedKind > 5)
2703          {
2704             jjmatchedKind = 5;
2705          }
2706          break;
2707        case 1:
2708          try { input_stream.backup(0);
2709             while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
2710                curChar = input_stream.BeginToken();
2711          }
2712          catch (java.io.IOException e1) { continue EOFLoop; }
2713          jjmatchedKind = 0x7fffffff;
2714          jjmatchedPos = 0;
2715          curPos = jjMoveStringLiteralDfa0_1();
2716          break;
2717        case 2:
2718          jjmatchedKind = 0x7fffffff;
2719          jjmatchedPos = 0;
2720          curPos = jjMoveStringLiteralDfa0_2();
2721          if (jjmatchedPos == 0 && jjmatchedKind > 21)
2722          {
2723             jjmatchedKind = 21;
2724          }
2725          break;
2726        case 3:
2727          jjmatchedKind = 0x7fffffff;
2728          jjmatchedPos = 0;
2729          curPos = jjMoveStringLiteralDfa0_3();
2730          break;
2731        case 4:
2732          jjmatchedKind = 0x7fffffff;
2733          jjmatchedPos = 0;
2734          curPos = jjMoveStringLiteralDfa0_4();
2735          if (jjmatchedPos == 0 && jjmatchedKind > 26)
2736          {
2737             jjmatchedKind = 26;
2738          }
2739          break;
2740        case 5:
2741          jjmatchedKind = 0x7fffffff;
2742          jjmatchedPos = 0;
2743          curPos = jjMoveStringLiteralDfa0_5();
2744          if (jjmatchedPos == 0 && jjmatchedKind > 26)
2745          {
2746             jjmatchedKind = 26;
2747          }
2748          break;
2749        case 6:
2750          jjmatchedKind = 0x7fffffff;
2751          jjmatchedPos = 0;
2752          curPos = jjMoveStringLiteralDfa0_6();
2753          if (jjmatchedPos == 0 && jjmatchedKind > 121)
2754          {
2755             jjmatchedKind = 121;
2756          }
2757          break;
2758        case 7:
2759          jjmatchedKind = 0x7fffffff;
2760          jjmatchedPos = 0;
2761          curPos = jjMoveStringLiteralDfa0_7();
2762          if (jjmatchedPos == 0 && jjmatchedKind > 128)
2763          {
2764             jjmatchedKind = 128;
2765          }
2766          break;
2767        case 8:
2768          jjmatchedKind = 0x7fffffff;
2769          jjmatchedPos = 0;
2770          curPos = jjMoveStringLiteralDfa0_8();
2771          if (jjmatchedPos == 0 && jjmatchedKind > 118)
2772          {
2773             jjmatchedKind = 118;
2774          }
2775          break;
2776        case 9:
2777          jjmatchedKind = 120;
2778          jjmatchedPos = -1;
2779          curPos = 0;
2780          curPos = jjMoveStringLiteralDfa0_9();
2781          if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 122))
2782          {
2783             jjmatchedKind = 122;
2784             jjmatchedPos = 0;
2785          }
2786          break;
2787      }
2788      if (jjmatchedKind != 0x7fffffff)
2789      {
2790         if (jjmatchedPos + 1 < curPos)
2791            input_stream.backup(curPos - jjmatchedPos - 1);
2792         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2793         {
2794            matchedToken = jjFillToken();
2795            matchedToken.specialToken = specialToken;
2796            TokenLexicalActions(matchedToken);
2797        if (jjnewLexState[jjmatchedKind] != -1)
2798          curLexState = jjnewLexState[jjmatchedKind];
2799            CommonTokenAction(matchedToken);
2800            return matchedToken;
2801         }
2802         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2803         {
2804            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2805            {
2806               matchedToken = jjFillToken();
2807               if (specialToken == null)
2808                  specialToken = matchedToken;
2809               else
2810               {
2811                  matchedToken.specialToken = specialToken;
2812                  specialToken = (specialToken.next = matchedToken);
2813               }
2814               SkipLexicalActions(matchedToken);
2815            }
2816            else
2817               SkipLexicalActions(null);
2818          if (jjnewLexState[jjmatchedKind] != -1)
2819            curLexState = jjnewLexState[jjmatchedKind];
2820            continue EOFLoop;
2821         }
2822         jjimageLen += jjmatchedPos + 1;
2823       if (jjnewLexState[jjmatchedKind] != -1)
2824         curLexState = jjnewLexState[jjmatchedKind];
2825         curPos = 0;
2826         jjmatchedKind = 0x7fffffff;
2827         try {
2828            curChar = input_stream.readChar();
2829            continue;
2830         }
2831         catch (java.io.IOException e1) { }
2832      }
2833      int error_line = input_stream.getEndLine();
2834      int error_column = input_stream.getEndColumn();
2835      String error_after = null;
2836      boolean EOFSeen = false;
2837      try { input_stream.readChar(); input_stream.backup(1); }
2838      catch (java.io.IOException e1) {
2839         EOFSeen = true;
2840         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2841         if (curChar == '\n' || curChar == '\r') {
2842            error_line++;
2843            error_column = 0;
2844         }
2845         else
2846            error_column++;
2847      }
2848      if (!EOFSeen) {
2849         input_stream.backup(1);
2850         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2851      }
2852      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2853    }
2854   }
2855 }
2856
2857 static void SkipLexicalActions(Token matchedToken)
2858 {
2859    switch(jjmatchedKind)
2860    {
2861       case 18 :
2862          if (image == null)
2863             image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2864          else
2865             image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2866                    input_stream.backup(1);
2867          break;
2868       default :
2869          break;
2870    }
2871 }
2872 static void TokenLexicalActions(Token matchedToken)
2873 {
2874    switch(jjmatchedKind)
2875    {
2876       default :
2877          break;
2878    }
2879 }
2880 }