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

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