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

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