bundles/org.simantics.graphviz/src/org/simantics/graphviz/internal/parser/DotParserTokenManager.java

   1 /* Generated By:JavaCC: Do not edit this line. DotParserTokenManager.java */
   2 package org.simantics.graphviz.internal.parser;
   3
   4 /** Token Manager. */
   5 @SuppressWarnings("all")
   6 public class DotParserTokenManager implements DotParserConstants
   7 {
   8
   9   /** Debug output. */
  10   public  java.io.PrintStream debugStream = System.out;
  11   /** Set debug output. */
  12   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  13 private final int jjStopStringLiteralDfa_0(int pos, long active0)
  14 {
  15    switch (pos)
  16    {
  17       case 0:
  18          if ((active0 & 0x7e000L) != 0L)
  19          {
  20             jjmatchedKind = 22;
  21             return 18;
  22          }
  23          if ((active0 & 0x60L) != 0L)
  24             return 34;
  25          return -1;
  26       case 1:
  27          if ((active0 & 0x7e000L) != 0L)
  28          {
  29             jjmatchedKind = 22;
  30             jjmatchedPos = 1;
  31             return 18;
  32          }
  33          return -1;
  34       case 2:
  35          if ((active0 & 0x7e000L) != 0L)
  36          {
  37             jjmatchedKind = 22;
  38             jjmatchedPos = 2;
  39             return 18;
  40          }
  41          return -1;
  42       case 3:
  43          if ((active0 & 0x30000L) != 0L)
  44             return 18;
  45          if ((active0 & 0x4e000L) != 0L)
  46          {
  47             jjmatchedKind = 22;
  48             jjmatchedPos = 3;
  49             return 18;
  50          }
  51          return -1;
  52       case 4:
  53          if ((active0 & 0x46000L) != 0L)
  54          {
  55             jjmatchedKind = 22;
  56             jjmatchedPos = 4;
  57             return 18;
  58          }
  59          if ((active0 & 0x8000L) != 0L)
  60             return 18;
  61          return -1;
  62       case 5:
  63          if ((active0 & 0x40000L) != 0L)
  64             return 18;
  65          if ((active0 & 0x6000L) != 0L)
  66          {
  67             jjmatchedKind = 22;
  68             jjmatchedPos = 5;
  69             return 18;
  70          }
  71          return -1;
  72       case 6:
  73          if ((active0 & 0x4000L) != 0L)
  74             return 18;
  75          if ((active0 & 0x2000L) != 0L)
  76          {
  77             jjmatchedKind = 22;
  78             jjmatchedPos = 6;
  79             return 18;
  80          }
  81          return -1;
  82       default :
  83          return -1;
  84    }
  85 }
  86 private final int jjStartNfa_0(int pos, long active0)
  87 {
  88    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
  89 }
  90 private int jjStopAtPos(int pos, int kind)
  91 {
  92    jjmatchedKind = kind;
  93    jjmatchedPos = pos;
  94    return pos + 1;
  95 }
  96 private int jjMoveStringLiteralDfa0_0()
  97 {
  98    switch(curChar)
  99    {
 100       case 44:
 101          return jjStopAtPos(0, 12);
 102       case 45:
 103          return jjMoveStringLiteralDfa1_0(0x60L);
 104       case 58:
 105          return jjStopAtPos(0, 7);
 106       case 59:
 107          return jjStopAtPos(0, 19);
 108       case 61:
 109          return jjStopAtPos(0, 4);
 110       case 91:
 111          return jjStopAtPos(0, 10);
 112       case 93:
 113          return jjStopAtPos(0, 11);
 114       case 68:
 115       case 100:
 116          return jjMoveStringLiteralDfa1_0(0x4000L);
 117       case 69:
 118       case 101:
 119          return jjMoveStringLiteralDfa1_0(0x20000L);
 120       case 71:
 121       case 103:
 122          return jjMoveStringLiteralDfa1_0(0x8000L);
 123       case 78:
 124       case 110:
 125          return jjMoveStringLiteralDfa1_0(0x10000L);
 126       case 83:
 127       case 115:
 128          return jjMoveStringLiteralDfa1_0(0x42000L);
 129       case 123:
 130          return jjStopAtPos(0, 8);
 131       case 125:
 132          return jjStopAtPos(0, 9);
 133       default :
 134          return jjMoveNfa_0(0, 0);
 135    }
 136 }
 137 private int jjMoveStringLiteralDfa1_0(long active0)
 138 {
 139    try { curChar = input_stream.readChar(); }
 140    catch(java.io.IOException e) {
 141       jjStopStringLiteralDfa_0(0, active0);
 142       return 1;
 143    }
 144    switch(curChar)
 145    {
 146       case 45:
 147          if ((active0 & 0x40L) != 0L)
 148             return jjStopAtPos(1, 6);
 149          break;
 150       case 62:
 151          if ((active0 & 0x20L) != 0L)
 152             return jjStopAtPos(1, 5);
 153          break;
 154       case 68:
 155       case 100:
 156          return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
 157       case 73:
 158       case 105:
 159          return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
 160       case 79:
 161       case 111:
 162          return jjMoveStringLiteralDfa2_0(active0, 0x10000L);
 163       case 82:
 164       case 114:
 165          return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
 166       case 84:
 167       case 116:
 168          return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
 169       case 85:
 170       case 117:
 171          return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
 172       default :
 173          break;
 174    }
 175    return jjStartNfa_0(0, active0);
 176 }
 177 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
 178 {
 179    if (((active0 &= old0)) == 0L)
 180       return jjStartNfa_0(0, old0);
 181    try { curChar = input_stream.readChar(); }
 182    catch(java.io.IOException e) {
 183       jjStopStringLiteralDfa_0(1, active0);
 184       return 2;
 185    }
 186    switch(curChar)
 187    {
 188       case 65:
 189       case 97:
 190          return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
 191       case 66:
 192       case 98:
 193          return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
 194       case 68:
 195       case 100:
 196          return jjMoveStringLiteralDfa3_0(active0, 0x10000L);
 197       case 71:
 198       case 103:
 199          return jjMoveStringLiteralDfa3_0(active0, 0x24000L);
 200       case 82:
 201       case 114:
 202          return jjMoveStringLiteralDfa3_0(active0, 0x40000L);
 203       default :
 204          break;
 205    }
 206    return jjStartNfa_0(1, active0);
 207 }
 208 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
 209 {
 210    if (((active0 &= old0)) == 0L)
 211       return jjStartNfa_0(1, old0);
 212    try { curChar = input_stream.readChar(); }
 213    catch(java.io.IOException e) {
 214       jjStopStringLiteralDfa_0(2, active0);
 215       return 3;
 216    }
 217    switch(curChar)
 218    {
 219       case 69:
 220       case 101:
 221          if ((active0 & 0x10000L) != 0L)
 222             return jjStartNfaWithStates_0(3, 16, 18);
 223          else if ((active0 & 0x20000L) != 0L)
 224             return jjStartNfaWithStates_0(3, 17, 18);
 225          break;
 226       case 71:
 227       case 103:
 228          return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
 229       case 73:
 230       case 105:
 231          return jjMoveStringLiteralDfa4_0(active0, 0x40000L);
 232       case 80:
 233       case 112:
 234          return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
 235       case 82:
 236       case 114:
 237          return jjMoveStringLiteralDfa4_0(active0, 0x4000L);
 238       default :
 239          break;
 240    }
 241    return jjStartNfa_0(2, active0);
 242 }
 243 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
 244 {
 245    if (((active0 &= old0)) == 0L)
 246       return jjStartNfa_0(2, old0);
 247    try { curChar = input_stream.readChar(); }
 248    catch(java.io.IOException e) {
 249       jjStopStringLiteralDfa_0(3, active0);
 250       return 4;
 251    }
 252    switch(curChar)
 253    {
 254       case 65:
 255       case 97:
 256          return jjMoveStringLiteralDfa5_0(active0, 0x4000L);
 257       case 67:
 258       case 99:
 259          return jjMoveStringLiteralDfa5_0(active0, 0x40000L);
 260       case 72:
 261       case 104:
 262          if ((active0 & 0x8000L) != 0L)
 263             return jjStartNfaWithStates_0(4, 15, 18);
 264          break;
 265       case 82:
 266       case 114:
 267          return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
 268       default :
 269          break;
 270    }
 271    return jjStartNfa_0(3, active0);
 272 }
 273 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
 274 {
 275    if (((active0 &= old0)) == 0L)
 276       return jjStartNfa_0(3, old0);
 277    try { curChar = input_stream.readChar(); }
 278    catch(java.io.IOException e) {
 279       jjStopStringLiteralDfa_0(4, active0);
 280       return 5;
 281    }
 282    switch(curChar)
 283    {
 284       case 65:
 285       case 97:
 286          return jjMoveStringLiteralDfa6_0(active0, 0x2000L);
 287       case 80:
 288       case 112:
 289          return jjMoveStringLiteralDfa6_0(active0, 0x4000L);
 290       case 84:
 291       case 116:
 292          if ((active0 & 0x40000L) != 0L)
 293             return jjStartNfaWithStates_0(5, 18, 18);
 294          break;
 295       default :
 296          break;
 297    }
 298    return jjStartNfa_0(4, active0);
 299 }
 300 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
 301 {
 302    if (((active0 &= old0)) == 0L)
 303       return jjStartNfa_0(4, old0);
 304    try { curChar = input_stream.readChar(); }
 305    catch(java.io.IOException e) {
 306       jjStopStringLiteralDfa_0(5, active0);
 307       return 6;
 308    }
 309    switch(curChar)
 310    {
 311       case 72:
 312       case 104:
 313          if ((active0 & 0x4000L) != 0L)
 314             return jjStartNfaWithStates_0(6, 14, 18);
 315          break;
 316       case 80:
 317       case 112:
 318          return jjMoveStringLiteralDfa7_0(active0, 0x2000L);
 319       default :
 320          break;
 321    }
 322    return jjStartNfa_0(5, active0);
 323 }
 324 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
 325 {
 326    if (((active0 &= old0)) == 0L)
 327       return jjStartNfa_0(5, old0);
 328    try { curChar = input_stream.readChar(); }
 329    catch(java.io.IOException e) {
 330       jjStopStringLiteralDfa_0(6, active0);
 331       return 7;
 332    }
 333    switch(curChar)
 334    {
 335       case 72:
 336       case 104:
 337          if ((active0 & 0x2000L) != 0L)
 338             return jjStartNfaWithStates_0(7, 13, 18);
 339          break;
 340       default :
 341          break;
 342    }
 343    return jjStartNfa_0(6, active0);
 344 }
 345 private int jjStartNfaWithStates_0(int pos, int kind, int state)
 346 {
 347    jjmatchedKind = kind;
 348    jjmatchedPos = pos;
 349    try { curChar = input_stream.readChar(); }
 350    catch(java.io.IOException e) { return pos + 1; }
 351    return jjMoveNfa_0(state, pos + 1);
 352 }
 353 static final long[] jjbitVec0 = {
 354    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 355 };
 356 private int jjMoveNfa_0(int startState, int curPos)
 357 {
 358    int startsAt = 0;
 359    jjnewStateCnt = 34;
 360    int i = 1;
 361    jjstateSet[0] = startState;
 362    int kind = 0x7fffffff;
 363    for (;;)
 364    {
 365       if (++jjround == 0x7fffffff)
 366          ReInitRounds();
 367       if (curChar < 64)
 368       {
 369          long l = 1L << curChar;
 370          do
 371          {
 372             switch(jjstateSet[--i])
 373             {
 374                case 0:
 375                   if ((0x3ff000000000000L & l) != 0L)
 376                   {
 377                      if (kind > 23)
 378                         kind = 23;
 379                      jjCheckNAddTwoStates(22, 23);
 380                   }
 381                   else if ((0x100002600L & l) != 0L)
 382                   {
 383                      if (kind > 1)
 384                         kind = 1;
 385                   }
 386                   else if (curChar == 47)
 387                      jjAddStates(0, 1);
 388                   else if (curChar == 46)
 389                      jjCheckNAdd(21);
 390                   else if (curChar == 45)
 391                      jjCheckNAddTwoStates(20, 22);
 392                   else if (curChar == 60)
 393                      jjCheckNAddStates(2, 4);
 394                   else if (curChar == 34)
 395                      jjCheckNAddStates(5, 7);
 396                   break;
 397                case 34:
 398                   if ((0x3ff000000000000L & l) != 0L)
 399                   {
 400                      if (kind > 23)
 401                         kind = 23;
 402                      jjCheckNAddTwoStates(22, 23);
 403                   }
 404                   else if (curChar == 46)
 405                      jjCheckNAdd(21);
 406                   break;
 407                case 1:
 408                   if (curChar == 34)
 409                      jjCheckNAddStates(5, 7);
 410                   break;
 411                case 2:
 412                   if ((0xfffffffbffffffffL & l) != 0L)
 413                      jjCheckNAddStates(5, 7);
 414                   break;
 415                case 4:
 416                   jjCheckNAddStates(5, 7);
 417                   break;
 418                case 5:
 419                   if (curChar == 34 && kind > 20)
 420                      kind = 20;
 421                   break;
 422                case 6:
 423                   if (curChar == 60)
 424                      jjCheckNAddStates(2, 4);
 425                   break;
 426                case 7:
 427                   if ((0xafffffffffffffffL & l) != 0L)
 428                      jjCheckNAddStates(2, 4);
 429                   break;
 430                case 8:
 431                   if (curChar == 60)
 432                      jjCheckNAddStates(8, 10);
 433                   break;
 434                case 9:
 435                   if ((0xaffffffbffffffffL & l) != 0L)
 436                      jjCheckNAddStates(8, 10);
 437                   break;
 438                case 10:
 439                   if (curChar == 34)
 440                      jjCheckNAddStates(11, 13);
 441                   break;
 442                case 11:
 443                   if ((0xfffffffbffffffffL & l) != 0L)
 444                      jjCheckNAddStates(11, 13);
 445                   break;
 446                case 13:
 447                   jjCheckNAddStates(11, 13);
 448                   break;
 449                case 14:
 450                   if (curChar == 34)
 451                      jjCheckNAddStates(8, 10);
 452                   break;
 453                case 15:
 454                   if (curChar == 62)
 455                      jjCheckNAddStates(2, 4);
 456                   break;
 457                case 16:
 458                   if (curChar == 62 && kind > 21)
 459                      kind = 21;
 460                   break;
 461                case 18:
 462                   if ((0x7ff000000000000L & l) == 0L)
 463                      break;
 464                   if (kind > 22)
 465                      kind = 22;
 466                   jjstateSet[jjnewStateCnt++] = 18;
 467                   break;
 468                case 19:
 469                   if (curChar == 45)
 470                      jjCheckNAddTwoStates(20, 22);
 471                   break;
 472                case 20:
 473                   if (curChar == 46)
 474                      jjCheckNAdd(21);
 475                   break;
 476                case 21:
 477                   if ((0x3ff000000000000L & l) == 0L)
 478                      break;
 479                   if (kind > 23)
 480                      kind = 23;
 481                   jjCheckNAdd(21);
 482                   break;
 483                case 22:
 484                   if ((0x3ff000000000000L & l) == 0L)
 485                      break;
 486                   if (kind > 23)
 487                      kind = 23;
 488                   jjCheckNAddTwoStates(22, 23);
 489                   break;
 490                case 23:
 491                   if (curChar != 46)
 492                      break;
 493                   if (kind > 23)
 494                      kind = 23;
 495                   jjCheckNAdd(24);
 496                   break;
 497                case 24:
 498                   if ((0x3ff000000000000L & l) == 0L)
 499                      break;
 500                   if (kind > 23)
 501                      kind = 23;
 502                   jjCheckNAdd(24);
 503                   break;
 504                case 25:
 505                   if (curChar == 47)
 506                      jjAddStates(0, 1);
 507                   break;
 508                case 26:
 509                   if (curChar == 42)
 510                      jjCheckNAddStates(14, 16);
 511                   break;
 512                case 27:
 513                   if ((0xfffffbffffffffffL & l) != 0L)
 514                      jjCheckNAddStates(14, 16);
 515                   break;
 516                case 28:
 517                   if (curChar == 42)
 518                      jjstateSet[jjnewStateCnt++] = 29;
 519                   break;
 520                case 29:
 521                   if ((0xffff7fffffffffffL & l) != 0L)
 522                      jjCheckNAddStates(14, 16);
 523                   break;
 524                case 30:
 525                   if (curChar == 47 && kind > 2)
 526                      kind = 2;
 527                   break;
 528                case 31:
 529                   if (curChar == 42)
 530                      jjstateSet[jjnewStateCnt++] = 30;
 531                   break;
 532                case 32:
 533                   if (curChar != 47)
 534                      break;
 535                   if (kind > 3)
 536                      kind = 3;
 537                   jjCheckNAdd(33);
 538                   break;
 539                case 33:
 540                   if ((0xfffffffffffffbffL & l) == 0L)
 541                      break;
 542                   if (kind > 3)
 543                      kind = 3;
 544                   jjCheckNAdd(33);
 545                   break;
 546                default : break;
 547             }
 548          } while(i != startsAt);
 549       }
 550       else if (curChar < 128)
 551       {
 552          long l = 1L << (curChar & 077);
 553          do
 554          {
 555             switch(jjstateSet[--i])
 556             {
 557                case 0:
 558                case 18:
 559                   if ((0x7fffffe87fffffeL & l) == 0L)
 560                      break;
 561                   if (kind > 22)
 562                      kind = 22;
 563                   jjCheckNAdd(18);
 564                   break;
 565                case 2:
 566                   if ((0xffffffffefffffffL & l) != 0L)
 567                      jjCheckNAddStates(5, 7);
 568                   break;
 569                case 3:
 570                   if (curChar == 92)
 571                      jjstateSet[jjnewStateCnt++] = 4;
 572                   break;
 573                case 4:
 574                   jjCheckNAddStates(5, 7);
 575                   break;
 576                case 7:
 577                   jjAddStates(2, 4);
 578                   break;
 579                case 9:
 580                   jjAddStates(8, 10);
 581                   break;
 582                case 11:
 583                   if ((0xffffffffefffffffL & l) != 0L)
 584                      jjCheckNAddStates(11, 13);
 585                   break;
 586                case 12:
 587                   if (curChar == 92)
 588                      jjstateSet[jjnewStateCnt++] = 13;
 589                   break;
 590                case 13:
 591                   jjCheckNAddStates(11, 13);
 592                   break;
 593                case 27:
 594                case 29:
 595                   jjCheckNAddStates(14, 16);
 596                   break;
 597                case 33:
 598                   if (kind > 3)
 599                      kind = 3;
 600                   jjstateSet[jjnewStateCnt++] = 33;
 601                   break;
 602                default : break;
 603             }
 604          } while(i != startsAt);
 605       }
 606       else
 607       {
 608          int i2 = (curChar & 0xff) >> 6;
 609          long l2 = 1L << (curChar & 077);
 610          do
 611          {
 612             switch(jjstateSet[--i])
 613             {
 614                case 2:
 615                case 4:
 616                   if ((jjbitVec0[i2] & l2) != 0L)
 617                      jjCheckNAddStates(5, 7);
 618                   break;
 619                case 7:
 620                   if ((jjbitVec0[i2] & l2) != 0L)
 621                      jjAddStates(2, 4);
 622                   break;
 623                case 9:
 624                   if ((jjbitVec0[i2] & l2) != 0L)
 625                      jjAddStates(8, 10);
 626                   break;
 627                case 11:
 628                case 13:
 629                   if ((jjbitVec0[i2] & l2) != 0L)
 630                      jjCheckNAddStates(11, 13);
 631                   break;
 632                case 27:
 633                case 29:
 634                   if ((jjbitVec0[i2] & l2) != 0L)
 635                      jjCheckNAddStates(14, 16);
 636                   break;
 637                case 33:
 638                   if ((jjbitVec0[i2] & l2) == 0L)
 639                      break;
 640                   if (kind > 3)
 641                      kind = 3;
 642                   jjstateSet[jjnewStateCnt++] = 33;
 643                   break;
 644                default : break;
 645             }
 646          } while(i != startsAt);
 647       }
 648       if (kind != 0x7fffffff)
 649       {
 650          jjmatchedKind = kind;
 651          jjmatchedPos = curPos;
 652          kind = 0x7fffffff;
 653       }
 654       ++curPos;
 655       if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
 656          return curPos;
 657       try { curChar = input_stream.readChar(); }
 658       catch(java.io.IOException e) { return curPos; }
 659    }
 660 }
 661 static final int[] jjnextStates = {
 662    26, 32, 7, 8, 16, 2, 3, 5, 9, 10, 15, 11, 12, 14, 27, 28,
 663    31,
 664 };
 665
 666 /** Token literal values. */
 667 public static final String[] jjstrLiteralImages = {
 668 "", null, null, null, "\75", "\55\76", "\55\55", "\72", "\173", "\175",
 669 "\133", "\135", "\54", null, null, null, null, null, null, "\73", null, null, null,
 670 null, };
 671
 672 /** Lexer state names. */
 673 public static final String[] lexStateNames = {
 674    "DEFAULT",
 675 };
 676 static final long[] jjtoToken = {
 677    0xfffff1L,
 678 };
 679 static final long[] jjtoSkip = {
 680    0xeL,
 681 };
 682 protected SimpleCharStream input_stream;
 683 private final int[] jjrounds = new int[34];
 684 private final int[] jjstateSet = new int[68];
 685 private final StringBuilder jjimage = new StringBuilder();
 686 private StringBuilder image = jjimage;
 687 private int jjimageLen;
 688 private int lengthOfMatch;
 689 protected char curChar;
 690 /** Constructor. */
 691 public DotParserTokenManager(SimpleCharStream stream){
 692    if (SimpleCharStream.staticFlag)
 693       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 694    input_stream = stream;
 695 }
 696
 697 /** Constructor. */
 698 public DotParserTokenManager(SimpleCharStream stream, int lexState){
 699    this(stream);
 700    SwitchTo(lexState);
 701 }
 702
 703 /** Reinitialise parser. */
 704 public void ReInit(SimpleCharStream stream)
 705 {
 706    jjmatchedPos = jjnewStateCnt = 0;
 707    curLexState = defaultLexState;
 708    input_stream = stream;
 709    ReInitRounds();
 710 }
 711 private void ReInitRounds()
 712 {
 713    int i;
 714    jjround = 0x80000001;
 715    for (i = 34; i-- > 0;)
 716       jjrounds[i] = 0x80000000;
 717 }
 718
 719 /** Reinitialise parser. */
 720 public void ReInit(SimpleCharStream stream, int lexState)
 721 {
 722    ReInit(stream);
 723    SwitchTo(lexState);
 724 }
 725
 726 /** Switch to specified lex state. */
 727 public void SwitchTo(int lexState)
 728 {
 729    if (lexState >= 1 || lexState < 0)
 730       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 731    else
 732       curLexState = lexState;
 733 }
 734
 735 protected Token jjFillToken()
 736 {
 737    final Token t;
 738    final String curTokenImage;
 739    final int beginLine;
 740    final int endLine;
 741    final int beginColumn;
 742    final int endColumn;
 743    String im = jjstrLiteralImages[jjmatchedKind];
 744    curTokenImage = (im == null) ? input_stream.GetImage() : im;
 745    beginLine = input_stream.getBeginLine();
 746    beginColumn = input_stream.getBeginColumn();
 747    endLine = input_stream.getEndLine();
 748    endColumn = input_stream.getEndColumn();
 749    t = Token.newToken(jjmatchedKind, curTokenImage);
 750
 751    t.beginLine = beginLine;
 752    t.endLine = endLine;
 753    t.beginColumn = beginColumn;
 754    t.endColumn = endColumn;
 755
 756    return t;
 757 }
 758
 759 int curLexState = 0;
 760 int defaultLexState = 0;
 761 int jjnewStateCnt;
 762 int jjround;
 763 int jjmatchedPos;
 764 int jjmatchedKind;
 765
 766 /** Get the next Token. */
 767 public Token getNextToken()
 768 {
 769   Token matchedToken;
 770   int curPos = 0;
 771
 772   EOFLoop :
 773   for (;;)
 774   {
 775    try
 776    {
 777       curChar = input_stream.BeginToken();
 778    }
 779    catch(java.io.IOException e)
 780    {
 781       jjmatchedKind = 0;
 782       matchedToken = jjFillToken();
 783       return matchedToken;
 784    }
 785    image = jjimage;
 786    image.setLength(0);
 787    jjimageLen = 0;
 788
 789    jjmatchedKind = 0x7fffffff;
 790    jjmatchedPos = 0;
 791    curPos = jjMoveStringLiteralDfa0_0();
 792    if (jjmatchedKind != 0x7fffffff)
 793    {
 794       if (jjmatchedPos + 1 < curPos)
 795          input_stream.backup(curPos - jjmatchedPos - 1);
 796       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 797       {
 798          matchedToken = jjFillToken();
 799          TokenLexicalActions(matchedToken);
 800          return matchedToken;
 801       }
 802       else
 803       {
 804          continue EOFLoop;
 805       }
 806    }
 807    int error_line = input_stream.getEndLine();
 808    int error_column = input_stream.getEndColumn();
 809    String error_after = null;
 810    boolean EOFSeen = false;
 811    try { input_stream.readChar(); input_stream.backup(1); }
 812    catch (java.io.IOException e1) {
 813       EOFSeen = true;
 814       error_after = curPos <= 1 ? "" : input_stream.GetImage();
 815       if (curChar == '\n' || curChar == '\r') {
 816          error_line++;
 817          error_column = 0;
 818       }
 819       else
 820          error_column++;
 821    }
 822    if (!EOFSeen) {
 823       input_stream.backup(1);
 824       error_after = curPos <= 1 ? "" : input_stream.GetImage();
 825    }
 826    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 827   }
 828 }
 829
 830 void TokenLexicalActions(Token matchedToken)
 831 {
 832    switch(jjmatchedKind)
 833    {
 834       case 20 :
 835         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
 836       matchedToken.image = matchedToken.image.substring(1,matchedToken.image.length()-1);
 837          break;
 838       default :
 839          break;
 840    }
 841 }
 842 private void jjCheckNAdd(int state)
 843 {
 844    if (jjrounds[state] != jjround)
 845    {
 846       jjstateSet[jjnewStateCnt++] = state;
 847       jjrounds[state] = jjround;
 848    }
 849 }
 850 private void jjAddStates(int start, int end)
 851 {
 852    do {
 853       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 854    } while (start++ != end);
 855 }
 856 private void jjCheckNAddTwoStates(int state1, int state2)
 857 {
 858    jjCheckNAdd(state1);
 859    jjCheckNAdd(state2);
 860 }
 861
 862 private void jjCheckNAddStates(int start, int end)
 863 {
 864    do {
 865       jjCheckNAdd(jjnextStates[start]);
 866    } while (start++ != end);
 867 }
 868
 869 }