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