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                   jjCheckNAddStates(33, 36);
1448                   break;
1449                case 39:
1450                   if (curChar == 34)
1451                      jjCheckNAddStates(33, 36);
1452                   break;
1453                case 42:
1454                   if ((0xfffffffbffffffffL & l) != 0L)
1455                      jjstateSet[jjnewStateCnt++] = 43;
1456                   break;
1457                case 44:
1458                   if (curChar == 34 && kind > 80)
1459                      kind = 80;
1460                   break;
1461                case 45:
1462                   jjCheckNAddStates(37, 40);
1463                   break;
1464                case 46:
1465                   if (curChar == 34)
1466                      jjCheckNAddStates(37, 40);
1467                   break;
1468                case 49:
1469                   if ((0xfffffffbffffffffL & l) != 0L)
1470                      jjstateSet[jjnewStateCnt++] = 50;
1471                   break;
1472                case 51:
1473                   if (curChar == 34 && kind > 81)
1474                      kind = 81;
1475                   break;
1476                case 52:
1477                   if (curChar == 39)
1478                      jjCheckNAddStates(7, 12);
1479                   break;
1480                case 53:
1481                   if ((0xffffff7fffffffffL & l) != 0L)
1482                      jjCheckNAddStates(41, 43);
1483                   break;
1484                case 54:
1485                   if (curChar == 39)
1486                      jjCheckNAddStates(41, 43);
1487                   break;
1488                case 56:
1489                   if (curChar == 39 && kind > 80)
1490                      kind = 80;
1491                   break;
1492                case 57:
1493                   if ((0xffffff7fffffffffL & l) != 0L)
1494                      jjCheckNAddStates(44, 46);
1495                   break;
1496                case 58:
1497                   if (curChar == 39)
1498                      jjCheckNAddStates(44, 46);
1499                   break;
1500                case 60:
1501                   if (curChar == 39 && kind > 82)
1502                      kind = 82;
1503                   break;
1504                case 62:
1505                   jjAddStates(47, 49);
1506                   break;
1507                case 66:
1508                   jjAddStates(50, 52);
1509                   break;
1510                default : break;
1511             }
1512          } while(i != startsAt);
1513       }
1514       else if (curChar < 128)
1515       {
1516          long l = 1L << (curChar & 077);
1517          MatchLoop: do
1518          {
1519             switch(jjstateSet[--i])
1520             {
1521                case 3:
1522                   if ((0x87fffffe87fffffeL & l) != 0L)
1523                   {
1524                      if (kind > 84)
1525                         kind = 84;
1526                      jjCheckNAdd(14);
1527                   }
1528                   else if (curChar == 96)
1529                      jjCheckNAddStates(53, 58);
1530                   break;
1531                case 1:
1532                   if (kind > 13)
1533                      kind = 13;
1534                   break;
1535                case 6:
1536                   if ((0x100000001000L & l) != 0L && kind > 74)
1537                      kind = 74;
1538                   break;
1539                case 9:
1540                   if ((0x2000000020L & l) != 0L)
1541                      jjAddStates(59, 60);
1542                   break;
1543                case 12:
1544                   if ((0x5000000050L & l) != 0L && kind > 78)
1545                      kind = 78;
1546                   break;
1547                case 13:
1548                case 14:
1549                   if ((0x87fffffe87fffffeL & l) == 0L)
1550                      break;
1551                   if (kind > 84)
1552                      kind = 84;
1553                   jjCheckNAdd(14);
1554                   break;
1555                case 16:
1556                case 17:
1557                   if ((0x87fffffe87fffffeL & l) == 0L)
1558                      break;
1559                   if (kind > 140)
1560                      kind = 140;
1561                   jjCheckNAdd(17);
1562                   break;
1563                case 22:
1564                   if ((0x2000000020L & l) != 0L)
1565                      jjAddStates(61, 62);
1566                   break;
1567                case 26:
1568                   if ((0x2000000020L & l) != 0L)
1569                      jjAddStates(63, 64);
1570                   break;
1571                case 30:
1572                   if ((0x2000000020L & l) != 0L)
1573                      jjAddStates(65, 66);
1574                   break;
1575                case 34:
1576                   if ((0x100000001000000L & l) != 0L)
1577                      jjCheckNAdd(35);
1578                   break;
1579                case 35:
1580                   if ((0x7e0000007eL & l) == 0L)
1581                      break;
1582                   if (kind > 74)
1583                      kind = 74;
1584                   jjCheckNAddTwoStates(35, 6);
1585                   break;
1586                case 38:
1587                   jjCheckNAddStates(33, 36);
1588                   break;
1589                case 40:
1590                   if (curChar == 92)
1591                      jjstateSet[jjnewStateCnt++] = 39;
1592                   break;
1593                case 41:
1594                   if (curChar == 123)
1595                      jjstateSet[jjnewStateCnt++] = 42;
1596                   break;
1597                case 42:
1598                   jjstateSet[jjnewStateCnt++] = 43;
1599                   break;
1600                case 43:
1601                   if (curChar == 125)
1602                      jjCheckNAddStates(33, 36);
1603                   break;
1604                case 45:
1605                   jjCheckNAddStates(37, 40);
1606                   break;
1607                case 47:
1608                   if (curChar == 92)
1609                      jjstateSet[jjnewStateCnt++] = 46;
1610                   break;
1611                case 48:
1612                   if (curChar == 123)
1613                      jjstateSet[jjnewStateCnt++] = 49;
1614                   break;
1615                case 49:
1616                   jjstateSet[jjnewStateCnt++] = 50;
1617                   break;
1618                case 50:
1619                   if (curChar == 125)
1620                      jjCheckNAddStates(37, 40);
1621                   break;
1622                case 53:
1623                   jjAddStates(41, 43);
1624                   break;
1625                case 55:
1626                   if (curChar == 92)
1627                      jjstateSet[jjnewStateCnt++] = 54;
1628                   break;
1629                case 57:
1630                   jjAddStates(44, 46);
1631                   break;
1632                case 59:
1633                   if (curChar == 92)
1634                      jjstateSet[jjnewStateCnt++] = 58;
1635                   break;
1636                case 61:
1637                   if (curChar == 96)
1638                      jjCheckNAddStates(53, 58);
1639                   break;
1640                case 62:
1641                   if ((0xfffffffeffffffffL & l) != 0L)
1642                      jjCheckNAddStates(47, 49);
1643                   break;
1644                case 63:
1645                   if (curChar == 96)
1646                      jjCheckNAddStates(47, 49);
1647                   break;
1648                case 64:
1649                   if (curChar == 92)
1650                      jjstateSet[jjnewStateCnt++] = 63;
1651                   break;
1652                case 65:
1653                   if (curChar == 96 && kind > 80)
1654                      kind = 80;
1655                   break;
1656                case 66:
1657                   if ((0xfffffffeffffffffL & l) != 0L)
1658                      jjCheckNAddStates(50, 52);
1659                   break;
1660                case 67:
1661                   if (curChar == 96)
1662                      jjCheckNAddStates(50, 52);
1663                   break;
1664                case 68:
1665                   if (curChar == 92)
1666                      jjstateSet[jjnewStateCnt++] = 67;
1667                   break;
1668                case 69:
1669                   if (curChar == 96 && kind > 83)
1670                      kind = 83;
1671                   break;
1672                default : break;
1673             }
1674          } while(i != startsAt);
1675       }
1676       else
1677       {
1678          int i2 = (curChar & 0xff) >> 6;
1679          long l2 = 1L << (curChar & 077);
1680          MatchLoop: do
1681          {
1682             switch(jjstateSet[--i])
1683             {
1684                case 3:
1685                case 14:
1686                   if ((jjbitVec0[i2] & l2) == 0L)
1687                      break;
1688                   if (kind > 84)
1689                      kind = 84;
1690                   jjCheckNAdd(14);
1691                   break;
1692                case 1:
1693                   if ((jjbitVec0[i2] & l2) != 0L && kind > 13)
1694                      kind = 13;
1695                   break;
1696                case 16:
1697                case 17:
1698                   if ((jjbitVec0[i2] & l2) == 0L)
1699                      break;
1700                   if (kind > 140)
1701                      kind = 140;
1702                   jjCheckNAdd(17);
1703                   break;
1704                case 38:
1705                   if ((jjbitVec0[i2] & l2) != 0L)
1706                      jjAddStates(33, 36);
1707                   break;
1708                case 42:
1709                   if ((jjbitVec0[i2] & l2) != 0L)
1710                      jjstateSet[jjnewStateCnt++] = 43;
1711                   break;
1712                case 45:
1713                   if ((jjbitVec0[i2] & l2) != 0L)
1714                      jjAddStates(37, 40);
1715                   break;
1716                case 49:
1717                   if ((jjbitVec0[i2] & l2) != 0L)
1718                      jjstateSet[jjnewStateCnt++] = 50;
1719                   break;
1720                case 53:
1721                   if ((jjbitVec0[i2] & l2) != 0L)
1722                      jjAddStates(41, 43);
1723                   break;
1724                case 57:
1725                   if ((jjbitVec0[i2] & l2) != 0L)
1726                      jjAddStates(44, 46);
1727                   break;
1728                case 62:
1729                   if ((jjbitVec0[i2] & l2) != 0L)
1730                      jjAddStates(47, 49);
1731                   break;
1732                case 66:
1733                   if ((jjbitVec0[i2] & l2) != 0L)
1734                      jjAddStates(50, 52);
1735                   break;
1736                default : break;
1737             }
1738          } while(i != startsAt);
1739       }
1740       if (kind != 0x7fffffff)
1741       {
1742          jjmatchedKind = kind;
1743          jjmatchedPos = curPos;
1744          kind = 0x7fffffff;
1745       }
1746       ++curPos;
1747       if ((i = jjnewStateCnt) == (startsAt = 70 - (jjnewStateCnt = startsAt)))
1748          return curPos;
1749       try { curChar = input_stream.readChar(); }
1750       catch(java.io.IOException e) { return curPos; }
1751    }
1752 }
1753 static private final int jjMoveStringLiteralDfa0_3()
1754 {
1755    switch(curChar)
1756    {
1757       case 42:
1758          return jjMoveStringLiteralDfa1_3(0x20000L);
1759       default :
1760          return 1;
1761    }
1762 }
1763 static private final int jjMoveStringLiteralDfa1_3(long active0)
1764 {
1765    try { curChar = input_stream.readChar(); }
1766    catch(java.io.IOException e) {
1767       return 1;
1768    }
1769    switch(curChar)
1770    {
1771       case 47:
1772          if ((active0 & 0x20000L) != 0L)
1773             return jjStopAtPos(1, 17);
1774          break;
1775       default :
1776          return 2;
1777    }
1778    return 2;
1779 }
1780 static final int[] jjnextStates = {
1781    19, 20, 25, 26, 29, 30, 12, 53, 55, 56, 57, 59, 60, 38, 40, 41,
1782    44, 45, 47, 48, 51, 34, 36, 6, 8, 9, 12, 21, 22, 12, 29, 30,
1783    12, 38, 40, 41, 44, 45, 47, 48, 51, 53, 55, 56, 57, 59, 60, 62,
1784    64, 65, 66, 68, 69, 62, 64, 65, 66, 68, 69, 10, 11, 23, 24, 27,
1785    28, 31, 32,
1786 };
1787 public static final String[] jjstrLiteralImages = {
1788 "", "\74\77", null, "\74\77\75", "\77\76", null, null, null, null, null, null,
1789 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1790 null, null, null, null, null, null, null, null, null, null, null, null, "\55\76",
1791 "\72\72", "\75\76", null, null, null, null, null, null, null, null, null, null, null,
1792 null, null, null, null, null, null, null, null, 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, "\50", "\51", "\173", "\175",
1795 "\133", "\135", "\73", "\54", "\56", "\76", "\74", "\75\75", "\74\75", "\76\75",
1796 "\41\75", "\74\76", "\41\75\75", "\75\75\75", "\75", "\53\75", "\55\75", "\52\75",
1797 "\57\75", "\46\75", "\174\75", "\136\75", "\56\75", "\45\75", "\176\75", "\100", "\44",
1798 "\41", "\176", "\77", "\72", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55",
1799 "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76",
1800 "\74\74\75", "\76\76\75", null, };
1801 public static final String[] lexStateNames = {
1802    "DEFAULT",
1803    "PHPPARSING",
1804    "IN_SINGLE_LINE_COMMENT",
1805    "IN_FORMAL_COMMENT",
1806    "IN_MULTI_LINE_COMMENT",
1807 };
1808 public static final int[] jjnewLexState = {
1809    -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,
1810    -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,
1811    -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,
1812    -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,
1813    -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,
1814    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1815 };
1816 static final long[] jjtoToken = {
1817    0xfffffffffff0001fL, 0xffffffffff1f47ffL, 0x1fffL,
1818 };
1819 static final long[] jjtoSkip = {
1820    0x7ffe0L, 0x0L, 0x0L,
1821 };
1822 static final long[] jjtoSpecial = {
1823    0x7f800L, 0x0L, 0x0L,
1824 };
1825 static final long[] jjtoMore = {
1826    0x80000L, 0x0L, 0x0L,
1827 };
1828 static protected SimpleCharStream input_stream;
1829 static private final int[] jjrounds = new int[70];
1830 static private final int[] jjstateSet = new int[140];
1831 static StringBuffer image;
1832 static int jjimageLen;
1833 static int lengthOfMatch;
1834 static protected char curChar;
1835 public PHPParserTokenManager(SimpleCharStream stream)
1836 {
1837    if (input_stream != null)
1838       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
1839    input_stream = stream;
1840 }
1841 public PHPParserTokenManager(SimpleCharStream stream, int lexState)
1842 {
1843    this(stream);
1844    SwitchTo(lexState);
1845 }
1846 static public void ReInit(SimpleCharStream stream)
1847 {
1848    jjmatchedPos = jjnewStateCnt = 0;
1849    curLexState = defaultLexState;
1850    input_stream = stream;
1851    ReInitRounds();
1852 }
1853 static private final void ReInitRounds()
1854 {
1855    int i;
1856    jjround = 0x80000001;
1857    for (i = 70; i-- > 0;)
1858       jjrounds[i] = 0x80000000;
1859 }
1860 static public void ReInit(SimpleCharStream stream, int lexState)
1861 {
1862    ReInit(stream);
1863    SwitchTo(lexState);
1864 }
1865 static public void SwitchTo(int lexState)
1866 {
1867    if (lexState >= 5 || lexState < 0)
1868       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1869    else
1870       curLexState = lexState;
1871 }
1872
1873 static protected Token jjFillToken()
1874 {
1875    Token t = Token.newToken(jjmatchedKind);
1876    t.kind = jjmatchedKind;
1877    String im = jjstrLiteralImages[jjmatchedKind];
1878    t.image = (im == null) ? input_stream.GetImage() : im;
1879    t.beginLine = input_stream.getBeginLine();
1880    t.beginColumn = input_stream.getBeginColumn();
1881    t.endLine = input_stream.getEndLine();
1882    t.endColumn = input_stream.getEndColumn();
1883    return t;
1884 }
1885
1886 static int curLexState = 0;
1887 static int defaultLexState = 0;
1888 static int jjnewStateCnt;
1889 static int jjround;
1890 static int jjmatchedPos;
1891 static int jjmatchedKind;
1892
1893 public static Token getNextToken()
1894 {
1895   int kind;
1896   Token specialToken = null;
1897   Token matchedToken;
1898   int curPos = 0;
1899
1900   EOFLoop :
1901   for (;;)
1902   {
1903    try
1904    {
1905       curChar = input_stream.BeginToken();
1906    }
1907    catch(java.io.IOException e)
1908    {
1909       jjmatchedKind = 0;
1910       matchedToken = jjFillToken();
1911       matchedToken.specialToken = specialToken;
1912       return matchedToken;
1913    }
1914    image = null;
1915    jjimageLen = 0;
1916
1917    for (;;)
1918    {
1919      switch(curLexState)
1920      {
1921        case 0:
1922          jjmatchedKind = 0x7fffffff;
1923          jjmatchedPos = 0;
1924          curPos = jjMoveStringLiteralDfa0_0();
1925          if (jjmatchedPos == 0 && jjmatchedKind > 5)
1926          {
1927             jjmatchedKind = 5;
1928          }
1929          break;
1930        case 1:
1931          try { input_stream.backup(0);
1932             while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1933                curChar = input_stream.BeginToken();
1934          }
1935          catch (java.io.IOException e1) { continue EOFLoop; }
1936          jjmatchedKind = 0x7fffffff;
1937          jjmatchedPos = 0;
1938          curPos = jjMoveStringLiteralDfa0_1();
1939          break;
1940        case 2:
1941          jjmatchedKind = 0x7fffffff;
1942          jjmatchedPos = 0;
1943          curPos = jjMoveStringLiteralDfa0_2();
1944          if (jjmatchedPos == 0 && jjmatchedKind > 19)
1945          {
1946             jjmatchedKind = 19;
1947          }
1948          break;
1949        case 3:
1950          jjmatchedKind = 0x7fffffff;
1951          jjmatchedPos = 0;
1952          curPos = jjMoveStringLiteralDfa0_3();
1953          if (jjmatchedPos == 0 && jjmatchedKind > 19)
1954          {
1955             jjmatchedKind = 19;
1956          }
1957          break;
1958        case 4:
1959          jjmatchedKind = 0x7fffffff;
1960          jjmatchedPos = 0;
1961          curPos = jjMoveStringLiteralDfa0_4();
1962          if (jjmatchedPos == 0 && jjmatchedKind > 19)
1963          {
1964             jjmatchedKind = 19;
1965          }
1966          break;
1967      }
1968      if (jjmatchedKind != 0x7fffffff)
1969      {
1970         if (jjmatchedPos + 1 < curPos)
1971            input_stream.backup(curPos - jjmatchedPos - 1);
1972         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1973         {
1974            matchedToken = jjFillToken();
1975            matchedToken.specialToken = specialToken;
1976        if (jjnewLexState[jjmatchedKind] != -1)
1977          curLexState = jjnewLexState[jjmatchedKind];
1978            return matchedToken;
1979         }
1980         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1981         {
1982            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1983            {
1984               matchedToken = jjFillToken();
1985               if (specialToken == null)
1986                  specialToken = matchedToken;
1987               else
1988               {
1989                  matchedToken.specialToken = specialToken;
1990                  specialToken = (specialToken.next = matchedToken);
1991               }
1992               SkipLexicalActions(matchedToken);
1993            }
1994            else
1995               SkipLexicalActions(null);
1996          if (jjnewLexState[jjmatchedKind] != -1)
1997            curLexState = jjnewLexState[jjmatchedKind];
1998            continue EOFLoop;
1999         }
2000         jjimageLen += jjmatchedPos + 1;
2001       if (jjnewLexState[jjmatchedKind] != -1)
2002         curLexState = jjnewLexState[jjmatchedKind];
2003         curPos = 0;
2004         jjmatchedKind = 0x7fffffff;
2005         try {
2006            curChar = input_stream.readChar();
2007            continue;
2008         }
2009         catch (java.io.IOException e1) { }
2010      }
2011      int error_line = input_stream.getEndLine();
2012      int error_column = input_stream.getEndColumn();
2013      String error_after = null;
2014      boolean EOFSeen = false;
2015      try { input_stream.readChar(); input_stream.backup(1); }
2016      catch (java.io.IOException e1) {
2017         EOFSeen = true;
2018         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2019         if (curChar == '\n' || curChar == '\r') {
2020            error_line++;
2021            error_column = 0;
2022         }
2023         else
2024            error_column++;
2025      }
2026      if (!EOFSeen) {
2027         input_stream.backup(1);
2028         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2029      }
2030      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2031    }
2032   }
2033 }
2034
2035 static void SkipLexicalActions(Token matchedToken)
2036 {
2037    switch(jjmatchedKind)
2038    {
2039       case 13 :
2040          if (image == null)
2041             image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2042          else
2043             image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2044                    input_stream.backup(1);
2045          break;
2046       default :
2047          break;
2048    }
2049 }
2050 }