net.sourceforge.phpeclipse/src/test/PHPParserTokenManager.java

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