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