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