bundles/org.simantics.spreadsheet/src/org/simantics/spreadsheet/solver/formula/parser/SheetFormulaParserTokenManager.java

   1 /* Generated By:JavaCC: Do not edit this line. SheetFormulaParserTokenManager.java */
   2 package org.simantics.spreadsheet.solver.formula.parser;
   3 import org.simantics.spreadsheet.solver.formula.parser.ast.*;
   4 import java.util.ArrayList;
   5 import java.util.List;
   6 import java.util.Collections;
   7
   8 /** Token Manager. */
   9 public class SheetFormulaParserTokenManager implements SheetFormulaParserConstants
  10 {
  11
  12   /** Debug output. */
  13   public  java.io.PrintStream debugStream = System.out;
  14   /** Set debug output. */
  15   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  16 private final int jjStopStringLiteralDfa_0(int pos, long active0)
  17 {
  18    switch (pos)
  19    {
  20       case 0:
  21          if ((active0 & 0x30000000L) != 0L)
  22          {
  23             jjmatchedKind = 38;
  24             return 82;
  25          }
  26          if ((active0 & 0xe000000L) != 0L)
  27          {
  28             jjmatchedKind = 38;
  29             return 21;
  30          }
  31          if ((active0 & 0x180000L) != 0L)
  32             return 23;
  33          if ((active0 & 0x10000L) != 0L)
  34             return 27;
  35          return -1;
  36       case 1:
  37          if ((active0 & 0x30000000L) != 0L)
  38          {
  39             jjmatchedKind = 38;
  40             jjmatchedPos = 1;
  41             return 70;
  42          }
  43          if ((active0 & 0xe000000L) != 0L)
  44          {
  45             jjmatchedKind = 38;
  46             jjmatchedPos = 1;
  47             return 21;
  48          }
  49          return -1;
  50       case 2:
  51          if ((active0 & 0x30000000L) != 0L)
  52          {
  53             jjmatchedKind = 38;
  54             jjmatchedPos = 2;
  55             return 83;
  56          }
  57          if ((active0 & 0xe000000L) != 0L)
  58          {
  59             jjmatchedKind = 38;
  60             jjmatchedPos = 2;
  61             return 21;
  62          }
  63          return -1;
  64       case 3:
  65          if ((active0 & 0x20000000L) != 0L)
  66          {
  67             jjmatchedKind = 38;
  68             jjmatchedPos = 3;
  69             return 84;
  70          }
  71          if ((active0 & 0x10000000L) != 0L)
  72             return 84;
  73          if ((active0 & 0x4000000L) != 0L)
  74          {
  75             jjmatchedKind = 38;
  76             jjmatchedPos = 3;
  77             return 21;
  78          }
  79          if ((active0 & 0xa000000L) != 0L)
  80             return 21;
  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 33:
 101          return jjStopAtPos(0, 42);
 102       case 35:
 103          return jjMoveStringLiteralDfa1_0(0x80000000000L);
 104       case 38:
 105          return jjStopAtPos(0, 13);
 106       case 40:
 107          return jjStopAtPos(0, 5);
 108       case 41:
 109          return jjStopAtPos(0, 6);
 110       case 42:
 111          return jjStopAtPos(0, 15);
 112       case 43:
 113          return jjStopAtPos(0, 14);
 114       case 44:
 115          return jjStopAtPos(0, 18);
 116       case 45:
 117          return jjStopAtPos(0, 46);
 118       case 46:
 119          jjmatchedKind = 20;
 120          return jjMoveStringLiteralDfa1_0(0x80000L);
 121       case 47:
 122          return jjStartNfaWithStates_0(0, 16, 27);
 123       case 59:
 124          return jjStopAtPos(0, 4);
 125       case 60:
 126          jjmatchedKind = 22;
 127          return jjMoveStringLiteralDfa1_0(0x100001000000L);
 128       case 61:
 129          return jjStopAtPos(0, 21);
 130       case 62:
 131          jjmatchedKind = 23;
 132          return jjMoveStringLiteralDfa1_0(0x200000000000L);
 133       case 63:
 134          return jjStopAtPos(0, 7);
 135       case 70:
 136          return jjMoveStringLiteralDfa1_0(0x20000000L);
 137       case 84:
 138          return jjMoveStringLiteralDfa1_0(0x10000000L);
 139       case 91:
 140          return jjStopAtPos(0, 8);
 141       case 93:
 142          return jjStopAtPos(0, 9);
 143       case 94:
 144          return jjStopAtPos(0, 17);
 145       case 102:
 146          return jjMoveStringLiteralDfa1_0(0x4000000L);
 147       case 110:
 148          return jjMoveStringLiteralDfa1_0(0x8000000L);
 149       case 116:
 150          return jjMoveStringLiteralDfa1_0(0x2000000L);
 151       case 123:
 152          return jjStopAtPos(0, 10);
 153       case 124:
 154          return jjStopAtPos(0, 12);
 155       case 125:
 156          return jjStopAtPos(0, 11);
 157       default :
 158          return jjMoveNfa_0(0, 0);
 159    }
 160 }
 161 private int jjMoveStringLiteralDfa1_0(long active0)
 162 {
 163    try { curChar = input_stream.readChar(); }
 164    catch(java.io.IOException e) {
 165       jjStopStringLiteralDfa_0(0, active0);
 166       return 1;
 167    }
 168    switch(curChar)
 169    {
 170       case 46:
 171          if ((active0 & 0x80000L) != 0L)
 172             return jjStopAtPos(1, 19);
 173          break;
 174       case 61:
 175          if ((active0 & 0x100000000000L) != 0L)
 176             return jjStopAtPos(1, 44);
 177          else if ((active0 & 0x200000000000L) != 0L)
 178             return jjStopAtPos(1, 45);
 179          break;
 180       case 62:
 181          if ((active0 & 0x1000000L) != 0L)
 182             return jjStopAtPos(1, 24);
 183          break;
 184       case 65:
 185          return jjMoveStringLiteralDfa2_0(active0, 0x20000000L);
 186       case 82:
 187          return jjMoveStringLiteralDfa2_0(active0, 0x80010000000L);
 188       case 97:
 189          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
 190       case 114:
 191          return jjMoveStringLiteralDfa2_0(active0, 0x2000000L);
 192       case 117:
 193          return jjMoveStringLiteralDfa2_0(active0, 0x8000000L);
 194       default :
 195          break;
 196    }
 197    return jjStartNfa_0(0, active0);
 198 }
 199 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
 200 {
 201    if (((active0 &= old0)) == 0L)
 202       return jjStartNfa_0(0, old0);
 203    try { curChar = input_stream.readChar(); }
 204    catch(java.io.IOException e) {
 205       jjStopStringLiteralDfa_0(1, active0);
 206       return 2;
 207    }
 208    switch(curChar)
 209    {
 210       case 69:
 211          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L);
 212       case 76:
 213          return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
 214       case 85:
 215          return jjMoveStringLiteralDfa3_0(active0, 0x10000000L);
 216       case 108:
 217          return jjMoveStringLiteralDfa3_0(active0, 0xc000000L);
 218       case 117:
 219          return jjMoveStringLiteralDfa3_0(active0, 0x2000000L);
 220       default :
 221          break;
 222    }
 223    return jjStartNfa_0(1, active0);
 224 }
 225 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
 226 {
 227    if (((active0 &= old0)) == 0L)
 228       return jjStartNfa_0(1, old0);
 229    try { curChar = input_stream.readChar(); }
 230    catch(java.io.IOException e) {
 231       jjStopStringLiteralDfa_0(2, active0);
 232       return 3;
 233    }
 234    switch(curChar)
 235    {
 236       case 69:
 237          if ((active0 & 0x10000000L) != 0L)
 238             return jjStartNfaWithStates_0(3, 28, 84);
 239          break;
 240       case 70:
 241          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L);
 242       case 83:
 243          return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
 244       case 101:
 245          if ((active0 & 0x2000000L) != 0L)
 246             return jjStartNfaWithStates_0(3, 25, 21);
 247          break;
 248       case 108:
 249          if ((active0 & 0x8000000L) != 0L)
 250             return jjStartNfaWithStates_0(3, 27, 21);
 251          break;
 252       case 115:
 253          return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
 254       default :
 255          break;
 256    }
 257    return jjStartNfa_0(2, active0);
 258 }
 259 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
 260 {
 261    if (((active0 &= old0)) == 0L)
 262       return jjStartNfa_0(2, old0);
 263    try { curChar = input_stream.readChar(); }
 264    catch(java.io.IOException e) {
 265       jjStopStringLiteralDfa_0(3, active0);
 266       return 4;
 267    }
 268    switch(curChar)
 269    {
 270       case 33:
 271          if ((active0 & 0x80000000000L) != 0L)
 272             return jjStopAtPos(4, 43);
 273          break;
 274       case 69:
 275          if ((active0 & 0x20000000L) != 0L)
 276             return jjStartNfaWithStates_0(4, 29, 85);
 277          break;
 278       case 101:
 279          if ((active0 & 0x4000000L) != 0L)
 280             return jjStartNfaWithStates_0(4, 26, 21);
 281          break;
 282       default :
 283          break;
 284    }
 285    return jjStartNfa_0(3, active0);
 286 }
 287 private int jjStartNfaWithStates_0(int pos, int kind, int state)
 288 {
 289    jjmatchedKind = kind;
 290    jjmatchedPos = pos;
 291    try { curChar = input_stream.readChar(); }
 292    catch(java.io.IOException e) { return pos + 1; }
 293    return jjMoveNfa_0(state, pos + 1);
 294 }
 295 static final long[] jjbitVec0 = {
 296    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 297 };
 298 static final long[] jjbitVec2 = {
 299    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 300 };
 301 static final long[] jjbitVec3 = {
 302    0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x1600000000000000L
 303 };
 304 static final long[] jjbitVec4 = {
 305    0x0L, 0x0L, 0xc603c0000000000L, 0xff7fffffff7fffffL
 306 };
 307 static final long[] jjbitVec5 = {
 308    0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 309 };
 310 static final long[] jjbitVec6 = {
 311    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
 312 };
 313 static final long[] jjbitVec7 = {
 314    0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
 315 };
 316 static final long[] jjbitVec8 = {
 317    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
 318 };
 319 static final long[] jjbitVec9 = {
 320    0x7f7ffdff80f8007fL, 0xffffffffffffffdbL, 0xffffffffffffffffL, 0xffffffffffffffffL
 321 };
 322 static final long[] jjbitVec10 = {
 323    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fff000000ffffffL
 324 };
 325 static final long[] jjbitVec11 = {
 326    0x0L, 0xffff000000000000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
 327 };
 328 static final long[] jjbitVec12 = {
 329    0x87ffffff80000000L, 0xfffffffe7fffffffL, 0x7fffffffffffffffL, 0x1cfcfcfcL
 330 };
 331 private int jjMoveNfa_0(int startState, int curPos)
 332 {
 333    int startsAt = 0;
 334    jjnewStateCnt = 82;
 335    int i = 1;
 336    jjstateSet[0] = startState;
 337    int kind = 0x7fffffff;
 338    for (;;)
 339    {
 340       if (++jjround == 0x7fffffff)
 341          ReInitRounds();
 342       if (curChar < 64)
 343       {
 344          long l = 1L << curChar;
 345          do
 346          {
 347             switch(jjstateSet[--i])
 348             {
 349                case 84:
 350                   if ((0x3ff001000000000L & l) != 0L)
 351                   {
 352                      if (kind > 38)
 353                         kind = 38;
 354                      jjCheckNAdd(21);
 355                   }
 356                   else if (curChar == 58)
 357                      jjCheckNAddTwoStates(50, 51);
 358                   if ((0x3ff000000000000L & l) != 0L)
 359                      jjCheckNAddStates(0, 4);
 360                   else if (curChar == 36)
 361                      jjCheckNAddTwoStates(49, 62);
 362                   if ((0x3ff000000000000L & l) != 0L)
 363                   {
 364                      if (kind > 35)
 365                         kind = 35;
 366                      jjstateSet[jjnewStateCnt++] = 39;
 367                   }
 368                   else if (curChar == 36)
 369                      jjstateSet[jjnewStateCnt++] = 38;
 370                   break;
 371                case 70:
 372                   if ((0x3ff001000000000L & l) != 0L)
 373                   {
 374                      if (kind > 38)
 375                         kind = 38;
 376                      jjCheckNAdd(21);
 377                   }
 378                   else if (curChar == 58)
 379                      jjCheckNAddTwoStates(50, 51);
 380                   if ((0x3ff000000000000L & l) != 0L)
 381                      jjCheckNAddStates(0, 4);
 382                   else if (curChar == 36)
 383                      jjCheckNAddTwoStates(49, 62);
 384                   if ((0x3ff000000000000L & l) != 0L)
 385                   {
 386                      if (kind > 35)
 387                         kind = 35;
 388                      jjstateSet[jjnewStateCnt++] = 39;
 389                   }
 390                   else if (curChar == 36)
 391                      jjstateSet[jjnewStateCnt++] = 38;
 392                   break;
 393                case 85:
 394                   if ((0x3ff001000000000L & l) != 0L)
 395                   {
 396                      if (kind > 38)
 397                         kind = 38;
 398                      jjCheckNAdd(21);
 399                   }
 400                   else if (curChar == 58)
 401                      jjCheckNAddTwoStates(50, 51);
 402                   if ((0x3ff000000000000L & l) != 0L)
 403                      jjCheckNAddStates(0, 4);
 404                   else if (curChar == 36)
 405                      jjCheckNAddTwoStates(49, 62);
 406                   if ((0x3ff000000000000L & l) != 0L)
 407                   {
 408                      if (kind > 35)
 409                         kind = 35;
 410                      jjstateSet[jjnewStateCnt++] = 39;
 411                   }
 412                   else if (curChar == 36)
 413                      jjstateSet[jjnewStateCnt++] = 38;
 414                   break;
 415                case 83:
 416                   if ((0x3ff001000000000L & l) != 0L)
 417                   {
 418                      if (kind > 38)
 419                         kind = 38;
 420                      jjCheckNAdd(21);
 421                   }
 422                   else if (curChar == 58)
 423                      jjCheckNAddTwoStates(50, 51);
 424                   if ((0x3ff000000000000L & l) != 0L)
 425                      jjCheckNAddStates(0, 4);
 426                   else if (curChar == 36)
 427                      jjCheckNAddTwoStates(49, 62);
 428                   if ((0x3ff000000000000L & l) != 0L)
 429                   {
 430                      if (kind > 35)
 431                         kind = 35;
 432                      jjstateSet[jjnewStateCnt++] = 39;
 433                   }
 434                   else if (curChar == 36)
 435                      jjstateSet[jjnewStateCnt++] = 38;
 436                   break;
 437                case 82:
 438                   if ((0x3ff001000000000L & l) != 0L)
 439                   {
 440                      if (kind > 38)
 441                         kind = 38;
 442                      jjCheckNAdd(21);
 443                   }
 444                   else if (curChar == 58)
 445                      jjCheckNAddTwoStates(50, 51);
 446                   if ((0x3ff000000000000L & l) != 0L)
 447                      jjCheckNAddStates(0, 4);
 448                   else if (curChar == 36)
 449                      jjCheckNAddTwoStates(49, 62);
 450                   if ((0x3ff000000000000L & l) != 0L)
 451                   {
 452                      if (kind > 35)
 453                         kind = 35;
 454                      jjstateSet[jjnewStateCnt++] = 39;
 455                   }
 456                   else if (curChar == 36)
 457                      jjstateSet[jjnewStateCnt++] = 38;
 458                   break;
 459                case 27:
 460                   if (curChar == 47)
 461                   {
 462                      if (kind > 3)
 463                         kind = 3;
 464                      jjCheckNAdd(34);
 465                   }
 466                   else if (curChar == 42)
 467                      jjCheckNAddStates(5, 7);
 468                   break;
 469                case 0:
 470                   if ((0x3ff000000000000L & l) != 0L)
 471                   {
 472                      if (kind > 41)
 473                         kind = 41;
 474                      jjCheckNAddStates(8, 12);
 475                   }
 476                   else if ((0x100002600L & l) != 0L)
 477                   {
 478                      if (kind > 1)
 479                         kind = 1;
 480                   }
 481                   else if (curChar == 36)
 482                      jjAddStates(13, 14);
 483                   else if (curChar == 47)
 484                      jjAddStates(15, 16);
 485                   else if (curChar == 46)
 486                      jjCheckNAdd(23);
 487                   else if (curChar == 34)
 488                      jjstateSet[jjnewStateCnt++] = 18;
 489                   else if (curChar == 39)
 490                      jjCheckNAddStates(17, 19);
 491                   if (curChar == 36)
 492                   {
 493                      if (kind > 38)
 494                         kind = 38;
 495                      jjCheckNAdd(21);
 496                   }
 497                   else if (curChar == 34)
 498                      jjCheckNAddStates(20, 22);
 499                   break;
 500                case 1:
 501                   if (curChar == 34)
 502                      jjCheckNAddStates(20, 22);
 503                   break;
 504                case 2:
 505                   if ((0xfffffffbfffffbffL & l) != 0L)
 506                      jjCheckNAddStates(20, 22);
 507                   break;
 508                case 4:
 509                   if ((0xfffffffffffffbffL & l) != 0L)
 510                      jjCheckNAddStates(20, 22);
 511                   break;
 512                case 5:
 513                   if (curChar == 34 && kind > 32)
 514                      kind = 32;
 515                   break;
 516                case 6:
 517                   if (curChar == 39)
 518                      jjCheckNAddStates(17, 19);
 519                   break;
 520                case 7:
 521                   if ((0xffffff7ffffffbffL & l) != 0L)
 522                      jjCheckNAddStates(17, 19);
 523                   break;
 524                case 9:
 525                   if ((0xfffffffffffffbffL & l) != 0L)
 526                      jjCheckNAddStates(17, 19);
 527                   break;
 528                case 10:
 529                   if (curChar == 39 && kind > 33)
 530                      kind = 33;
 531                   break;
 532                case 11:
 533                   if (curChar == 34)
 534                      jjCheckNAddStates(23, 25);
 535                   break;
 536                case 12:
 537                   if ((0xfffffffbffffffffL & l) != 0L)
 538                      jjCheckNAddStates(23, 25);
 539                   break;
 540                case 13:
 541                case 15:
 542                   if (curChar == 34)
 543                      jjCheckNAdd(12);
 544                   break;
 545                case 14:
 546                   if (curChar == 34)
 547                      jjAddStates(26, 27);
 548                   break;
 549                case 16:
 550                   if (curChar == 34 && kind > 34)
 551                      kind = 34;
 552                   break;
 553                case 17:
 554                   if (curChar == 34)
 555                      jjstateSet[jjnewStateCnt++] = 16;
 556                   break;
 557                case 18:
 558                   if (curChar == 34)
 559                      jjstateSet[jjnewStateCnt++] = 11;
 560                   break;
 561                case 19:
 562                   if (curChar == 34)
 563                      jjstateSet[jjnewStateCnt++] = 18;
 564                   break;
 565                case 20:
 566                   if (curChar != 36)
 567                      break;
 568                   if (kind > 38)
 569                      kind = 38;
 570                   jjCheckNAdd(21);
 571                   break;
 572                case 21:
 573                   if ((0x3ff001000000000L & l) == 0L)
 574                      break;
 575                   if (kind > 38)
 576                      kind = 38;
 577                   jjCheckNAdd(21);
 578                   break;
 579                case 22:
 580                   if (curChar == 46)
 581                      jjCheckNAdd(23);
 582                   break;
 583                case 23:
 584                   if ((0x3ff000000000000L & l) == 0L)
 585                      break;
 586                   if (kind > 40)
 587                      kind = 40;
 588                   jjCheckNAddTwoStates(23, 24);
 589                   break;
 590                case 25:
 591                   if ((0x3ff000000000000L & l) == 0L)
 592                      break;
 593                   if (kind > 40)
 594                      kind = 40;
 595                   jjstateSet[jjnewStateCnt++] = 25;
 596                   break;
 597                case 26:
 598                   if (curChar == 47)
 599                      jjAddStates(15, 16);
 600                   break;
 601                case 28:
 602                   if ((0xfffffbffffffffffL & l) != 0L)
 603                      jjCheckNAddStates(5, 7);
 604                   break;
 605                case 29:
 606                   if (curChar == 42)
 607                      jjstateSet[jjnewStateCnt++] = 30;
 608                   break;
 609                case 30:
 610                   if ((0xffff7fffffffffffL & l) != 0L)
 611                      jjCheckNAddStates(5, 7);
 612                   break;
 613                case 31:
 614                   if (curChar == 47 && kind > 2)
 615                      kind = 2;
 616                   break;
 617                case 32:
 618                   if (curChar == 42)
 619                      jjstateSet[jjnewStateCnt++] = 31;
 620                   break;
 621                case 33:
 622                   if (curChar != 47)
 623                      break;
 624                   if (kind > 3)
 625                      kind = 3;
 626                   jjCheckNAdd(34);
 627                   break;
 628                case 34:
 629                   if ((0xfffffffffffffbffL & l) == 0L)
 630                      break;
 631                   if (kind > 3)
 632                      kind = 3;
 633                   jjCheckNAdd(34);
 634                   break;
 635                case 35:
 636                   if (curChar == 36)
 637                      jjAddStates(13, 14);
 638                   break;
 639                case 37:
 640                   if (curChar == 36)
 641                      jjstateSet[jjnewStateCnt++] = 38;
 642                   break;
 643                case 38:
 644                   if ((0x3ff000000000000L & l) == 0L)
 645                      break;
 646                   if (kind > 35)
 647                      kind = 35;
 648                   jjstateSet[jjnewStateCnt++] = 39;
 649                   break;
 650                case 39:
 651                   if ((0x3ff000000000000L & l) == 0L)
 652                      break;
 653                   if (kind > 35)
 654                      kind = 35;
 655                   jjCheckNAddStates(28, 30);
 656                   break;
 657                case 40:
 658                   if ((0x3ff000000000000L & l) != 0L && kind > 35)
 659                      kind = 35;
 660                   break;
 661                case 41:
 662                   if ((0x3ff000000000000L & l) == 0L)
 663                      break;
 664                   if (kind > 35)
 665                      kind = 35;
 666                   jjCheckNAdd(40);
 667                   break;
 668                case 42:
 669                   if ((0x3ff000000000000L & l) == 0L)
 670                      break;
 671                   if (kind > 35)
 672                      kind = 35;
 673                   jjCheckNAddTwoStates(40, 41);
 674                   break;
 675                case 48:
 676                   if (curChar == 36)
 677                      jjCheckNAddTwoStates(49, 62);
 678                   break;
 679                case 49:
 680                   if (curChar == 58)
 681                      jjCheckNAddTwoStates(50, 51);
 682                   break;
 683                case 50:
 684                   if (curChar == 36)
 685                      jjCheckNAdd(51);
 686                   break;
 687                case 52:
 688                   if (curChar != 36)
 689                      break;
 690                   if (kind > 37)
 691                      kind = 37;
 692                   jjstateSet[jjnewStateCnt++] = 53;
 693                   break;
 694                case 53:
 695                   if ((0x3ff000000000000L & l) == 0L)
 696                      break;
 697                   if (kind > 37)
 698                      kind = 37;
 699                   jjCheckNAddStates(31, 34);
 700                   break;
 701                case 54:
 702                   if ((0x3ff000000000000L & l) != 0L && kind > 37)
 703                      kind = 37;
 704                   break;
 705                case 55:
 706                   if ((0x3ff000000000000L & l) == 0L)
 707                      break;
 708                   if (kind > 37)
 709                      kind = 37;
 710                   jjCheckNAdd(54);
 711                   break;
 712                case 56:
 713                   if ((0x3ff000000000000L & l) == 0L)
 714                      break;
 715                   if (kind > 37)
 716                      kind = 37;
 717                   jjCheckNAddTwoStates(54, 55);
 718                   break;
 719                case 57:
 720                   if ((0x3ff000000000000L & l) == 0L)
 721                      break;
 722                   if (kind > 37)
 723                      kind = 37;
 724                   jjCheckNAddStates(35, 37);
 725                   break;
 726                case 62:
 727                   if ((0x3ff000000000000L & l) != 0L)
 728                      jjCheckNAddStates(0, 4);
 729                   break;
 730                case 63:
 731                   if ((0x3ff000000000000L & l) != 0L)
 732                      jjCheckNAdd(49);
 733                   break;
 734                case 64:
 735                   if ((0x3ff000000000000L & l) != 0L)
 736                      jjCheckNAddTwoStates(63, 49);
 737                   break;
 738                case 65:
 739                   if ((0x3ff000000000000L & l) != 0L)
 740                      jjCheckNAddStates(38, 40);
 741                   break;
 742                case 66:
 743                   if ((0x3ff000000000000L & l) != 0L)
 744                      jjCheckNAddStates(41, 44);
 745                   break;
 746                case 72:
 747                   if ((0x3ff000000000000L & l) == 0L)
 748                      break;
 749                   if (kind > 41)
 750                      kind = 41;
 751                   jjCheckNAddStates(8, 12);
 752                   break;
 753                case 73:
 754                   if ((0x3ff000000000000L & l) != 0L)
 755                      jjCheckNAddTwoStates(73, 74);
 756                   break;
 757                case 74:
 758                   if (curChar == 46)
 759                      jjCheckNAdd(75);
 760                   break;
 761                case 75:
 762                   if ((0x3ff000000000000L & l) == 0L)
 763                      break;
 764                   if (kind > 40)
 765                      kind = 40;
 766                   jjCheckNAddTwoStates(75, 76);
 767                   break;
 768                case 77:
 769                   if ((0x3ff000000000000L & l) == 0L)
 770                      break;
 771                   if (kind > 40)
 772                      kind = 40;
 773                   jjstateSet[jjnewStateCnt++] = 77;
 774                   break;
 775                case 78:
 776                   if ((0x3ff000000000000L & l) != 0L)
 777                      jjCheckNAddTwoStates(78, 79);
 778                   break;
 779                case 80:
 780                   if ((0x3ff000000000000L & l) == 0L)
 781                      break;
 782                   if (kind > 40)
 783                      kind = 40;
 784                   jjstateSet[jjnewStateCnt++] = 80;
 785                   break;
 786                case 81:
 787                   if ((0x3ff000000000000L & l) == 0L)
 788                      break;
 789                   if (kind > 41)
 790                      kind = 41;
 791                   jjCheckNAdd(81);
 792                   break;
 793                default : break;
 794             }
 795          } while(i != startsAt);
 796       }
 797       else if (curChar < 128)
 798       {
 799          long l = 1L << (curChar & 077);
 800          do
 801          {
 802             switch(jjstateSet[--i])
 803             {
 804                case 84:
 805                   if ((0x7fffffe87fffffeL & l) != 0L)
 806                   {
 807                      if (kind > 38)
 808                         kind = 38;
 809                      jjCheckNAdd(21);
 810                   }
 811                   if ((0x7fffffeL & l) != 0L)
 812                      jjCheckNAddStates(45, 47);
 813                   if ((0x7fffffeL & l) != 0L)
 814                      jjCheckNAddTwoStates(37, 38);
 815                   break;
 816                case 70:
 817                   if ((0x7fffffe87fffffeL & l) != 0L)
 818                   {
 819                      if (kind > 38)
 820                         kind = 38;
 821                      jjCheckNAdd(21);
 822                   }
 823                   if ((0x7fffffeL & l) != 0L)
 824                      jjCheckNAddStates(48, 51);
 825                   if ((0x7fffffeL & l) != 0L)
 826                      jjCheckNAddStates(52, 54);
 827                   if ((0x7fffffeL & l) != 0L)
 828                      jjCheckNAddStates(55, 59);
 829                   if ((0x7fffffeL & l) != 0L)
 830                      jjCheckNAddStates(60, 63);
 831                   if ((0x7fffffeL & l) != 0L)
 832                      jjCheckNAddStates(45, 47);
 833                   if ((0x7fffffeL & l) != 0L)
 834                      jjCheckNAddTwoStates(37, 38);
 835                   break;
 836                case 85:
 837                case 21:
 838                   if ((0x7fffffe87fffffeL & l) == 0L)
 839                      break;
 840                   if (kind > 38)
 841                      kind = 38;
 842                   jjCheckNAdd(21);
 843                   break;
 844                case 83:
 845                   if ((0x7fffffe87fffffeL & l) != 0L)
 846                   {
 847                      if (kind > 38)
 848                         kind = 38;
 849                      jjCheckNAdd(21);
 850                   }
 851                   if ((0x7fffffeL & l) != 0L)
 852                      jjCheckNAddStates(52, 54);
 853                   if ((0x7fffffeL & l) != 0L)
 854                      jjCheckNAddStates(60, 63);
 855                   if ((0x7fffffeL & l) != 0L)
 856                      jjCheckNAddStates(45, 47);
 857                   if ((0x7fffffeL & l) != 0L)
 858                      jjCheckNAddTwoStates(37, 38);
 859                   break;
 860                case 82:
 861                   if ((0x7fffffe87fffffeL & l) != 0L)
 862                   {
 863                      if (kind > 38)
 864                         kind = 38;
 865                      jjCheckNAdd(21);
 866                   }
 867                   if ((0x7fffffeL & l) != 0L)
 868                      jjCheckNAddStates(64, 68);
 869                   if ((0x7fffffeL & l) != 0L)
 870                      jjCheckNAddStates(69, 74);
 871                   break;
 872                case 0:
 873                   if ((0x7fffffe87fffffeL & l) != 0L)
 874                   {
 875                      if (kind > 38)
 876                         kind = 38;
 877                      jjCheckNAdd(21);
 878                   }
 879                   if ((0x7fffffeL & l) != 0L)
 880                      jjCheckNAddStates(75, 81);
 881                   break;
 882                case 2:
 883                   if ((0xffffffffefffffffL & l) != 0L)
 884                      jjCheckNAddStates(20, 22);
 885                   break;
 886                case 3:
 887                   if (curChar == 92)
 888                      jjstateSet[jjnewStateCnt++] = 4;
 889                   break;
 890                case 4:
 891                   jjCheckNAddStates(20, 22);
 892                   break;
 893                case 7:
 894                   if ((0xffffffffefffffffL & l) != 0L)
 895                      jjCheckNAddStates(17, 19);
 896                   break;
 897                case 8:
 898                   if (curChar == 92)
 899                      jjstateSet[jjnewStateCnt++] = 9;
 900                   break;
 901                case 9:
 902                   jjCheckNAddStates(17, 19);
 903                   break;
 904                case 12:
 905                   jjAddStates(23, 25);
 906                   break;
 907                case 20:
 908                   if ((0x7fffffe87fffffeL & l) == 0L)
 909                      break;
 910                   if (kind > 38)
 911                      kind = 38;
 912                   jjCheckNAdd(21);
 913                   break;
 914                case 24:
 915                   if ((0x2000000020L & l) != 0L)
 916                      jjstateSet[jjnewStateCnt++] = 25;
 917                   break;
 918                case 28:
 919                case 30:
 920                   jjCheckNAddStates(5, 7);
 921                   break;
 922                case 34:
 923                   if (kind > 3)
 924                      kind = 3;
 925                   jjstateSet[jjnewStateCnt++] = 34;
 926                   break;
 927                case 36:
 928                   if ((0x7fffffeL & l) != 0L)
 929                      jjCheckNAddStates(82, 84);
 930                   break;
 931                case 43:
 932                   if ((0x7fffffeL & l) != 0L)
 933                      jjCheckNAddStates(64, 68);
 934                   break;
 935                case 44:
 936                   if ((0x7fffffeL & l) != 0L)
 937                      jjCheckNAddTwoStates(37, 38);
 938                   break;
 939                case 45:
 940                   if ((0x7fffffeL & l) != 0L)
 941                      jjCheckNAddStates(52, 54);
 942                   break;
 943                case 46:
 944                   if ((0x7fffffeL & l) != 0L)
 945                      jjCheckNAddStates(48, 51);
 946                   break;
 947                case 47:
 948                   if ((0x7fffffeL & l) != 0L)
 949                      jjCheckNAddStates(85, 88);
 950                   break;
 951                case 51:
 952                   if ((0x7fffffeL & l) == 0L)
 953                      break;
 954                   if (kind > 37)
 955                      kind = 37;
 956                   jjCheckNAddStates(89, 91);
 957                   break;
 958                case 58:
 959                   if ((0x7fffffeL & l) == 0L)
 960                      break;
 961                   if (kind > 37)
 962                      kind = 37;
 963                   jjCheckNAddStates(92, 96);
 964                   break;
 965                case 59:
 966                   if ((0x7fffffeL & l) == 0L)
 967                      break;
 968                   if (kind > 37)
 969                      kind = 37;
 970                   jjCheckNAddTwoStates(52, 53);
 971                   break;
 972                case 60:
 973                   if ((0x7fffffeL & l) == 0L)
 974                      break;
 975                   if (kind > 37)
 976                      kind = 37;
 977                   jjCheckNAddStates(97, 99);
 978                   break;
 979                case 61:
 980                   if ((0x7fffffeL & l) == 0L)
 981                      break;
 982                   if (kind > 37)
 983                      kind = 37;
 984                   jjCheckNAddStates(100, 103);
 985                   break;
 986                case 67:
 987                   if ((0x7fffffeL & l) != 0L)
 988                      jjCheckNAddStates(69, 74);
 989                   break;
 990                case 68:
 991                   if ((0x7fffffeL & l) != 0L)
 992                      jjCheckNAddStates(45, 47);
 993                   break;
 994                case 69:
 995                   if ((0x7fffffeL & l) != 0L)
 996                      jjCheckNAddStates(60, 63);
 997                   break;
 998                case 71:
 999                   if ((0x7fffffeL & l) != 0L)
1000                      jjCheckNAddStates(75, 81);
1001                   break;
1002                case 76:
1003                   if ((0x2000000020L & l) != 0L)
1004                      jjstateSet[jjnewStateCnt++] = 77;
1005                   break;
1006                case 79:
1007                   if ((0x2000000020L & l) != 0L)
1008                      jjstateSet[jjnewStateCnt++] = 80;
1009                   break;
1010                default : break;
1011             }
1012          } while(i != startsAt);
1013       }
1014       else
1015       {
1016          int hiByte = (int)(curChar >> 8);
1017          int i1 = hiByte >> 6;
1018          long l1 = 1L << (hiByte & 077);
1019          int i2 = (curChar & 0xff) >> 6;
1020          long l2 = 1L << (curChar & 077);
1021          do
1022          {
1023             switch(jjstateSet[--i])
1024             {
1025                case 84:
1026                case 21:
1027                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1028                      break;
1029                   if (kind > 38)
1030                      kind = 38;
1031                   jjCheckNAdd(21);
1032                   break;
1033                case 70:
1034                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1035                      break;
1036                   if (kind > 38)
1037                      kind = 38;
1038                   jjCheckNAdd(21);
1039                   break;
1040                case 85:
1041                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1042                      break;
1043                   if (kind > 38)
1044                      kind = 38;
1045                   jjCheckNAdd(21);
1046                   break;
1047                case 83:
1048                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1049                      break;
1050                   if (kind > 38)
1051                      kind = 38;
1052                   jjCheckNAdd(21);
1053                   break;
1054                case 82:
1055                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1056                      break;
1057                   if (kind > 38)
1058                      kind = 38;
1059                   jjCheckNAdd(21);
1060                   break;
1061                case 0:
1062                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1063                      break;
1064                   if (kind > 38)
1065                      kind = 38;
1066                   jjCheckNAdd(21);
1067                   break;
1068                case 2:
1069                case 4:
1070                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1071                      jjCheckNAddStates(20, 22);
1072                   break;
1073                case 7:
1074                case 9:
1075                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1076                      jjCheckNAddStates(17, 19);
1077                   break;
1078                case 12:
1079                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1080                      jjAddStates(23, 25);
1081                   break;
1082                case 28:
1083                case 30:
1084                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1085                      jjCheckNAddStates(5, 7);
1086                   break;
1087                case 34:
1088                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1089                      break;
1090                   if (kind > 3)
1091                      kind = 3;
1092                   jjstateSet[jjnewStateCnt++] = 34;
1093                   break;
1094                default : break;
1095             }
1096          } while(i != startsAt);
1097       }
1098       if (kind != 0x7fffffff)
1099       {
1100          jjmatchedKind = kind;
1101          jjmatchedPos = curPos;
1102          kind = 0x7fffffff;
1103       }
1104       ++curPos;
1105       if ((i = jjnewStateCnt) == (startsAt = 82 - (jjnewStateCnt = startsAt)))
1106          return curPos;
1107       try { curChar = input_stream.readChar(); }
1108       catch(java.io.IOException e) { return curPos; }
1109    }
1110 }
1111 static final int[] jjnextStates = {
1112    63, 49, 64, 65, 66, 28, 29, 32, 73, 74, 78, 79, 81, 36, 47, 27,
1113    33, 7, 8, 10, 2, 3, 5, 12, 13, 14, 15, 17, 40, 41, 42, 54,
1114    55, 56, 57, 54, 55, 56, 63, 49, 64, 63, 49, 64, 65, 48, 49, 62,
1115    44, 37, 38, 45, 44, 37, 38, 68, 48, 49, 62, 69, 68, 48, 49, 62,
1116    44, 37, 38, 45, 46, 68, 48, 49, 62, 69, 70, 37, 38, 48, 49, 62,
1117    67, 43, 37, 38, 43, 48, 49, 62, 67, 52, 53, 58, 59, 52, 53, 60,
1118    61, 59, 52, 53, 59, 52, 53, 60,
1119 };
1120 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1121 {
1122    switch(hiByte)
1123    {
1124       case 0:
1125          return ((jjbitVec2[i2] & l2) != 0L);
1126       default :
1127          if ((jjbitVec0[i1] & l1) != 0L)
1128             return true;
1129          return false;
1130    }
1131 }
1132 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1133 {
1134    switch(hiByte)
1135    {
1136       case 0:
1137          return ((jjbitVec4[i2] & l2) != 0L);
1138       case 48:
1139          return ((jjbitVec5[i2] & l2) != 0L);
1140       case 49:
1141          return ((jjbitVec6[i2] & l2) != 0L);
1142       case 51:
1143          return ((jjbitVec7[i2] & l2) != 0L);
1144       case 61:
1145          return ((jjbitVec8[i2] & l2) != 0L);
1146       case 251:
1147          return ((jjbitVec9[i2] & l2) != 0L);
1148       case 253:
1149          return ((jjbitVec10[i2] & l2) != 0L);
1150       case 254:
1151          return ((jjbitVec11[i2] & l2) != 0L);
1152       case 255:
1153          return ((jjbitVec12[i2] & l2) != 0L);
1154       default :
1155          if ((jjbitVec3[i1] & l1) != 0L)
1156             return true;
1157          return false;
1158    }
1159 }
1160
1161 /** Token literal values. */
1162 public static final String[] jjstrLiteralImages = {
1163 "", null, null, null, "\73", "\50", "\51", "\77", "\133", "\135", "\173",
1164 "\175", "\174", "\46", "\53", "\52", "\57", "\136", "\54", "\56\56", "\56", "\75",
1165 "\74", "\76", "\74\76", "\164\162\165\145", "\146\141\154\163\145",
1166 "\156\165\154\154", "\124\122\125\105", "\106\101\114\123\105", null, null, null, null, null, null,
1167 null, null, null, null, null, null, "\41", "\43\122\105\106\41", "\74\75", "\76\75",
1168 "\55", };
1169
1170 /** Lexer state names. */
1171 public static final String[] lexStateNames = {
1172    "DEFAULT",
1173 };
1174 static final long[] jjtoToken = {
1175    0x7f6f3ffffff1L,
1176 };
1177 static final long[] jjtoSkip = {
1178    0xeL,
1179 };
1180 protected SimpleCharStream input_stream;
1181 private final int[] jjrounds = new int[82];
1182 private final int[] jjstateSet = new int[164];
1183 private final StringBuilder jjimage = new StringBuilder();
1184 private StringBuilder image = jjimage;
1185 private int jjimageLen;
1186 private int lengthOfMatch;
1187 protected char curChar;
1188 /** Constructor. */
1189 public SheetFormulaParserTokenManager(SimpleCharStream stream){
1190    if (SimpleCharStream.staticFlag)
1191       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1192    input_stream = stream;
1193 }
1194
1195 /** Constructor. */
1196 public SheetFormulaParserTokenManager(SimpleCharStream stream, int lexState){
1197    this(stream);
1198    SwitchTo(lexState);
1199 }
1200
1201 /** Reinitialise parser. */
1202 public void ReInit(SimpleCharStream stream)
1203 {
1204    jjmatchedPos = jjnewStateCnt = 0;
1205    curLexState = defaultLexState;
1206    input_stream = stream;
1207    ReInitRounds();
1208 }
1209 private void ReInitRounds()
1210 {
1211    int i;
1212    jjround = 0x80000001;
1213    for (i = 82; i-- > 0;)
1214       jjrounds[i] = 0x80000000;
1215 }
1216
1217 /** Reinitialise parser. */
1218 public void ReInit(SimpleCharStream stream, int lexState)
1219 {
1220    ReInit(stream);
1221    SwitchTo(lexState);
1222 }
1223
1224 /** Switch to specified lex state. */
1225 public void SwitchTo(int lexState)
1226 {
1227    if (lexState >= 1 || lexState < 0)
1228       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1229    else
1230       curLexState = lexState;
1231 }
1232
1233 protected Token jjFillToken()
1234 {
1235    final Token t;
1236    final String curTokenImage;
1237    final int beginLine;
1238    final int endLine;
1239    final int beginColumn;
1240    final int endColumn;
1241    String im = jjstrLiteralImages[jjmatchedKind];
1242    curTokenImage = (im == null) ? input_stream.GetImage() : im;
1243    beginLine = input_stream.getBeginLine();
1244    beginColumn = input_stream.getBeginColumn();
1245    endLine = input_stream.getEndLine();
1246    endColumn = input_stream.getEndColumn();
1247    t = Token.newToken(jjmatchedKind, curTokenImage);
1248
1249    t.beginLine = beginLine;
1250    t.endLine = endLine;
1251    t.beginColumn = beginColumn;
1252    t.endColumn = endColumn;
1253
1254    return t;
1255 }
1256
1257 int curLexState = 0;
1258 int defaultLexState = 0;
1259 int jjnewStateCnt;
1260 int jjround;
1261 int jjmatchedPos;
1262 int jjmatchedKind;
1263
1264 /** Get the next Token. */
1265 public Token getNextToken()
1266 {
1267   Token matchedToken;
1268   int curPos = 0;
1269
1270   EOFLoop :
1271   for (;;)
1272   {
1273    try
1274    {
1275       curChar = input_stream.BeginToken();
1276    }
1277    catch(java.io.IOException e)
1278    {
1279       jjmatchedKind = 0;
1280       matchedToken = jjFillToken();
1281       return matchedToken;
1282    }
1283    image = jjimage;
1284    image.setLength(0);
1285    jjimageLen = 0;
1286
1287    jjmatchedKind = 0x7fffffff;
1288    jjmatchedPos = 0;
1289    curPos = jjMoveStringLiteralDfa0_0();
1290    if (jjmatchedKind != 0x7fffffff)
1291    {
1292       if (jjmatchedPos + 1 < curPos)
1293          input_stream.backup(curPos - jjmatchedPos - 1);
1294       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1295       {
1296          matchedToken = jjFillToken();
1297          TokenLexicalActions(matchedToken);
1298          return matchedToken;
1299       }
1300       else
1301       {
1302          continue EOFLoop;
1303       }
1304    }
1305    int error_line = input_stream.getEndLine();
1306    int error_column = input_stream.getEndColumn();
1307    String error_after = null;
1308    boolean EOFSeen = false;
1309    try { input_stream.readChar(); input_stream.backup(1); }
1310    catch (java.io.IOException e1) {
1311       EOFSeen = true;
1312       error_after = curPos <= 1 ? "" : input_stream.GetImage();
1313       if (curChar == '\n' || curChar == '\r') {
1314          error_line++;
1315          error_column = 0;
1316       }
1317       else
1318          error_column++;
1319    }
1320    if (!EOFSeen) {
1321       input_stream.backup(1);
1322       error_after = curPos <= 1 ? "" : input_stream.GetImage();
1323    }
1324    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1325   }
1326 }
1327
1328 void TokenLexicalActions(Token matchedToken)
1329 {
1330    switch(jjmatchedKind)
1331    {
1332       case 32 :
1333         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
1334       matchedToken.image = SheetParserUtils.unescape(
1335         matchedToken.image.substring(1,matchedToken.image.length()-1));
1336          break;
1337       case 33 :
1338         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
1339       matchedToken.image = SheetParserUtils.unescape(
1340         matchedToken.image.substring(1,matchedToken.image.length()-1));
1341          break;
1342       case 34 :
1343         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
1344       matchedToken.image = matchedToken.image.substring(3,matchedToken.image.length()-3);
1345          break;
1346       default :
1347          break;
1348    }
1349 }
1350 private void jjCheckNAdd(int state)
1351 {
1352    if (jjrounds[state] != jjround)
1353    {
1354       jjstateSet[jjnewStateCnt++] = state;
1355       jjrounds[state] = jjround;
1356    }
1357 }
1358 private void jjAddStates(int start, int end)
1359 {
1360    do {
1361       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1362    } while (start++ != end);
1363 }
1364 private void jjCheckNAddTwoStates(int state1, int state2)
1365 {
1366    jjCheckNAdd(state1);
1367    jjCheckNAdd(state2);
1368 }
1369
1370 private void jjCheckNAddStates(int start, int end)
1371 {
1372    do {
1373       jjCheckNAdd(jjnextStates[start]);
1374    } while (start++ != end);
1375 }
1376
1377 }