lucene-java-3.4.0/lucene/contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/demohtml/HTMLParserTokenManager.java

   1 /* Generated By:JavaCC: Do not edit this line. HTMLParserTokenManager.java */
   2 package org.apache.lucene.benchmark.byTask.feeds.demohtml;
   3 import java.io.*;
   4 import java.util.Locale;
   5 import java.util.Properties;
   6
   7 /** Token Manager. */
   8 public class HTMLParserTokenManager implements HTMLParserConstants
   9 {
  10
  11   /** Debug output. */
  12   public  java.io.PrintStream debugStream = System.out;
  13   /** Set debug output. */
  14   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  15 private final int jjStopStringLiteralDfa_0(int pos, long active0)
  16 {
  17    switch (pos)
  18    {
  19       case 0:
  20          if ((active0 & 0x32L) != 0L)
  21             return 20;
  22          return -1;
  23       case 1:
  24          if ((active0 & 0x2L) != 0L)
  25          {
  26             if (jjmatchedPos != 1)
  27             {
  28                jjmatchedKind = 2;
  29                jjmatchedPos = 1;
  30             }
  31             return 22;
  32          }
  33          if ((active0 & 0x30L) != 0L)
  34             return 25;
  35          return -1;
  36       case 2:
  37          if ((active0 & 0x2L) != 0L)
  38          {
  39             jjmatchedKind = 2;
  40             jjmatchedPos = 2;
  41             return 23;
  42          }
  43          return -1;
  44       case 3:
  45          if ((active0 & 0x2L) != 0L)
  46          {
  47             jjmatchedKind = 2;
  48             jjmatchedPos = 3;
  49             return 23;
  50          }
  51          return -1;
  52       case 4:
  53          if ((active0 & 0x2L) != 0L)
  54          {
  55             jjmatchedKind = 2;
  56             jjmatchedPos = 4;
  57             return 23;
  58          }
  59          return -1;
  60       case 5:
  61          if ((active0 & 0x2L) != 0L)
  62          {
  63             jjmatchedKind = 2;
  64             jjmatchedPos = 5;
  65             return 23;
  66          }
  67          return -1;
  68       default :
  69          return -1;
  70    }
  71 }
  72 private final int jjStartNfa_0(int pos, long active0)
  73 {
  74    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
  75 }
  76 private int jjStopAtPos(int pos, int kind)
  77 {
  78    jjmatchedKind = kind;
  79    jjmatchedPos = pos;
  80    return pos + 1;
  81 }
  82 private int jjMoveStringLiteralDfa0_0()
  83 {
  84    switch(curChar)
  85    {
  86       case 60:
  87          return jjMoveStringLiteralDfa1_0(0x32L);
  88       default :
  89          return jjMoveNfa_0(11, 0);
  90    }
  91 }
  92 private int jjMoveStringLiteralDfa1_0(long active0)
  93 {
  94    try { curChar = input_stream.readChar(); }
  95    catch(java.io.IOException e) {
  96       jjStopStringLiteralDfa_0(0, active0);
  97       return 1;
  98    }
  99    switch(curChar)
 100    {
 101       case 33:
 102          if ((active0 & 0x20L) != 0L)
 103          {
 104             jjmatchedKind = 5;
 105             jjmatchedPos = 1;
 106          }
 107          return jjMoveStringLiteralDfa2_0(active0, 0x10L);
 108       case 115:
 109          return jjMoveStringLiteralDfa2_0(active0, 0x2L);
 110       default :
 111          break;
 112    }
 113    return jjStartNfa_0(0, active0);
 114 }
 115 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
 116 {
 117    if (((active0 &= old0)) == 0L)
 118       return jjStartNfa_0(0, old0);
 119    try { curChar = input_stream.readChar(); }
 120    catch(java.io.IOException e) {
 121       jjStopStringLiteralDfa_0(1, active0);
 122       return 2;
 123    }
 124    switch(curChar)
 125    {
 126       case 45:
 127          return jjMoveStringLiteralDfa3_0(active0, 0x10L);
 128       case 99:
 129          return jjMoveStringLiteralDfa3_0(active0, 0x2L);
 130       default :
 131          break;
 132    }
 133    return jjStartNfa_0(1, active0);
 134 }
 135 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
 136 {
 137    if (((active0 &= old0)) == 0L)
 138       return jjStartNfa_0(1, old0);
 139    try { curChar = input_stream.readChar(); }
 140    catch(java.io.IOException e) {
 141       jjStopStringLiteralDfa_0(2, active0);
 142       return 3;
 143    }
 144    switch(curChar)
 145    {
 146       case 45:
 147          if ((active0 & 0x10L) != 0L)
 148             return jjStopAtPos(3, 4);
 149          break;
 150       case 114:
 151          return jjMoveStringLiteralDfa4_0(active0, 0x2L);
 152       default :
 153          break;
 154    }
 155    return jjStartNfa_0(2, active0);
 156 }
 157 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
 158 {
 159    if (((active0 &= old0)) == 0L)
 160       return jjStartNfa_0(2, old0);
 161    try { curChar = input_stream.readChar(); }
 162    catch(java.io.IOException e) {
 163       jjStopStringLiteralDfa_0(3, active0);
 164       return 4;
 165    }
 166    switch(curChar)
 167    {
 168       case 105:
 169          return jjMoveStringLiteralDfa5_0(active0, 0x2L);
 170       default :
 171          break;
 172    }
 173    return jjStartNfa_0(3, active0);
 174 }
 175 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
 176 {
 177    if (((active0 &= old0)) == 0L)
 178       return jjStartNfa_0(3, old0);
 179    try { curChar = input_stream.readChar(); }
 180    catch(java.io.IOException e) {
 181       jjStopStringLiteralDfa_0(4, active0);
 182       return 5;
 183    }
 184    switch(curChar)
 185    {
 186       case 112:
 187          return jjMoveStringLiteralDfa6_0(active0, 0x2L);
 188       default :
 189          break;
 190    }
 191    return jjStartNfa_0(4, active0);
 192 }
 193 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
 194 {
 195    if (((active0 &= old0)) == 0L)
 196       return jjStartNfa_0(4, old0);
 197    try { curChar = input_stream.readChar(); }
 198    catch(java.io.IOException e) {
 199       jjStopStringLiteralDfa_0(5, active0);
 200       return 6;
 201    }
 202    switch(curChar)
 203    {
 204       case 116:
 205          if ((active0 & 0x2L) != 0L)
 206             return jjStartNfaWithStates_0(6, 1, 23);
 207          break;
 208       default :
 209          break;
 210    }
 211    return jjStartNfa_0(5, active0);
 212 }
 213 private int jjStartNfaWithStates_0(int pos, int kind, int state)
 214 {
 215    jjmatchedKind = kind;
 216    jjmatchedPos = pos;
 217    try { curChar = input_stream.readChar(); }
 218    catch(java.io.IOException e) { return pos + 1; }
 219    return jjMoveNfa_0(state, pos + 1);
 220 }
 221 static final long[] jjbitVec0 = {
 222    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 223 };
 224 static final long[] jjbitVec2 = {
 225    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 226 };
 227 private int jjMoveNfa_0(int startState, int curPos)
 228 {
 229    int startsAt = 0;
 230    jjnewStateCnt = 28;
 231    int i = 1;
 232    jjstateSet[0] = startState;
 233    int kind = 0x7fffffff;
 234    for (;;)
 235    {
 236       if (++jjround == 0x7fffffff)
 237          ReInitRounds();
 238       if (curChar < 64)
 239       {
 240          long l = 1L << curChar;
 241          do
 242          {
 243             switch(jjstateSet[--i])
 244             {
 245                case 20:
 246                   if (curChar == 33)
 247                      jjstateSet[jjnewStateCnt++] = 25;
 248                   else if (curChar == 47)
 249                      jjCheckNAdd(21);
 250                   break;
 251                case 11:
 252                   if ((0x3ff000000000000L & l) != 0L)
 253                      jjCheckNAddTwoStates(7, 2);
 254                   else if ((0x100002600L & l) != 0L)
 255                   {
 256                      if (kind > 11)
 257                         kind = 11;
 258                      jjCheckNAdd(10);
 259                   }
 260                   else if (curChar == 60)
 261                      jjCheckNAddStates(0, 2);
 262                   else if (curChar == 38)
 263                      jjAddStates(3, 5);
 264                   else if (curChar == 36)
 265                      jjstateSet[jjnewStateCnt++] = 1;
 266                   if ((0x3ff000000000000L & l) != 0L)
 267                   {
 268                      if (kind > 6)
 269                         kind = 6;
 270                      jjCheckNAddStates(6, 10);
 271                   }
 272                   break;
 273                case 0:
 274                   if (curChar == 36)
 275                      jjstateSet[jjnewStateCnt++] = 1;
 276                   break;
 277                case 1:
 278                   if ((0x3ff000000000000L & l) != 0L)
 279                      jjCheckNAdd(2);
 280                   break;
 281                case 2:
 282                   if ((0x500000000000L & l) != 0L)
 283                      jjstateSet[jjnewStateCnt++] = 3;
 284                   break;
 285                case 3:
 286                case 9:
 287                   if ((0x3ff000000000000L & l) == 0L)
 288                      break;
 289                   if (kind > 6)
 290                      kind = 6;
 291                   jjCheckNAddStates(11, 13);
 292                   break;
 293                case 4:
 294                   if ((0x3ff000000000000L & l) == 0L)
 295                      break;
 296                   if (kind > 6)
 297                      kind = 6;
 298                   jjCheckNAddStates(6, 10);
 299                   break;
 300                case 5:
 301                   if ((0x880000000000L & l) == 0L)
 302                      break;
 303                   if (kind > 6)
 304                      kind = 6;
 305                   jjCheckNAddStates(14, 17);
 306                   break;
 307                case 6:
 308                   if ((0x3ff000000000000L & l) != 0L)
 309                      jjCheckNAddTwoStates(7, 2);
 310                   break;
 311                case 7:
 312                   if (curChar != 34)
 313                      break;
 314                   if (kind > 6)
 315                      kind = 6;
 316                   jjCheckNAddStates(11, 13);
 317                   break;
 318                case 8:
 319                   if ((0x208000000000L & l) != 0L)
 320                      jjstateSet[jjnewStateCnt++] = 9;
 321                   break;
 322                case 10:
 323                   if ((0x100002600L & l) == 0L)
 324                      break;
 325                   kind = 11;
 326                   jjCheckNAdd(10);
 327                   break;
 328                case 13:
 329                   if (curChar == 59 && kind > 10)
 330                      kind = 10;
 331                   break;
 332                case 14:
 333                   if (curChar == 35)
 334                      jjCheckNAdd(15);
 335                   break;
 336                case 15:
 337                   if ((0x3ff000000000000L & l) == 0L)
 338                      break;
 339                   if (kind > 10)
 340                      kind = 10;
 341                   jjCheckNAddTwoStates(15, 13);
 342                   break;
 343                case 16:
 344                   if (curChar == 35)
 345                      jjstateSet[jjnewStateCnt++] = 17;
 346                   break;
 347                case 18:
 348                   if ((0x3ff000000000000L & l) == 0L)
 349                      break;
 350                   if (kind > 10)
 351                      kind = 10;
 352                   jjCheckNAddTwoStates(18, 13);
 353                   break;
 354                case 19:
 355                   if (curChar == 60)
 356                      jjCheckNAddStates(0, 2);
 357                   break;
 358                case 22:
 359                   if ((0x9fffff7affffd9ffL & l) == 0L)
 360                      break;
 361                   if (kind > 2)
 362                      kind = 2;
 363                   jjCheckNAdd(23);
 364                   break;
 365                case 23:
 366                   if ((0x9ffffffeffffd9ffL & l) == 0L)
 367                      break;
 368                   if (kind > 2)
 369                      kind = 2;
 370                   jjCheckNAdd(23);
 371                   break;
 372                case 24:
 373                   if (curChar == 33)
 374                      jjstateSet[jjnewStateCnt++] = 25;
 375                   break;
 376                case 26:
 377                   if ((0x9fffff7affffd9ffL & l) == 0L)
 378                      break;
 379                   if (kind > 3)
 380                      kind = 3;
 381                   jjCheckNAdd(27);
 382                   break;
 383                case 27:
 384                   if ((0x9ffffffeffffd9ffL & l) == 0L)
 385                      break;
 386                   if (kind > 3)
 387                      kind = 3;
 388                   jjCheckNAdd(27);
 389                   break;
 390                default : break;
 391             }
 392          } while(i != startsAt);
 393       }
 394       else if (curChar < 128)
 395       {
 396          long l = 1L << (curChar & 077);
 397          do
 398          {
 399             switch(jjstateSet[--i])
 400             {
 401                case 20:
 402                case 21:
 403                   if ((0x7fffffe07fffffeL & l) == 0L)
 404                      break;
 405                   if (kind > 2)
 406                      kind = 2;
 407                   jjstateSet[jjnewStateCnt++] = 22;
 408                   break;
 409                case 11:
 410                case 4:
 411                   if ((0x7fffffe07fffffeL & l) == 0L)
 412                      break;
 413                   if (kind > 6)
 414                      kind = 6;
 415                   jjCheckNAddStates(6, 10);
 416                   break;
 417                case 9:
 418                   if ((0x7fffffe07fffffeL & l) == 0L)
 419                      break;
 420                   if (kind > 6)
 421                      kind = 6;
 422                   jjCheckNAddStates(11, 13);
 423                   break;
 424                case 12:
 425                   if ((0x7fffffe07fffffeL & l) == 0L)
 426                      break;
 427                   if (kind > 10)
 428                      kind = 10;
 429                   jjCheckNAddTwoStates(12, 13);
 430                   break;
 431                case 17:
 432                   if ((0x100000001000000L & l) != 0L)
 433                      jjCheckNAdd(18);
 434                   break;
 435                case 18:
 436                   if ((0x7e0000007eL & l) == 0L)
 437                      break;
 438                   if (kind > 10)
 439                      kind = 10;
 440                   jjCheckNAddTwoStates(18, 13);
 441                   break;
 442                case 22:
 443                case 23:
 444                   if (kind > 2)
 445                      kind = 2;
 446                   jjCheckNAdd(23);
 447                   break;
 448                case 25:
 449                   if ((0x7fffffe07fffffeL & l) == 0L)
 450                      break;
 451                   if (kind > 3)
 452                      kind = 3;
 453                   jjstateSet[jjnewStateCnt++] = 26;
 454                   break;
 455                case 26:
 456                case 27:
 457                   if (kind > 3)
 458                      kind = 3;
 459                   jjCheckNAdd(27);
 460                   break;
 461                default : break;
 462             }
 463          } while(i != startsAt);
 464       }
 465       else
 466       {
 467          int hiByte = (int)(curChar >> 8);
 468          int i1 = hiByte >> 6;
 469          long l1 = 1L << (hiByte & 077);
 470          int i2 = (curChar & 0xff) >> 6;
 471          long l2 = 1L << (curChar & 077);
 472          do
 473          {
 474             switch(jjstateSet[--i])
 475             {
 476                case 22:
 477                case 23:
 478                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 479                      break;
 480                   if (kind > 2)
 481                      kind = 2;
 482                   jjCheckNAdd(23);
 483                   break;
 484                case 26:
 485                case 27:
 486                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 487                      break;
 488                   if (kind > 3)
 489                      kind = 3;
 490                   jjCheckNAdd(27);
 491                   break;
 492                default : break;
 493             }
 494          } while(i != startsAt);
 495       }
 496       if (kind != 0x7fffffff)
 497       {
 498          jjmatchedKind = kind;
 499          jjmatchedPos = curPos;
 500          kind = 0x7fffffff;
 501       }
 502       ++curPos;
 503       if ((i = jjnewStateCnt) == (startsAt = 28 - (jjnewStateCnt = startsAt)))
 504          return curPos;
 505       try { curChar = input_stream.readChar(); }
 506       catch(java.io.IOException e) { return curPos; }
 507    }
 508 }
 509 private int jjMoveStringLiteralDfa0_5()
 510 {
 511    return jjMoveNfa_5(1, 0);
 512 }
 513 private int jjMoveNfa_5(int startState, int curPos)
 514 {
 515    int startsAt = 0;
 516    jjnewStateCnt = 2;
 517    int i = 1;
 518    jjstateSet[0] = startState;
 519    int kind = 0x7fffffff;
 520    for (;;)
 521    {
 522       if (++jjround == 0x7fffffff)
 523          ReInitRounds();
 524       if (curChar < 64)
 525       {
 526          long l = 1L << curChar;
 527          do
 528          {
 529             switch(jjstateSet[--i])
 530             {
 531                case 1:
 532                   if ((0xfffffffbffffffffL & l) != 0L)
 533                   {
 534                      if (kind > 25)
 535                         kind = 25;
 536                      jjCheckNAdd(0);
 537                   }
 538                   else if (curChar == 34)
 539                   {
 540                      if (kind > 26)
 541                         kind = 26;
 542                   }
 543                   break;
 544                case 0:
 545                   if ((0xfffffffbffffffffL & l) == 0L)
 546                      break;
 547                   kind = 25;
 548                   jjCheckNAdd(0);
 549                   break;
 550                default : break;
 551             }
 552          } while(i != startsAt);
 553       }
 554       else if (curChar < 128)
 555       {
 556          long l = 1L << (curChar & 077);
 557          do
 558          {
 559             switch(jjstateSet[--i])
 560             {
 561                case 1:
 562                case 0:
 563                   kind = 25;
 564                   jjCheckNAdd(0);
 565                   break;
 566                default : break;
 567             }
 568          } while(i != startsAt);
 569       }
 570       else
 571       {
 572          int hiByte = (int)(curChar >> 8);
 573          int i1 = hiByte >> 6;
 574          long l1 = 1L << (hiByte & 077);
 575          int i2 = (curChar & 0xff) >> 6;
 576          long l2 = 1L << (curChar & 077);
 577          do
 578          {
 579             switch(jjstateSet[--i])
 580             {
 581                case 1:
 582                case 0:
 583                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 584                      break;
 585                   if (kind > 25)
 586                      kind = 25;
 587                   jjCheckNAdd(0);
 588                   break;
 589                default : break;
 590             }
 591          } while(i != startsAt);
 592       }
 593       if (kind != 0x7fffffff)
 594       {
 595          jjmatchedKind = kind;
 596          jjmatchedPos = curPos;
 597          kind = 0x7fffffff;
 598       }
 599       ++curPos;
 600       if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
 601          return curPos;
 602       try { curChar = input_stream.readChar(); }
 603       catch(java.io.IOException e) { return curPos; }
 604    }
 605 }
 606 private final int jjStopStringLiteralDfa_7(int pos, long active0)
 607 {
 608    switch (pos)
 609    {
 610       default :
 611          return -1;
 612    }
 613 }
 614 private final int jjStartNfa_7(int pos, long active0)
 615 {
 616    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
 617 }
 618 private int jjMoveStringLiteralDfa0_7()
 619 {
 620    switch(curChar)
 621    {
 622       case 62:
 623          return jjStopAtPos(0, 30);
 624       default :
 625          return jjMoveNfa_7(0, 0);
 626    }
 627 }
 628 private int jjMoveNfa_7(int startState, int curPos)
 629 {
 630    int startsAt = 0;
 631    jjnewStateCnt = 1;
 632    int i = 1;
 633    jjstateSet[0] = startState;
 634    int kind = 0x7fffffff;
 635    for (;;)
 636    {
 637       if (++jjround == 0x7fffffff)
 638          ReInitRounds();
 639       if (curChar < 64)
 640       {
 641          long l = 1L << curChar;
 642          do
 643          {
 644             switch(jjstateSet[--i])
 645             {
 646                case 0:
 647                   if ((0xbfffffffffffffffL & l) == 0L)
 648                      break;
 649                   kind = 29;
 650                   jjstateSet[jjnewStateCnt++] = 0;
 651                   break;
 652                default : break;
 653             }
 654          } while(i != startsAt);
 655       }
 656       else if (curChar < 128)
 657       {
 658          long l = 1L << (curChar & 077);
 659          do
 660          {
 661             switch(jjstateSet[--i])
 662             {
 663                case 0:
 664                   kind = 29;
 665                   jjstateSet[jjnewStateCnt++] = 0;
 666                   break;
 667                default : break;
 668             }
 669          } while(i != startsAt);
 670       }
 671       else
 672       {
 673          int hiByte = (int)(curChar >> 8);
 674          int i1 = hiByte >> 6;
 675          long l1 = 1L << (hiByte & 077);
 676          int i2 = (curChar & 0xff) >> 6;
 677          long l2 = 1L << (curChar & 077);
 678          do
 679          {
 680             switch(jjstateSet[--i])
 681             {
 682                case 0:
 683                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 684                      break;
 685                   if (kind > 29)
 686                      kind = 29;
 687                   jjstateSet[jjnewStateCnt++] = 0;
 688                   break;
 689                default : break;
 690             }
 691          } while(i != startsAt);
 692       }
 693       if (kind != 0x7fffffff)
 694       {
 695          jjmatchedKind = kind;
 696          jjmatchedPos = curPos;
 697          kind = 0x7fffffff;
 698       }
 699       ++curPos;
 700       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
 701          return curPos;
 702       try { curChar = input_stream.readChar(); }
 703       catch(java.io.IOException e) { return curPos; }
 704    }
 705 }
 706 private int jjMoveStringLiteralDfa0_4()
 707 {
 708    return jjMoveNfa_4(1, 0);
 709 }
 710 private int jjMoveNfa_4(int startState, int curPos)
 711 {
 712    int startsAt = 0;
 713    jjnewStateCnt = 2;
 714    int i = 1;
 715    jjstateSet[0] = startState;
 716    int kind = 0x7fffffff;
 717    for (;;)
 718    {
 719       if (++jjround == 0x7fffffff)
 720          ReInitRounds();
 721       if (curChar < 64)
 722       {
 723          long l = 1L << curChar;
 724          do
 725          {
 726             switch(jjstateSet[--i])
 727             {
 728                case 1:
 729                   if ((0xffffff7fffffffffL & l) != 0L)
 730                   {
 731                      if (kind > 23)
 732                         kind = 23;
 733                      jjCheckNAdd(0);
 734                   }
 735                   else if (curChar == 39)
 736                   {
 737                      if (kind > 24)
 738                         kind = 24;
 739                   }
 740                   break;
 741                case 0:
 742                   if ((0xffffff7fffffffffL & l) == 0L)
 743                      break;
 744                   kind = 23;
 745                   jjCheckNAdd(0);
 746                   break;
 747                default : break;
 748             }
 749          } while(i != startsAt);
 750       }
 751       else if (curChar < 128)
 752       {
 753          long l = 1L << (curChar & 077);
 754          do
 755          {
 756             switch(jjstateSet[--i])
 757             {
 758                case 1:
 759                case 0:
 760                   kind = 23;
 761                   jjCheckNAdd(0);
 762                   break;
 763                default : break;
 764             }
 765          } while(i != startsAt);
 766       }
 767       else
 768       {
 769          int hiByte = (int)(curChar >> 8);
 770          int i1 = hiByte >> 6;
 771          long l1 = 1L << (hiByte & 077);
 772          int i2 = (curChar & 0xff) >> 6;
 773          long l2 = 1L << (curChar & 077);
 774          do
 775          {
 776             switch(jjstateSet[--i])
 777             {
 778                case 1:
 779                case 0:
 780                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 781                      break;
 782                   if (kind > 23)
 783                      kind = 23;
 784                   jjCheckNAdd(0);
 785                   break;
 786                default : break;
 787             }
 788          } while(i != startsAt);
 789       }
 790       if (kind != 0x7fffffff)
 791       {
 792          jjmatchedKind = kind;
 793          jjmatchedPos = curPos;
 794          kind = 0x7fffffff;
 795       }
 796       ++curPos;
 797       if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
 798          return curPos;
 799       try { curChar = input_stream.readChar(); }
 800       catch(java.io.IOException e) { return curPos; }
 801    }
 802 }
 803 private final int jjStopStringLiteralDfa_3(int pos, long active0)
 804 {
 805    switch (pos)
 806    {
 807       default :
 808          return -1;
 809    }
 810 }
 811 private final int jjStartNfa_3(int pos, long active0)
 812 {
 813    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
 814 }
 815 private int jjMoveStringLiteralDfa0_3()
 816 {
 817    switch(curChar)
 818    {
 819       case 34:
 820          return jjStopAtPos(0, 21);
 821       case 39:
 822          return jjStopAtPos(0, 20);
 823       default :
 824          return jjMoveNfa_3(0, 0);
 825    }
 826 }
 827 private int jjMoveNfa_3(int startState, int curPos)
 828 {
 829    int startsAt = 0;
 830    jjnewStateCnt = 3;
 831    int i = 1;
 832    jjstateSet[0] = startState;
 833    int kind = 0x7fffffff;
 834    for (;;)
 835    {
 836       if (++jjround == 0x7fffffff)
 837          ReInitRounds();
 838       if (curChar < 64)
 839       {
 840          long l = 1L << curChar;
 841          do
 842          {
 843             switch(jjstateSet[--i])
 844             {
 845                case 0:
 846                   if ((0x9fffff7affffd9ffL & l) != 0L)
 847                   {
 848                      if (kind > 19)
 849                         kind = 19;
 850                      jjCheckNAdd(1);
 851                   }
 852                   else if ((0x100002600L & l) != 0L)
 853                   {
 854                      if (kind > 22)
 855                         kind = 22;
 856                      jjCheckNAdd(2);
 857                   }
 858                   break;
 859                case 1:
 860                   if ((0xbffffffeffffd9ffL & l) == 0L)
 861                      break;
 862                   if (kind > 19)
 863                      kind = 19;
 864                   jjCheckNAdd(1);
 865                   break;
 866                case 2:
 867                   if ((0x100002600L & l) == 0L)
 868                      break;
 869                   kind = 22;
 870                   jjCheckNAdd(2);
 871                   break;
 872                default : break;
 873             }
 874          } while(i != startsAt);
 875       }
 876       else if (curChar < 128)
 877       {
 878          long l = 1L << (curChar & 077);
 879          do
 880          {
 881             switch(jjstateSet[--i])
 882             {
 883                case 0:
 884                case 1:
 885                   if (kind > 19)
 886                      kind = 19;
 887                   jjCheckNAdd(1);
 888                   break;
 889                default : break;
 890             }
 891          } while(i != startsAt);
 892       }
 893       else
 894       {
 895          int hiByte = (int)(curChar >> 8);
 896          int i1 = hiByte >> 6;
 897          long l1 = 1L << (hiByte & 077);
 898          int i2 = (curChar & 0xff) >> 6;
 899          long l2 = 1L << (curChar & 077);
 900          do
 901          {
 902             switch(jjstateSet[--i])
 903             {
 904                case 0:
 905                case 1:
 906                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 907                      break;
 908                   if (kind > 19)
 909                      kind = 19;
 910                   jjCheckNAdd(1);
 911                   break;
 912                default : break;
 913             }
 914          } while(i != startsAt);
 915       }
 916       if (kind != 0x7fffffff)
 917       {
 918          jjmatchedKind = kind;
 919          jjmatchedPos = curPos;
 920          kind = 0x7fffffff;
 921       }
 922       ++curPos;
 923       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
 924          return curPos;
 925       try { curChar = input_stream.readChar(); }
 926       catch(java.io.IOException e) { return curPos; }
 927    }
 928 }
 929 private final int jjStopStringLiteralDfa_6(int pos, long active0)
 930 {
 931    switch (pos)
 932    {
 933       case 0:
 934          if ((active0 & 0x10000000L) != 0L)
 935          {
 936             jjmatchedKind = 27;
 937             return -1;
 938          }
 939          return -1;
 940       case 1:
 941          if ((active0 & 0x10000000L) != 0L)
 942          {
 943             if (jjmatchedPos == 0)
 944             {
 945                jjmatchedKind = 27;
 946                jjmatchedPos = 0;
 947             }
 948             return -1;
 949          }
 950          return -1;
 951       default :
 952          return -1;
 953    }
 954 }
 955 private final int jjStartNfa_6(int pos, long active0)
 956 {
 957    return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
 958 }
 959 private int jjMoveStringLiteralDfa0_6()
 960 {
 961    switch(curChar)
 962    {
 963       case 45:
 964          return jjMoveStringLiteralDfa1_6(0x10000000L);
 965       default :
 966          return jjMoveNfa_6(1, 0);
 967    }
 968 }
 969 private int jjMoveStringLiteralDfa1_6(long active0)
 970 {
 971    try { curChar = input_stream.readChar(); }
 972    catch(java.io.IOException e) {
 973       jjStopStringLiteralDfa_6(0, active0);
 974       return 1;
 975    }
 976    switch(curChar)
 977    {
 978       case 45:
 979          return jjMoveStringLiteralDfa2_6(active0, 0x10000000L);
 980       default :
 981          break;
 982    }
 983    return jjStartNfa_6(0, active0);
 984 }
 985 private int jjMoveStringLiteralDfa2_6(long old0, long active0)
 986 {
 987    if (((active0 &= old0)) == 0L)
 988       return jjStartNfa_6(0, old0);
 989    try { curChar = input_stream.readChar(); }
 990    catch(java.io.IOException e) {
 991       jjStopStringLiteralDfa_6(1, active0);
 992       return 2;
 993    }
 994    switch(curChar)
 995    {
 996       case 62:
 997          if ((active0 & 0x10000000L) != 0L)
 998             return jjStopAtPos(2, 28);
 999          break;
1000       default :
1001          break;
1002    }
1003    return jjStartNfa_6(1, active0);
1004 }
1005 private int jjMoveNfa_6(int startState, int curPos)
1006 {
1007    int startsAt = 0;
1008    jjnewStateCnt = 2;
1009    int i = 1;
1010    jjstateSet[0] = startState;
1011    int kind = 0x7fffffff;
1012    for (;;)
1013    {
1014       if (++jjround == 0x7fffffff)
1015          ReInitRounds();
1016       if (curChar < 64)
1017       {
1018          long l = 1L << curChar;
1019          do
1020          {
1021             switch(jjstateSet[--i])
1022             {
1023                case 1:
1024                   if ((0xffffdfffffffffffL & l) != 0L)
1025                   {
1026                      if (kind > 27)
1027                         kind = 27;
1028                      jjCheckNAdd(0);
1029                   }
1030                   else if (curChar == 45)
1031                   {
1032                      if (kind > 27)
1033                         kind = 27;
1034                   }
1035                   break;
1036                case 0:
1037                   if ((0xffffdfffffffffffL & l) == 0L)
1038                      break;
1039                   kind = 27;
1040                   jjCheckNAdd(0);
1041                   break;
1042                default : break;
1043             }
1044          } while(i != startsAt);
1045       }
1046       else if (curChar < 128)
1047       {
1048          long l = 1L << (curChar & 077);
1049          do
1050          {
1051             switch(jjstateSet[--i])
1052             {
1053                case 1:
1054                case 0:
1055                   kind = 27;
1056                   jjCheckNAdd(0);
1057                   break;
1058                default : break;
1059             }
1060          } while(i != startsAt);
1061       }
1062       else
1063       {
1064          int hiByte = (int)(curChar >> 8);
1065          int i1 = hiByte >> 6;
1066          long l1 = 1L << (hiByte & 077);
1067          int i2 = (curChar & 0xff) >> 6;
1068          long l2 = 1L << (curChar & 077);
1069          do
1070          {
1071             switch(jjstateSet[--i])
1072             {
1073                case 1:
1074                case 0:
1075                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1076                      break;
1077                   if (kind > 27)
1078                      kind = 27;
1079                   jjCheckNAdd(0);
1080                   break;
1081                default : break;
1082             }
1083          } while(i != startsAt);
1084       }
1085       if (kind != 0x7fffffff)
1086       {
1087          jjmatchedKind = kind;
1088          jjmatchedPos = curPos;
1089          kind = 0x7fffffff;
1090       }
1091       ++curPos;
1092       if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
1093          return curPos;
1094       try { curChar = input_stream.readChar(); }
1095       catch(java.io.IOException e) { return curPos; }
1096    }
1097 }
1098 private int jjMoveStringLiteralDfa0_1()
1099 {
1100    return jjMoveNfa_1(1, 0);
1101 }
1102 private int jjMoveNfa_1(int startState, int curPos)
1103 {
1104    int startsAt = 0;
1105    jjnewStateCnt = 12;
1106    int i = 1;
1107    jjstateSet[0] = startState;
1108    int kind = 0x7fffffff;
1109    for (;;)
1110    {
1111       if (++jjround == 0x7fffffff)
1112          ReInitRounds();
1113       if (curChar < 64)
1114       {
1115          long l = 1L << curChar;
1116          do
1117          {
1118             switch(jjstateSet[--i])
1119             {
1120                case 1:
1121                   if ((0xafffffffffffffffL & l) != 0L)
1122                   {
1123                      if (kind > 14)
1124                         kind = 14;
1125                      jjCheckNAdd(0);
1126                   }
1127                   else if ((0x5000000000000000L & l) != 0L)
1128                   {
1129                      if (kind > 14)
1130                         kind = 14;
1131                   }
1132                   if (curChar == 60)
1133                      jjstateSet[jjnewStateCnt++] = 10;
1134                   break;
1135                case 0:
1136                   if ((0xafffffffffffffffL & l) == 0L)
1137                      break;
1138                   if (kind > 14)
1139                      kind = 14;
1140                   jjCheckNAdd(0);
1141                   break;
1142                case 3:
1143                   if ((0xafffffffffffffffL & l) != 0L)
1144                      jjAddStates(18, 19);
1145                   break;
1146                case 4:
1147                   if (curChar == 62 && kind > 15)
1148                      kind = 15;
1149                   break;
1150                case 10:
1151                   if (curChar == 47)
1152                      jjstateSet[jjnewStateCnt++] = 9;
1153                   break;
1154                case 11:
1155                   if (curChar == 60)
1156                      jjstateSet[jjnewStateCnt++] = 10;
1157                   break;
1158                default : break;
1159             }
1160          } while(i != startsAt);
1161       }
1162       else if (curChar < 128)
1163       {
1164          long l = 1L << (curChar & 077);
1165          do
1166          {
1167             switch(jjstateSet[--i])
1168             {
1169                case 1:
1170                case 0:
1171                   if (kind > 14)
1172                      kind = 14;
1173                   jjCheckNAdd(0);
1174                   break;
1175                case 2:
1176                   if (curChar == 116)
1177                      jjCheckNAddTwoStates(3, 4);
1178                   break;
1179                case 3:
1180                   jjCheckNAddTwoStates(3, 4);
1181                   break;
1182                case 5:
1183                   if (curChar == 112)
1184                      jjstateSet[jjnewStateCnt++] = 2;
1185                   break;
1186                case 6:
1187                   if (curChar == 105)
1188                      jjstateSet[jjnewStateCnt++] = 5;
1189                   break;
1190                case 7:
1191                   if (curChar == 114)
1192                      jjstateSet[jjnewStateCnt++] = 6;
1193                   break;
1194                case 8:
1195                   if (curChar == 99)
1196                      jjstateSet[jjnewStateCnt++] = 7;
1197                   break;
1198                case 9:
1199                   if (curChar == 115)
1200                      jjstateSet[jjnewStateCnt++] = 8;
1201                   break;
1202                default : break;
1203             }
1204          } while(i != startsAt);
1205       }
1206       else
1207       {
1208          int hiByte = (int)(curChar >> 8);
1209          int i1 = hiByte >> 6;
1210          long l1 = 1L << (hiByte & 077);
1211          int i2 = (curChar & 0xff) >> 6;
1212          long l2 = 1L << (curChar & 077);
1213          do
1214          {
1215             switch(jjstateSet[--i])
1216             {
1217                case 1:
1218                case 0:
1219                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1220                      break;
1221                   if (kind > 14)
1222                      kind = 14;
1223                   jjCheckNAdd(0);
1224                   break;
1225                case 3:
1226                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1227                      jjAddStates(18, 19);
1228                   break;
1229                default : break;
1230             }
1231          } while(i != startsAt);
1232       }
1233       if (kind != 0x7fffffff)
1234       {
1235          jjmatchedKind = kind;
1236          jjmatchedPos = curPos;
1237          kind = 0x7fffffff;
1238       }
1239       ++curPos;
1240       if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
1241          return curPos;
1242       try { curChar = input_stream.readChar(); }
1243       catch(java.io.IOException e) { return curPos; }
1244    }
1245 }
1246 private final int jjStopStringLiteralDfa_2(int pos, long active0)
1247 {
1248    switch (pos)
1249    {
1250       default :
1251          return -1;
1252    }
1253 }
1254 private final int jjStartNfa_2(int pos, long active0)
1255 {
1256    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
1257 }
1258 private int jjMoveStringLiteralDfa0_2()
1259 {
1260    switch(curChar)
1261    {
1262       case 34:
1263          return jjStopAtPos(0, 21);
1264       case 39:
1265          return jjStopAtPos(0, 20);
1266       case 61:
1267          return jjStartNfaWithStates_2(0, 17, 3);
1268       default :
1269          return jjMoveNfa_2(0, 0);
1270    }
1271 }
1272 private int jjStartNfaWithStates_2(int pos, int kind, int state)
1273 {
1274    jjmatchedKind = kind;
1275    jjmatchedPos = pos;
1276    try { curChar = input_stream.readChar(); }
1277    catch(java.io.IOException e) { return pos + 1; }
1278    return jjMoveNfa_2(state, pos + 1);
1279 }
1280 private int jjMoveNfa_2(int startState, int curPos)
1281 {
1282    int startsAt = 0;
1283    jjnewStateCnt = 6;
1284    int i = 1;
1285    jjstateSet[0] = startState;
1286    int kind = 0x7fffffff;
1287    for (;;)
1288    {
1289       if (++jjround == 0x7fffffff)
1290          ReInitRounds();
1291       if (curChar < 64)
1292       {
1293          long l = 1L << curChar;
1294          do
1295          {
1296             switch(jjstateSet[--i])
1297             {
1298                case 0:
1299                   if ((0x9fffff7affffd9ffL & l) != 0L)
1300                   {
1301                      if (kind > 16)
1302                         kind = 16;
1303                      jjCheckNAdd(1);
1304                   }
1305                   else if ((0x100002600L & l) != 0L)
1306                   {
1307                      if (kind > 22)
1308                         kind = 22;
1309                      jjCheckNAdd(5);
1310                   }
1311                   else if (curChar == 61)
1312                      jjstateSet[jjnewStateCnt++] = 3;
1313                   else if (curChar == 62)
1314                   {
1315                      if (kind > 18)
1316                         kind = 18;
1317                   }
1318                   break;
1319                case 1:
1320                   if ((0x9ffffffeffffd9ffL & l) == 0L)
1321                      break;
1322                   if (kind > 16)
1323                      kind = 16;
1324                   jjCheckNAdd(1);
1325                   break;
1326                case 2:
1327                case 3:
1328                   if (curChar == 62 && kind > 18)
1329                      kind = 18;
1330                   break;
1331                case 4:
1332                   if (curChar == 61)
1333                      jjstateSet[jjnewStateCnt++] = 3;
1334                   break;
1335                case 5:
1336                   if ((0x100002600L & l) == 0L)
1337                      break;
1338                   kind = 22;
1339                   jjCheckNAdd(5);
1340                   break;
1341                default : break;
1342             }
1343          } while(i != startsAt);
1344       }
1345       else if (curChar < 128)
1346       {
1347          long l = 1L << (curChar & 077);
1348          do
1349          {
1350             switch(jjstateSet[--i])
1351             {
1352                case 0:
1353                case 1:
1354                   if (kind > 16)
1355                      kind = 16;
1356                   jjCheckNAdd(1);
1357                   break;
1358                default : break;
1359             }
1360          } while(i != startsAt);
1361       }
1362       else
1363       {
1364          int hiByte = (int)(curChar >> 8);
1365          int i1 = hiByte >> 6;
1366          long l1 = 1L << (hiByte & 077);
1367          int i2 = (curChar & 0xff) >> 6;
1368          long l2 = 1L << (curChar & 077);
1369          do
1370          {
1371             switch(jjstateSet[--i])
1372             {
1373                case 0:
1374                case 1:
1375                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1376                      break;
1377                   if (kind > 16)
1378                      kind = 16;
1379                   jjCheckNAdd(1);
1380                   break;
1381                default : break;
1382             }
1383          } while(i != startsAt);
1384       }
1385       if (kind != 0x7fffffff)
1386       {
1387          jjmatchedKind = kind;
1388          jjmatchedPos = curPos;
1389          kind = 0x7fffffff;
1390       }
1391       ++curPos;
1392       if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
1393          return curPos;
1394       try { curChar = input_stream.readChar(); }
1395       catch(java.io.IOException e) { return curPos; }
1396    }
1397 }
1398 static final int[] jjnextStates = {
1399    20, 21, 24, 12, 14, 16, 5, 8, 0, 4, 6, 0, 4, 6, 5, 0,
1400    4, 6, 3, 4,
1401 };
1402 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1403 {
1404    switch(hiByte)
1405    {
1406       case 0:
1407          return ((jjbitVec2[i2] & l2) != 0L);
1408       default :
1409          if ((jjbitVec0[i1] & l1) != 0L)
1410             return true;
1411          return false;
1412    }
1413 }
1414
1415 /** Token literal values. */
1416 public static final String[] jjstrLiteralImages = {
1417 "", "\74\163\143\162\151\160\164", null, null, "\74\41\55\55", "\74\41", null,
1418 null, null, null, null, null, null, null, null, null, null, "\75", null, null,
1419 "\47", "\42", null, null, null, null, null, null, "\55\55\76", null, "\76", };
1420
1421 /** Lexer state names. */
1422 public static final String[] lexStateNames = {
1423    "DEFAULT",
1424    "WithinScript",
1425    "WithinTag",
1426    "AfterEquals",
1427    "WithinQuote1",
1428    "WithinQuote2",
1429    "WithinComment1",
1430    "WithinComment2",
1431 };
1432
1433 /** Lex State array. */
1434 public static final int[] jjnewLexState = {
1435    -1, 1, 2, 2, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, 3, 0, 2, 4, 5, -1, -1, 2,
1436    -1, 2, -1, 0, -1, 0,
1437 };
1438 static final long[] jjtoToken = {
1439    0x7fbfec7fL,
1440 };
1441 static final long[] jjtoSkip = {
1442    0x400000L,
1443 };
1444 protected SimpleCharStream input_stream;
1445 private final int[] jjrounds = new int[28];
1446 private final int[] jjstateSet = new int[56];
1447 protected char curChar;
1448 /** Constructor. */
1449 public HTMLParserTokenManager(SimpleCharStream stream){
1450    if (SimpleCharStream.staticFlag)
1451       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1452    input_stream = stream;
1453 }
1454
1455 /** Constructor. */
1456 public HTMLParserTokenManager(SimpleCharStream stream, int lexState){
1457    this(stream);
1458    SwitchTo(lexState);
1459 }
1460
1461 /** Reinitialise parser. */
1462 public void ReInit(SimpleCharStream stream)
1463 {
1464    jjmatchedPos = jjnewStateCnt = 0;
1465    curLexState = defaultLexState;
1466    input_stream = stream;
1467    ReInitRounds();
1468 }
1469 private void ReInitRounds()
1470 {
1471    int i;
1472    jjround = 0x80000001;
1473    for (i = 28; i-- > 0;)
1474       jjrounds[i] = 0x80000000;
1475 }
1476
1477 /** Reinitialise parser. */
1478 public void ReInit(SimpleCharStream stream, int lexState)
1479 {
1480    ReInit(stream);
1481    SwitchTo(lexState);
1482 }
1483
1484 /** Switch to specified lex state. */
1485 public void SwitchTo(int lexState)
1486 {
1487    if (lexState >= 8 || lexState < 0)
1488       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1489    else
1490       curLexState = lexState;
1491 }
1492
1493 protected Token jjFillToken()
1494 {
1495    final Token t;
1496    final String curTokenImage;
1497    final int beginLine;
1498    final int endLine;
1499    final int beginColumn;
1500    final int endColumn;
1501    String im = jjstrLiteralImages[jjmatchedKind];
1502    curTokenImage = (im == null) ? input_stream.GetImage() : im;
1503    beginLine = input_stream.getBeginLine();
1504    beginColumn = input_stream.getBeginColumn();
1505    endLine = input_stream.getEndLine();
1506    endColumn = input_stream.getEndColumn();
1507    t = Token.newToken(jjmatchedKind, curTokenImage);
1508
1509    t.beginLine = beginLine;
1510    t.endLine = endLine;
1511    t.beginColumn = beginColumn;
1512    t.endColumn = endColumn;
1513
1514    return t;
1515 }
1516
1517 int curLexState = 0;
1518 int defaultLexState = 0;
1519 int jjnewStateCnt;
1520 int jjround;
1521 int jjmatchedPos;
1522 int jjmatchedKind;
1523
1524 /** Get the next Token. */
1525 public Token getNextToken()
1526 {
1527   Token matchedToken;
1528   int curPos = 0;
1529
1530   EOFLoop :
1531   for (;;)
1532   {
1533    try
1534    {
1535       curChar = input_stream.BeginToken();
1536    }
1537    catch(java.io.IOException e)
1538    {
1539       jjmatchedKind = 0;
1540       matchedToken = jjFillToken();
1541       return matchedToken;
1542    }
1543
1544    switch(curLexState)
1545    {
1546      case 0:
1547        jjmatchedKind = 0x7fffffff;
1548        jjmatchedPos = 0;
1549        curPos = jjMoveStringLiteralDfa0_0();
1550        if (jjmatchedPos == 0 && jjmatchedKind > 13)
1551        {
1552           jjmatchedKind = 13;
1553        }
1554        break;
1555      case 1:
1556        jjmatchedKind = 0x7fffffff;
1557        jjmatchedPos = 0;
1558        curPos = jjMoveStringLiteralDfa0_1();
1559        break;
1560      case 2:
1561        jjmatchedKind = 0x7fffffff;
1562        jjmatchedPos = 0;
1563        curPos = jjMoveStringLiteralDfa0_2();
1564        break;
1565      case 3:
1566        jjmatchedKind = 0x7fffffff;
1567        jjmatchedPos = 0;
1568        curPos = jjMoveStringLiteralDfa0_3();
1569        break;
1570      case 4:
1571        jjmatchedKind = 0x7fffffff;
1572        jjmatchedPos = 0;
1573        curPos = jjMoveStringLiteralDfa0_4();
1574        break;
1575      case 5:
1576        jjmatchedKind = 0x7fffffff;
1577        jjmatchedPos = 0;
1578        curPos = jjMoveStringLiteralDfa0_5();
1579        break;
1580      case 6:
1581        jjmatchedKind = 0x7fffffff;
1582        jjmatchedPos = 0;
1583        curPos = jjMoveStringLiteralDfa0_6();
1584        break;
1585      case 7:
1586        jjmatchedKind = 0x7fffffff;
1587        jjmatchedPos = 0;
1588        curPos = jjMoveStringLiteralDfa0_7();
1589        break;
1590    }
1591      if (jjmatchedKind != 0x7fffffff)
1592      {
1593         if (jjmatchedPos + 1 < curPos)
1594            input_stream.backup(curPos - jjmatchedPos - 1);
1595         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1596         {
1597            matchedToken = jjFillToken();
1598        if (jjnewLexState[jjmatchedKind] != -1)
1599          curLexState = jjnewLexState[jjmatchedKind];
1600            return matchedToken;
1601         }
1602         else
1603         {
1604          if (jjnewLexState[jjmatchedKind] != -1)
1605            curLexState = jjnewLexState[jjmatchedKind];
1606            continue EOFLoop;
1607         }
1608      }
1609      int error_line = input_stream.getEndLine();
1610      int error_column = input_stream.getEndColumn();
1611      String error_after = null;
1612      boolean EOFSeen = false;
1613      try { input_stream.readChar(); input_stream.backup(1); }
1614      catch (java.io.IOException e1) {
1615         EOFSeen = true;
1616         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1617         if (curChar == '\n' || curChar == '\r') {
1618            error_line++;
1619            error_column = 0;
1620         }
1621         else
1622            error_column++;
1623      }
1624      if (!EOFSeen) {
1625         input_stream.backup(1);
1626         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1627      }
1628      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1629   }
1630 }
1631
1632 private void jjCheckNAdd(int state)
1633 {
1634    if (jjrounds[state] != jjround)
1635    {
1636       jjstateSet[jjnewStateCnt++] = state;
1637       jjrounds[state] = jjround;
1638    }
1639 }
1640 private void jjAddStates(int start, int end)
1641 {
1642    do {
1643       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1644    } while (start++ != end);
1645 }
1646 private void jjCheckNAddTwoStates(int state1, int state2)
1647 {
1648    jjCheckNAdd(state1);
1649    jjCheckNAdd(state2);
1650 }
1651
1652 private void jjCheckNAddStates(int start, int end)
1653 {
1654    do {
1655       jjCheckNAdd(jjnextStates[start]);
1656    } while (start++ != end);
1657 }
1658
1659 }