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