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