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