Source for org.jfree.formula.parser.GeneratedFormulaParserTokenManager

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