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 = 64;
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, 18);
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(19, 21);
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(22, 24);
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(25, 27);
1377                   break;
1378                case 21:
1379                   if ((0x3ff000000000000L & l) == 0L)
1380                      break;
1381                   if (kind > 99)
1382                      kind = 99;
1383                   jjCheckNAddStates(25, 27);
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(28, 30);
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(19, 21);
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, 18);
1447                   break;
1448                case 38:
1449                   if ((0xfffffffbffffffffL & l) != 0L)
1450                      jjCheckNAddStates(31, 33);
1451                   break;
1452                case 39:
1453                   if (curChar == 34)
1454                      jjCheckNAddStates(31, 33);
1455                   break;
1456                case 41:
1457                   if (curChar == 34 && kind > 101)
1458                      kind = 101;
1459                   break;
1460                case 42:
1461                   if ((0xfffffffbffffffffL & l) != 0L)
1462                      jjCheckNAddStates(34, 36);
1463                   break;
1464                case 43:
1465                   if (curChar == 34)
1466                      jjCheckNAddStates(34, 36);
1467                   break;
1468                case 45:
1469                   if (curChar == 34 && kind > 102)
1470                      kind = 102;
1471                   break;
1472                case 46:
1473                   if (curChar == 39)
1474                      jjCheckNAddStates(7, 12);
1475                   break;
1476                case 47:
1477                   if ((0xffffff7fffffffffL & l) != 0L)
1478                      jjCheckNAddStates(37, 39);
1479                   break;
1480                case 48:
1481                   if (curChar == 39)
1482                      jjCheckNAddStates(37, 39);
1483                   break;
1484                case 50:
1485                   if (curChar == 39 && kind > 101)
1486                      kind = 101;
1487                   break;
1488                case 51:
1489                   if ((0xffffff7fffffffffL & l) != 0L)
1490                      jjCheckNAddStates(40, 42);
1491                   break;
1492                case 52:
1493                   if (curChar == 39)
1494                      jjCheckNAddStates(40, 42);
1495                   break;
1496                case 54:
1497                   if (curChar == 39 && kind > 103)
1498                      kind = 103;
1499                   break;
1500                case 56:
1501                   jjAddStates(43, 45);
1502                   break;
1503                case 60:
1504                   jjAddStates(46, 48);
1505                   break;
1506                default : break;
1507             }
1508          } while(i != startsAt);
1509       }
1510       else if (curChar < 128)
1511       {
1512          long l = 1L << (curChar & 077);
1513          MatchLoop: do
1514          {
1515             switch(jjstateSet[--i])
1516             {
1517                case 3:
1518                   if ((0x87fffffe87fffffeL & l) != 0L)
1519                   {
1520                      if (kind > 105)
1521                         kind = 105;
1522                      jjCheckNAdd(14);
1523                   }
1524                   else if (curChar == 96)
1525                      jjCheckNAddStates(49, 54);
1526                   break;
1527                case 1:
1528                   if (kind > 13)
1529                      kind = 13;
1530                   break;
1531                case 6:
1532                   if ((0x100000001000L & l) != 0L && kind > 95)
1533                      kind = 95;
1534                   break;
1535                case 9:
1536                   if ((0x2000000020L & l) != 0L)
1537                      jjAddStates(55, 56);
1538                   break;
1539                case 12:
1540                   if ((0x5000000050L & l) != 0L && kind > 99)
1541                      kind = 99;
1542                   break;
1543                case 13:
1544                case 14:
1545                   if ((0x87fffffe87fffffeL & l) == 0L)
1546                      break;
1547                   if (kind > 105)
1548                      kind = 105;
1549                   jjCheckNAdd(14);
1550                   break;
1551                case 16:
1552                case 17:
1553                   if ((0x87fffffe87fffffeL & l) == 0L)
1554                      break;
1555                   if (kind > 140)
1556                      kind = 140;
1557                   jjCheckNAdd(17);
1558                   break;
1559                case 22:
1560                   if ((0x2000000020L & l) != 0L)
1561                      jjAddStates(57, 58);
1562                   break;
1563                case 26:
1564                   if ((0x2000000020L & l) != 0L)
1565                      jjAddStates(59, 60);
1566                   break;
1567                case 30:
1568                   if ((0x2000000020L & l) != 0L)
1569                      jjAddStates(61, 62);
1570                   break;
1571                case 34:
1572                   if ((0x100000001000000L & l) != 0L)
1573                      jjCheckNAdd(35);
1574                   break;
1575                case 35:
1576                   if ((0x7e0000007eL & l) == 0L)
1577                      break;
1578                   if (kind > 95)
1579                      kind = 95;
1580                   jjCheckNAddTwoStates(35, 6);
1581                   break;
1582                case 38:
1583                   jjAddStates(31, 33);
1584                   break;
1585                case 40:
1586                   if (curChar == 92)
1587                      jjstateSet[jjnewStateCnt++] = 39;
1588                   break;
1589                case 42:
1590                   jjAddStates(34, 36);
1591                   break;
1592                case 44:
1593                   if (curChar == 92)
1594                      jjstateSet[jjnewStateCnt++] = 43;
1595                   break;
1596                case 47:
1597                   jjAddStates(37, 39);
1598                   break;
1599                case 49:
1600                   if (curChar == 92)
1601                      jjstateSet[jjnewStateCnt++] = 48;
1602                   break;
1603                case 51:
1604                   jjAddStates(40, 42);
1605                   break;
1606                case 53:
1607                   if (curChar == 92)
1608                      jjstateSet[jjnewStateCnt++] = 52;
1609                   break;
1610                case 55:
1611                   if (curChar == 96)
1612                      jjCheckNAddStates(49, 54);
1613                   break;
1614                case 56:
1615                   if ((0xfffffffeffffffffL & l) != 0L)
1616                      jjCheckNAddStates(43, 45);
1617                   break;
1618                case 57:
1619                   if (curChar == 96)
1620                      jjCheckNAddStates(43, 45);
1621                   break;
1622                case 58:
1623                   if (curChar == 92)
1624                      jjstateSet[jjnewStateCnt++] = 57;
1625                   break;
1626                case 59:
1627                   if (curChar == 96 && kind > 101)
1628                      kind = 101;
1629                   break;
1630                case 60:
1631                   if ((0xfffffffeffffffffL & l) != 0L)
1632                      jjCheckNAddStates(46, 48);
1633                   break;
1634                case 61:
1635                   if (curChar == 96)
1636                      jjCheckNAddStates(46, 48);
1637                   break;
1638                case 62:
1639                   if (curChar == 92)
1640                      jjstateSet[jjnewStateCnt++] = 61;
1641                   break;
1642                case 63:
1643                   if (curChar == 96 && kind > 104)
1644                      kind = 104;
1645                   break;
1646                default : break;
1647             }
1648          } while(i != startsAt);
1649       }
1650       else
1651       {
1652          int i2 = (curChar & 0xff) >> 6;
1653          long l2 = 1L << (curChar & 077);
1654          MatchLoop: do
1655          {
1656             switch(jjstateSet[--i])
1657             {
1658                case 3:
1659                case 14:
1660                   if ((jjbitVec0[i2] & l2) == 0L)
1661                      break;
1662                   if (kind > 105)
1663                      kind = 105;
1664                   jjCheckNAdd(14);
1665                   break;
1666                case 1:
1667                   if ((jjbitVec0[i2] & l2) != 0L && kind > 13)
1668                      kind = 13;
1669                   break;
1670                case 16:
1671                case 17:
1672                   if ((jjbitVec0[i2] & l2) == 0L)
1673                      break;
1674                   if (kind > 140)
1675                      kind = 140;
1676                   jjCheckNAdd(17);
1677                   break;
1678                case 38:
1679                   if ((jjbitVec0[i2] & l2) != 0L)
1680                      jjAddStates(31, 33);
1681                   break;
1682                case 42:
1683                   if ((jjbitVec0[i2] & l2) != 0L)
1684                      jjAddStates(34, 36);
1685                   break;
1686                case 47:
1687                   if ((jjbitVec0[i2] & l2) != 0L)
1688                      jjAddStates(37, 39);
1689                   break;
1690                case 51:
1691                   if ((jjbitVec0[i2] & l2) != 0L)
1692                      jjAddStates(40, 42);
1693                   break;
1694                case 56:
1695                   if ((jjbitVec0[i2] & l2) != 0L)
1696                      jjAddStates(43, 45);
1697                   break;
1698                case 60:
1699                   if ((jjbitVec0[i2] & l2) != 0L)
1700                      jjAddStates(46, 48);
1701                   break;
1702                default : break;
1703             }
1704          } while(i != startsAt);
1705       }
1706       if (kind != 0x7fffffff)
1707       {
1708          jjmatchedKind = kind;
1709          jjmatchedPos = curPos;
1710          kind = 0x7fffffff;
1711       }
1712       ++curPos;
1713       if ((i = jjnewStateCnt) == (startsAt = 64 - (jjnewStateCnt = startsAt)))
1714          return curPos;
1715       try { curChar = input_stream.readChar(); }
1716       catch(java.io.IOException e) { return curPos; }
1717    }
1718 }
1719 static private final int jjMoveStringLiteralDfa0_3()
1720 {
1721    switch(curChar)
1722    {
1723       case 42:
1724          return jjMoveStringLiteralDfa1_3(0x20000L);
1725       default :
1726          return 1;
1727    }
1728 }
1729 static private final int jjMoveStringLiteralDfa1_3(long active0)
1730 {
1731    try { curChar = input_stream.readChar(); }
1732    catch(java.io.IOException e) {
1733       return 1;
1734    }
1735    switch(curChar)
1736    {
1737       case 47:
1738          if ((active0 & 0x20000L) != 0L)
1739             return jjStopAtPos(1, 17);
1740          break;
1741       default :
1742          return 2;
1743    }
1744    return 2;
1745 }
1746 static final int[] jjnextStates = {
1747    19, 20, 25, 26, 29, 30, 12, 47, 49, 50, 51, 53, 54, 38, 40, 41,
1748    42, 44, 45, 34, 36, 6, 8, 9, 12, 21, 22, 12, 29, 30, 12, 38,
1749    40, 41, 42, 44, 45, 47, 49, 50, 51, 53, 54, 56, 58, 59, 60, 62,
1750    63, 56, 58, 59, 60, 62, 63, 10, 11, 23, 24, 27, 28, 31, 32,
1751 };
1752 public static final String[] jjstrLiteralImages = {
1753 "", "\74\77", null, "\74\77\75", "\77\76", null, null, null, null, null, null,
1754 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1755 null, null, null, null, null, null, null, null, null, null, null, null, "\55\76",
1756 "\72\72", "\75\76", null, null, null, null, null, null, null, null, null, null, null,
1757 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1758 null, null, null, null, null, null, null, "\100", "\44", "\41", "\176", "\77",
1759 "\72", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46",
1760 "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76", null, null, null, null, null,
1761 null, null, null, null, null, null, null, null, null, null, null, "\50", "\51",
1762 "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\76", "\74", "\75\75", "\74\75",
1763 "\76\75", "\41\75", "\74\76", "\41\75\75", "\75\75\75", "\75", "\53\75", "\55\75",
1764 "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\56\75", "\45\75", "\176\75",
1765 "\74\74\75", "\76\76\75", null, };
1766 public static final String[] lexStateNames = {
1767    "DEFAULT",
1768    "PHPPARSING",
1769    "IN_SINGLE_LINE_COMMENT",
1770    "IN_FORMAL_COMMENT",
1771    "IN_MULTI_LINE_COMMENT",
1772 };
1773 public static final int[] jjnewLexState = {
1774    -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,
1775    -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,
1776    -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,
1777    -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,
1778    -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,
1779    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1780 };
1781 static final long[] jjtoToken = {
1782    0xfffffffffff0001fL, 0xffffe3e8ffffffffL, 0x1fffL,
1783 };
1784 static final long[] jjtoSkip = {
1785    0x7ffe0L, 0x0L, 0x0L,
1786 };
1787 static final long[] jjtoSpecial = {
1788    0x7f800L, 0x0L, 0x0L,
1789 };
1790 static final long[] jjtoMore = {
1791    0x80000L, 0x0L, 0x0L,
1792 };
1793 static protected SimpleCharStream input_stream;
1794 static private final int[] jjrounds = new int[64];
1795 static private final int[] jjstateSet = new int[128];
1796 static StringBuffer image;
1797 static int jjimageLen;
1798 static int lengthOfMatch;
1799 static protected char curChar;
1800 public PHPParserTokenManager(SimpleCharStream stream)
1801 {
1802    if (input_stream != null)
1803       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
1804    input_stream = stream;
1805 }
1806 public PHPParserTokenManager(SimpleCharStream stream, int lexState)
1807 {
1808    this(stream);
1809    SwitchTo(lexState);
1810 }
1811 static public void ReInit(SimpleCharStream stream)
1812 {
1813    jjmatchedPos = jjnewStateCnt = 0;
1814    curLexState = defaultLexState;
1815    input_stream = stream;
1816    ReInitRounds();
1817 }
1818 static private final void ReInitRounds()
1819 {
1820    int i;
1821    jjround = 0x80000001;
1822    for (i = 64; i-- > 0;)
1823       jjrounds[i] = 0x80000000;
1824 }
1825 static public void ReInit(SimpleCharStream stream, int lexState)
1826 {
1827    ReInit(stream);
1828    SwitchTo(lexState);
1829 }
1830 static public void SwitchTo(int lexState)
1831 {
1832    if (lexState >= 5 || lexState < 0)
1833       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1834    else
1835       curLexState = lexState;
1836 }
1837
1838 static protected Token jjFillToken()
1839 {
1840    Token t = Token.newToken(jjmatchedKind);
1841    t.kind = jjmatchedKind;
1842    String im = jjstrLiteralImages[jjmatchedKind];
1843    t.image = (im == null) ? input_stream.GetImage() : im;
1844    t.beginLine = input_stream.getBeginLine();
1845    t.beginColumn = input_stream.getBeginColumn();
1846    t.endLine = input_stream.getEndLine();
1847    t.endColumn = input_stream.getEndColumn();
1848    return t;
1849 }
1850
1851 static int curLexState = 0;
1852 static int defaultLexState = 0;
1853 static int jjnewStateCnt;
1854 static int jjround;
1855 static int jjmatchedPos;
1856 static int jjmatchedKind;
1857
1858 public static Token getNextToken()
1859 {
1860   int kind;
1861   Token specialToken = null;
1862   Token matchedToken;
1863   int curPos = 0;
1864
1865   EOFLoop :
1866   for (;;)
1867   {
1868    try
1869    {
1870       curChar = input_stream.BeginToken();
1871    }
1872    catch(java.io.IOException e)
1873    {
1874       jjmatchedKind = 0;
1875       matchedToken = jjFillToken();
1876       matchedToken.specialToken = specialToken;
1877       return matchedToken;
1878    }
1879    image = null;
1880    jjimageLen = 0;
1881
1882    for (;;)
1883    {
1884      switch(curLexState)
1885      {
1886        case 0:
1887          jjmatchedKind = 0x7fffffff;
1888          jjmatchedPos = 0;
1889          curPos = jjMoveStringLiteralDfa0_0();
1890          if (jjmatchedPos == 0 && jjmatchedKind > 5)
1891          {
1892             jjmatchedKind = 5;
1893          }
1894          break;
1895        case 1:
1896          try { input_stream.backup(0);
1897             while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1898                curChar = input_stream.BeginToken();
1899          }
1900          catch (java.io.IOException e1) { continue EOFLoop; }
1901          jjmatchedKind = 0x7fffffff;
1902          jjmatchedPos = 0;
1903          curPos = jjMoveStringLiteralDfa0_1();
1904          break;
1905        case 2:
1906          jjmatchedKind = 0x7fffffff;
1907          jjmatchedPos = 0;
1908          curPos = jjMoveStringLiteralDfa0_2();
1909          if (jjmatchedPos == 0 && jjmatchedKind > 19)
1910          {
1911             jjmatchedKind = 19;
1912          }
1913          break;
1914        case 3:
1915          jjmatchedKind = 0x7fffffff;
1916          jjmatchedPos = 0;
1917          curPos = jjMoveStringLiteralDfa0_3();
1918          if (jjmatchedPos == 0 && jjmatchedKind > 19)
1919          {
1920             jjmatchedKind = 19;
1921          }
1922          break;
1923        case 4:
1924          jjmatchedKind = 0x7fffffff;
1925          jjmatchedPos = 0;
1926          curPos = jjMoveStringLiteralDfa0_4();
1927          if (jjmatchedPos == 0 && jjmatchedKind > 19)
1928          {
1929             jjmatchedKind = 19;
1930          }
1931          break;
1932      }
1933      if (jjmatchedKind != 0x7fffffff)
1934      {
1935         if (jjmatchedPos + 1 < curPos)
1936            input_stream.backup(curPos - jjmatchedPos - 1);
1937         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1938         {
1939            matchedToken = jjFillToken();
1940            matchedToken.specialToken = specialToken;
1941            TokenLexicalActions(matchedToken);
1942        if (jjnewLexState[jjmatchedKind] != -1)
1943          curLexState = jjnewLexState[jjmatchedKind];
1944            return matchedToken;
1945         }
1946         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1947         {
1948            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1949            {
1950               matchedToken = jjFillToken();
1951               if (specialToken == null)
1952                  specialToken = matchedToken;
1953               else
1954               {
1955                  matchedToken.specialToken = specialToken;
1956                  specialToken = (specialToken.next = matchedToken);
1957               }
1958               SkipLexicalActions(matchedToken);
1959            }
1960            else
1961               SkipLexicalActions(null);
1962          if (jjnewLexState[jjmatchedKind] != -1)
1963            curLexState = jjnewLexState[jjmatchedKind];
1964            continue EOFLoop;
1965         }
1966         jjimageLen += jjmatchedPos + 1;
1967       if (jjnewLexState[jjmatchedKind] != -1)
1968         curLexState = jjnewLexState[jjmatchedKind];
1969         curPos = 0;
1970         jjmatchedKind = 0x7fffffff;
1971         try {
1972            curChar = input_stream.readChar();
1973            continue;
1974         }
1975         catch (java.io.IOException e1) { }
1976      }
1977      int error_line = input_stream.getEndLine();
1978      int error_column = input_stream.getEndColumn();
1979      String error_after = null;
1980      boolean EOFSeen = false;
1981      try { input_stream.readChar(); input_stream.backup(1); }
1982      catch (java.io.IOException e1) {
1983         EOFSeen = true;
1984         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1985         if (curChar == '\n' || curChar == '\r') {
1986            error_line++;
1987            error_column = 0;
1988         }
1989         else
1990            error_column++;
1991      }
1992      if (!EOFSeen) {
1993         input_stream.backup(1);
1994         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1995      }
1996      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1997    }
1998   }
1999 }
2000
2001 static void SkipLexicalActions(Token matchedToken)
2002 {
2003    switch(jjmatchedKind)
2004    {
2005       case 13 :
2006          if (image == null)
2007             image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2008          else
2009             image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2010                    input_stream.backup(1);
2011          break;
2012       default :
2013          break;
2014    }
2015 }
2016 static void TokenLexicalActions(Token matchedToken)
2017 {
2018    switch(jjmatchedKind)
2019    {
2020       case 1 :
2021         if (image == null)
2022             image = new StringBuffer(jjstrLiteralImages[1]);
2023          else
2024             image.append(jjstrLiteralImages[1]);
2025                              PHPParser.createNewHTMLCode();
2026          break;
2027       case 2 :
2028         if (image == null)
2029             image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2030          else
2031             image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2032                              PHPParser.createNewHTMLCode();
2033          break;
2034       case 3 :
2035         if (image == null)
2036             image = new StringBuffer(jjstrLiteralImages[3]);
2037          else
2038             image.append(jjstrLiteralImages[3]);
2039                              PHPParser.createNewHTMLCode();
2040          break;
2041       case 4 :
2042         if (image == null)
2043             image = new StringBuffer(jjstrLiteralImages[4]);
2044          else
2045             image.append(jjstrLiteralImages[4]);
2046                   PHPParser.htmlStart = SimpleCharStream.getPosition();
2047          break;
2048       default :
2049          break;
2050    }
2051 }
2052 }