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