1. /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */

  2. package org.apache.commons.jexl.parser;

  3. 

  4. public class ParserTokenManager implements ParserConstants

  5. {

  6.   public  java.io.PrintStream debugStream = System.out;

  7.   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }

  8. private final int jjStopStringLiteralDfa_0(int pos, long active0)

  9. {

  10.    switch (pos)

  11.    {

  12.       case 0:

  13.          if ((active0 & 0x3ef285550a4800L) != 0L)

  14.          {

  15.             jjmatchedKind = 58;

  16.             return 5;

  17.          }

  18.          return -1;

  19.       case 1:

  20.          if ((active0 & 0x1cf28000084800L) != 0L)

  21.          {

  22.             jjmatchedKind = 58;

  23.             jjmatchedPos = 1;

  24.             return 5;

  25.          }

  26.          if ((active0 & 0x22000555020000L) != 0L)

  27.             return 5;

  28.          return -1;

  29.       case 2:

  30.          if ((active0 & 0x1ce00000004800L) != 0L)

  31.          {

  32.             jjmatchedKind = 58;

  33.             jjmatchedPos = 2;

  34.             return 5;

  35.          }

  36.          if ((active0 & 0x128000080000L) != 0L)

  37.             return 5;

  38.          return -1;

  39.       case 3:

  40.          if ((active0 & 0x18800000000800L) != 0L)

  41.          {

  42.             jjmatchedKind = 58;

  43.             jjmatchedPos = 3;

  44.             return 5;

  45.          }

  46.          if ((active0 & 0x4600000004000L) != 0L)

  47.             return 5;

  48.          return -1;

  49.       case 4:

  50.          if ((active0 & 0x10000000000000L) != 0L)

  51.          {

  52.             jjmatchedKind = 58;

  53.             jjmatchedPos = 4;

  54.             return 5;

  55.          }

  56.          if ((active0 & 0x8800000000800L) != 0L)

  57.             return 5;

  58.          return -1;

  59.       case 5:

  60.          if ((active0 & 0x10000000000000L) != 0L)

  61.          {

  62.             jjmatchedKind = 58;

  63.             jjmatchedPos = 5;

  64.             return 5;

  65.          }

  66.          return -1;

  67.       default :

  68.          return -1;

  69.    }

  70. }

  71. private final int jjStartNfa_0(int pos, long active0)

  72. {

  73.    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);

  74. }

  75. private final int jjStopAtPos(int pos, int kind)

  76. {

  77.    jjmatchedKind = kind;

  78.    jjmatchedPos = pos;

  79.    return pos + 1;

  80. }

  81. private final int jjStartNfaWithStates_0(int pos, int kind, int state)

  82. {

  83.    jjmatchedKind = kind;

  84.    jjmatchedPos = pos;

  85.    try { curChar = input_stream.readChar(); }

  86.    catch(java.io.IOException e) { return pos + 1; }

  87.    return jjMoveNfa_0(state, pos + 1);

  88. }

  89. private final int jjMoveStringLiteralDfa0_0()

  90. {

  91.    switch(curChar)

  92.    {

  93.       case 33:

  94.          jjmatchedKind = 43;

  95.          return jjMoveStringLiteralDfa1_0(0x2000000L);

  96.       case 37:

  97.          return jjStopAtPos(0, 40);

  98.       case 38:

  99.          jjmatchedKind = 22;

  100.          return jjMoveStringLiteralDfa1_0(0x40000L);

  101.       case 40:

  102.          return jjStopAtPos(0, 12);

  103.       case 41:

  104.          return jjStopAtPos(0, 13);

  105.       case 42:

  106.          return jjStopAtPos(0, 37);

  107.       case 43:

  108.          return jjStopAtPos(0, 35);

  109.       case 44:

  110.          return jjStopAtPos(0, 54);

  111.       case 45:

  112.          return jjStopAtPos(0, 36);

  113.       case 46:

  114.          return jjStopAtPos(0, 57);

  115.       case 47:

  116.          return jjStopAtPos(0, 38);

  117.       case 59:

  118.          return jjStopAtPos(0, 48);

  119.       case 60:

  120.          jjmatchedKind = 27;

  121.          return jjMoveStringLiteralDfa1_0(0x80000000L);

  122.       case 61:

  123.          jjmatchedKind = 15;

  124.          return jjMoveStringLiteralDfa1_0(0x800000L);

  125.       case 62:

  126.          jjmatchedKind = 29;

  127.          return jjMoveStringLiteralDfa1_0(0x200000000L);

  128.       case 91:

  129.          return jjStopAtPos(0, 55);

  130.       case 93:

  131.          return jjStopAtPos(0, 56);

  132.       case 94:

  133.          return jjStopAtPos(0, 21);

  134.       case 97:

  135.          return jjMoveStringLiteralDfa1_0(0x80000L);

  136.       case 100:

  137.          return jjMoveStringLiteralDfa1_0(0x8000000000L);

  138.       case 101:

  139.          return jjMoveStringLiteralDfa1_0(0x4000001000800L);

  140.       case 102:

  141.          return jjMoveStringLiteralDfa1_0(0x10800000000000L);

  142.       case 103:

  143.          return jjMoveStringLiteralDfa1_0(0x440000000L);

  144.       case 105:

  145.          return jjMoveStringLiteralDfa1_0(0x22000000000000L);

  146.       case 108:

  147.          return jjMoveStringLiteralDfa1_0(0x110000000L);

  148.       case 109:

  149.          return jjMoveStringLiteralDfa1_0(0x20000000000L);

  150.       case 110:

  151.          return jjMoveStringLiteralDfa1_0(0x300004000000L);

  152.       case 111:

  153.          return jjMoveStringLiteralDfa1_0(0x20000L);

  154.       case 115:

  155.          return jjMoveStringLiteralDfa1_0(0x4000L);

  156.       case 116:

  157.          return jjMoveStringLiteralDfa1_0(0x400000000000L);

  158.       case 119:

  159.          return jjMoveStringLiteralDfa1_0(0x8000000000000L);

  160.       case 123:

  161.          return jjStopAtPos(0, 9);

  162.       case 124:

  163.          jjmatchedKind = 20;

  164.          return jjMoveStringLiteralDfa1_0(0x10000L);

  165.       case 125:

  166.          return jjStopAtPos(0, 10);

  167.       case 126:

  168.          return jjStopAtPos(0, 42);

  169.       default :

  170.          return jjMoveNfa_0(3, 0);

  171.    }

  172. }

  173. private final int jjMoveStringLiteralDfa1_0(long active0)

  174. {

  175.    try { curChar = input_stream.readChar(); }

  176.    catch(java.io.IOException e) {

  177.       jjStopStringLiteralDfa_0(0, active0);

  178.       return 1;

  179.    }

  180.    switch(curChar)

  181.    {

  182.       case 38:

  183.          if ((active0 & 0x40000L) != 0L)

  184.             return jjStopAtPos(1, 18);

  185.          break;

  186.       case 61:

  187.          if ((active0 & 0x800000L) != 0L)

  188.             return jjStopAtPos(1, 23);

  189.          else if ((active0 & 0x2000000L) != 0L)

  190.             return jjStopAtPos(1, 25);

  191.          else if ((active0 & 0x80000000L) != 0L)

  192.             return jjStopAtPos(1, 31);

  193.          else if ((active0 & 0x200000000L) != 0L)

  194.             return jjStopAtPos(1, 33);

  195.          break;

  196.       case 97:

  197.          return jjMoveStringLiteralDfa2_0(active0, 0x800000000000L);

  198.       case 101:

  199.          if ((active0 & 0x4000000L) != 0L)

  200.             return jjStartNfaWithStates_0(1, 26, 5);

  201.          else if ((active0 & 0x100000000L) != 0L)

  202.             return jjStartNfaWithStates_0(1, 32, 5);

  203.          else if ((active0 & 0x400000000L) != 0L)

  204.             return jjStartNfaWithStates_0(1, 34, 5);

  205.          break;

  206.       case 102:

  207.          if ((active0 & 0x2000000000000L) != 0L)

  208.             return jjStartNfaWithStates_0(1, 49, 5);

  209.          break;

  210.       case 104:

  211.          return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L);

  212.       case 105:

  213.          return jjMoveStringLiteralDfa2_0(active0, 0x8000004000L);

  214.       case 108:

  215.          return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L);

  216.       case 109:

  217.          return jjMoveStringLiteralDfa2_0(active0, 0x800L);

  218.       case 110:

  219.          if ((active0 & 0x20000000000000L) != 0L)

  220.             return jjStartNfaWithStates_0(1, 53, 5);

  221.          return jjMoveStringLiteralDfa2_0(active0, 0x80000L);

  222.       case 111:

  223.          return jjMoveStringLiteralDfa2_0(active0, 0x10120000000000L);

  224.       case 113:

  225.          if ((active0 & 0x1000000L) != 0L)

  226.             return jjStartNfaWithStates_0(1, 24, 5);

  227.          break;

  228.       case 114:

  229.          if ((active0 & 0x20000L) != 0L)

  230.             return jjStartNfaWithStates_0(1, 17, 5);

  231.          return jjMoveStringLiteralDfa2_0(active0, 0x400000000000L);

  232.       case 116:

  233.          if ((active0 & 0x10000000L) != 0L)

  234.             return jjStartNfaWithStates_0(1, 28, 5);

  235.          else if ((active0 & 0x40000000L) != 0L)

  236.             return jjStartNfaWithStates_0(1, 30, 5);

  237.          break;

  238.       case 117:

  239.          return jjMoveStringLiteralDfa2_0(active0, 0x200000000000L);

  240.       case 124:

  241.          if ((active0 & 0x10000L) != 0L)

  242.             return jjStopAtPos(1, 16);

  243.          break;

  244.       default :

  245.          break;

  246.    }

  247.    return jjStartNfa_0(0, active0);

  248. }

  249. private final int jjMoveStringLiteralDfa2_0(long old0, long active0)

  250. {

  251.    if (((active0 &= old0)) == 0L)

  252.       return jjStartNfa_0(0, old0); 

  253.    try { curChar = input_stream.readChar(); }

  254.    catch(java.io.IOException e) {

  255.       jjStopStringLiteralDfa_0(1, active0);

  256.       return 2;

  257.    }

  258.    switch(curChar)

  259.    {

  260.       case 100:

  261.          if ((active0 & 0x80000L) != 0L)

  262.             return jjStartNfaWithStates_0(2, 19, 5);

  263.          else if ((active0 & 0x20000000000L) != 0L)

  264.             return jjStartNfaWithStates_0(2, 41, 5);

  265.          break;

  266.       case 105:

  267.          return jjMoveStringLiteralDfa3_0(active0, 0x8000000000000L);

  268.       case 108:

  269.          return jjMoveStringLiteralDfa3_0(active0, 0xa00000000000L);

  270.       case 112:

  271.          return jjMoveStringLiteralDfa3_0(active0, 0x800L);

  272.       case 114:

  273.          return jjMoveStringLiteralDfa3_0(active0, 0x10000000000000L);

  274.       case 115:

  275.          return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L);

  276.       case 116:

  277.          if ((active0 & 0x100000000000L) != 0L)

  278.             return jjStartNfaWithStates_0(2, 44, 5);

  279.          break;

  280.       case 117:

  281.          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L);

  282.       case 118:

  283.          if ((active0 & 0x8000000000L) != 0L)

  284.             return jjStartNfaWithStates_0(2, 39, 5);

  285.          break;

  286.       case 122:

  287.          return jjMoveStringLiteralDfa3_0(active0, 0x4000L);

  288.       default :

  289.          break;

  290.    }

  291.    return jjStartNfa_0(1, active0);

  292. }

  293. private final int jjMoveStringLiteralDfa3_0(long old0, long active0)

  294. {

  295.    if (((active0 &= old0)) == 0L)

  296.       return jjStartNfa_0(1, old0); 

  297.    try { curChar = input_stream.readChar(); }

  298.    catch(java.io.IOException e) {

  299.       jjStopStringLiteralDfa_0(2, active0);

  300.       return 3;

  301.    }

  302.    switch(curChar)

  303.    {

  304.       case 101:

  305.          if ((active0 & 0x4000L) != 0L)

  306.             return jjStartNfaWithStates_0(3, 14, 5);

  307.          else if ((active0 & 0x400000000000L) != 0L)

  308.             return jjStartNfaWithStates_0(3, 46, 5);

  309.          else if ((active0 & 0x4000000000000L) != 0L)

  310.             return jjStartNfaWithStates_0(3, 50, 5);

  311.          return jjMoveStringLiteralDfa4_0(active0, 0x10000000000000L);

  312.       case 108:

  313.          if ((active0 & 0x200000000000L) != 0L)

  314.             return jjStartNfaWithStates_0(3, 45, 5);

  315.          return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L);

  316.       case 115:

  317.          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L);

  318.       case 116:

  319.          return jjMoveStringLiteralDfa4_0(active0, 0x800L);

  320.       default :

  321.          break;

  322.    }

  323.    return jjStartNfa_0(2, active0);

  324. }

  325. private final int jjMoveStringLiteralDfa4_0(long old0, long active0)

  326. {

  327.    if (((active0 &= old0)) == 0L)

  328.       return jjStartNfa_0(2, old0); 

  329.    try { curChar = input_stream.readChar(); }

  330.    catch(java.io.IOException e) {

  331.       jjStopStringLiteralDfa_0(3, active0);

  332.       return 4;

  333.    }

  334.    switch(curChar)

  335.    {

  336.       case 97:

  337.          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);

  338.       case 101:

  339.          if ((active0 & 0x800000000000L) != 0L)

  340.             return jjStartNfaWithStates_0(4, 47, 5);

  341.          else if ((active0 & 0x8000000000000L) != 0L)

  342.             return jjStartNfaWithStates_0(4, 51, 5);

  343.          break;

  344.       case 121:

  345.          if ((active0 & 0x800L) != 0L)

  346.             return jjStartNfaWithStates_0(4, 11, 5);

  347.          break;

  348.       default :

  349.          break;

  350.    }

  351.    return jjStartNfa_0(3, active0);

  352. }

  353. private final int jjMoveStringLiteralDfa5_0(long old0, long active0)

  354. {

  355.    if (((active0 &= old0)) == 0L)

  356.       return jjStartNfa_0(3, old0); 

  357.    try { curChar = input_stream.readChar(); }

  358.    catch(java.io.IOException e) {

  359.       jjStopStringLiteralDfa_0(4, active0);

  360.       return 5;

  361.    }

  362.    switch(curChar)

  363.    {

  364.       case 99:

  365.          return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);

  366.       default :

  367.          break;

  368.    }

  369.    return jjStartNfa_0(4, active0);

  370. }

  371. private final int jjMoveStringLiteralDfa6_0(long old0, long active0)

  372. {

  373.    if (((active0 &= old0)) == 0L)

  374.       return jjStartNfa_0(4, old0); 

  375.    try { curChar = input_stream.readChar(); }

  376.    catch(java.io.IOException e) {

  377.       jjStopStringLiteralDfa_0(5, active0);

  378.       return 6;

  379.    }

  380.    switch(curChar)

  381.    {

  382.       case 104:

  383.          if ((active0 & 0x10000000000000L) != 0L)

  384.             return jjStartNfaWithStates_0(6, 52, 5);

  385.          break;

  386.       default :

  387.          break;

  388.    }

  389.    return jjStartNfa_0(5, active0);

  390. }

  391. private final void jjCheckNAdd(int state)

  392. {

  393.    if (jjrounds[state] != jjround)

  394.    {

  395.       jjstateSet[jjnewStateCnt++] = state;

  396.       jjrounds[state] = jjround;

  397.    }

  398. }

  399. private final void jjAddStates(int start, int end)

  400. {

  401.    do {

  402.       jjstateSet[jjnewStateCnt++] = jjnextStates[start];

  403.    } while (start++ != end);

  404. }

  405. private final void jjCheckNAddTwoStates(int state1, int state2)

  406. {

  407.    jjCheckNAdd(state1);

  408.    jjCheckNAdd(state2);

  409. }

  410. private final void jjCheckNAddStates(int start, int end)

  411. {

  412.    do {

  413.       jjCheckNAdd(jjnextStates[start]);

  414.    } while (start++ != end);

  415. }

  416. private final void jjCheckNAddStates(int start)

  417. {

  418.    jjCheckNAdd(jjnextStates[start]);

  419.    jjCheckNAdd(jjnextStates[start + 1]);

  420. }

  421. static final long[] jjbitVec0 = {

  422.    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL

  423. };

  424. private final int jjMoveNfa_0(int startState, int curPos)

  425. {

  426.    int[] nextStates;

  427.    int startsAt = 0;

  428.    jjnewStateCnt = 17;

  429.    int i = 1;

  430.    jjstateSet[0] = startState;

  431.    int j, kind = 0x7fffffff;

  432.    for (;;)

  433.    {

  434.       if (++jjround == 0x7fffffff)

  435.          ReInitRounds();

  436.       if (curChar < 64)

  437.       {

  438.          long l = 1L << curChar;

  439.          MatchLoop: do

  440.          {

  441.             switch(jjstateSet[--i])

  442.             {

  443.                case 3:

  444.                   if ((0x3ff000000000000L & l) != 0L)

  445.                   {

  446.                      if (kind > 7)

  447.                         kind = 7;

  448.                      jjCheckNAddStates(0, 2);

  449.                   }

  450.                   else if (curChar == 39)

  451.                      jjCheckNAddTwoStates(10, 11);

  452.                   else if (curChar == 34)

  453.                      jjCheckNAddTwoStates(7, 8);

  454.                   else if (curChar == 36)

  455.                   {

  456.                      if (kind > 58)

  457.                         kind = 58;

  458.                      jjCheckNAdd(5);

  459.                   }

  460.                   else if (curChar == 35)

  461.                      jjstateSet[jjnewStateCnt++] = 0;

  462.                   break;

  463.                case 0:

  464.                   if (curChar == 35)

  465.                      jjCheckNAddTwoStates(1, 2);

  466.                   break;

  467.                case 1:

  468.                   if ((0xfffffffbffffdbffL & l) != 0L)

  469.                      jjCheckNAddTwoStates(1, 2);

  470.                   break;

  471.                case 2:

  472.                   if ((0x2400L & l) != 0L)

  473.                      kind = 1;

  474.                   break;

  475.                case 4:

  476.                   if (curChar != 36)

  477.                      break;

  478.                   if (kind > 58)

  479.                      kind = 58;

  480.                   jjCheckNAdd(5);

  481.                   break;

  482.                case 5:

  483.                   if ((0x3ff001000000000L & l) == 0L)

  484.                      break;

  485.                   if (kind > 58)

  486.                      kind = 58;

  487.                   jjCheckNAdd(5);

  488.                   break;

  489.                case 6:

  490.                   if (curChar == 34)

  491.                      jjCheckNAddTwoStates(7, 8);

  492.                   break;

  493.                case 7:

  494.                   if ((0xfffffffbffffdbffL & l) != 0L)

  495.                      jjCheckNAddTwoStates(7, 8);

  496.                   break;

  497.                case 8:

  498.                   if (curChar == 34 && kind > 61)

  499.                      kind = 61;

  500.                   break;

  501.                case 9:

  502.                   if (curChar == 39)

  503.                      jjCheckNAddTwoStates(10, 11);

  504.                   break;

  505.                case 10:

  506.                   if ((0xffffff7fffffdbffL & l) != 0L)

  507.                      jjCheckNAddTwoStates(10, 11);

  508.                   break;

  509.                case 11:

  510.                   if (curChar == 39 && kind > 61)

  511.                      kind = 61;

  512.                   break;

  513.                case 12:

  514.                   if ((0x3ff000000000000L & l) == 0L)

  515.                      break;

  516.                   if (kind > 7)

  517.                      kind = 7;

  518.                   jjCheckNAddStates(0, 2);

  519.                   break;

  520.                case 13:

  521.                   if ((0x3ff000000000000L & l) == 0L)

  522.                      break;

  523.                   if (kind > 7)

  524.                      kind = 7;

  525.                   jjCheckNAdd(13);

  526.                   break;

  527.                case 14:

  528.                   if ((0x3ff000000000000L & l) != 0L)

  529.                      jjCheckNAddTwoStates(14, 15);

  530.                   break;

  531.                case 15:

  532.                   if (curChar == 46)

  533.                      jjCheckNAdd(16);

  534.                   break;

  535.                case 16:

  536.                   if ((0x3ff000000000000L & l) == 0L)

  537.                      break;

  538.                   if (kind > 8)

  539.                      kind = 8;

  540.                   jjCheckNAdd(16);

  541.                   break;

  542.                default : break;

  543.             }

  544.          } while(i != startsAt);

  545.       }

  546.       else if (curChar < 128)

  547.       {

  548.          long l = 1L << (curChar & 077);

  549.          MatchLoop: do

  550.          {

  551.             switch(jjstateSet[--i])

  552.             {

  553.                case 3:

  554.                case 5:

  555.                   if ((0x7fffffe87fffffeL & l) == 0L)

  556.                      break;

  557.                   if (kind > 58)

  558.                      kind = 58;

  559.                   jjCheckNAdd(5);

  560.                   break;

  561.                case 1:

  562.                   jjAddStates(3, 4);

  563.                   break;

  564.                case 7:

  565.                   jjAddStates(5, 6);

  566.                   break;

  567.                case 10:

  568.                   jjAddStates(7, 8);

  569.                   break;

  570.                default : break;

  571.             }

  572.          } while(i != startsAt);

  573.       }

  574.       else

  575.       {

  576.          int i2 = (curChar & 0xff) >> 6;

  577.          long l2 = 1L << (curChar & 077);

  578.          MatchLoop: do

  579.          {

  580.             switch(jjstateSet[--i])

  581.             {

  582.                case 1:

  583.                   if ((jjbitVec0[i2] & l2) != 0L)

  584.                      jjAddStates(3, 4);

  585.                   break;

  586.                case 7:

  587.                   if ((jjbitVec0[i2] & l2) != 0L)

  588.                      jjAddStates(5, 6);

  589.                   break;

  590.                case 10:

  591.                   if ((jjbitVec0[i2] & l2) != 0L)

  592.                      jjAddStates(7, 8);

  593.                   break;

  594.                default : break;

  595.             }

  596.          } while(i != startsAt);

  597.       }

  598.       if (kind != 0x7fffffff)

  599.       {

  600.          jjmatchedKind = kind;

  601.          jjmatchedPos = curPos;

  602.          kind = 0x7fffffff;

  603.       }

  604.       ++curPos;

  605.       if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt)))

  606.          return curPos;

  607.       try { curChar = input_stream.readChar(); }

  608.       catch(java.io.IOException e) { return curPos; }

  609.    }

  610. }

  611. static final int[] jjnextStates = {

  612.    13, 14, 15, 1, 2, 7, 8, 10, 11, 

  613. };

  614. public static final String[] jjstrLiteralImages = {

  615. "", null, null, null, null, null, null, null, null, "\173", "\175", 

  616. "\145\155\160\164\171", "\50", "\51", "\163\151\172\145", "\75", "\174\174", "\157\162", "\46\46", 

  617. "\141\156\144", "\174", "\136", "\46", "\75\75", "\145\161", "\41\75", "\156\145", "\74", 

  618. "\154\164", "\76", "\147\164", "\74\75", "\154\145", "\76\75", "\147\145", "\53", "\55", 

  619. "\52", "\57", "\144\151\166", "\45", "\155\157\144", "\176", "\41", "\156\157\164", 

  620. "\156\165\154\154", "\164\162\165\145", "\146\141\154\163\145", "\73", "\151\146", 

  621. "\145\154\163\145", "\167\150\151\154\145", "\146\157\162\145\141\143\150", "\151\156", "\54", 

  622. "\133", "\135", "\56", null, null, null, null, };

  623. public static final String[] lexStateNames = {

  624.    "DEFAULT", 

  625. };

  626. static final long[] jjtoToken = {

  627.    0x27ffffffffffff81L, 

  628. };

  629. static final long[] jjtoSkip = {

  630.    0x7eL, 

  631. };

  632. private SimpleCharStream input_stream;

  633. private final int[] jjrounds = new int[17];

  634. private final int[] jjstateSet = new int[34];

  635. protected char curChar;

  636. public ParserTokenManager(SimpleCharStream stream)

  637. {

  638.    if (SimpleCharStream.staticFlag)

  639.       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");

  640.    input_stream = stream;

  641. }

  642. public ParserTokenManager(SimpleCharStream stream, int lexState)

  643. {

  644.    this(stream);

  645.    SwitchTo(lexState);

  646. }

  647. public void ReInit(SimpleCharStream stream)

  648. {

  649.    jjmatchedPos = jjnewStateCnt = 0;

  650.    curLexState = defaultLexState;

  651.    input_stream = stream;

  652.    ReInitRounds();

  653. }

  654. private final void ReInitRounds()

  655. {

  656.    int i;

  657.    jjround = 0x80000001;

  658.    for (i = 17; i-- > 0;)

  659.       jjrounds[i] = 0x80000000;

  660. }

  661. public void ReInit(SimpleCharStream stream, int lexState)

  662. {

  663.    ReInit(stream);

  664.    SwitchTo(lexState);

  665. }

  666. public void SwitchTo(int lexState)

  667. {

  668.    if (lexState >= 1 || lexState < 0)

  669.       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);

  670.    else

  671.       curLexState = lexState;

  672. }

  673. 

  674. private final Token jjFillToken()

  675. {

  676.    Token t = Token.newToken(jjmatchedKind);

  677.    t.kind = jjmatchedKind;

  678.    String im = jjstrLiteralImages[jjmatchedKind];

  679.    t.image = (im == null) ? input_stream.GetImage() : im;

  680.    t.beginLine = input_stream.getBeginLine();

  681.    t.beginColumn = input_stream.getBeginColumn();

  682.    t.endLine = input_stream.getEndLine();

  683.    t.endColumn = input_stream.getEndColumn();

  684.    return t;

  685. }

  686. 

  687. int curLexState = 0;

  688. int defaultLexState = 0;

  689. int jjnewStateCnt;

  690. int jjround;

  691. int jjmatchedPos;

  692. int jjmatchedKind;

  693. 

  694. public final Token getNextToken() 

  695. {

  696.   int kind;

  697.   Token specialToken = null;

  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.    try { input_stream.backup(0);

  716.       while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)

  717.          curChar = input_stream.BeginToken();

  718.    }

  719.    catch (java.io.IOException e1) { continue EOFLoop; }

  720.    jjmatchedKind = 0x7fffffff;

  721.    jjmatchedPos = 0;

  722.    curPos = jjMoveStringLiteralDfa0_0();

  723.    if (jjmatchedKind != 0x7fffffff)

  724.    {

  725.       if (jjmatchedPos + 1 < curPos)

  726.          input_stream.backup(curPos - jjmatchedPos - 1);

  727.       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

  728.       {

  729.          matchedToken = jjFillToken();

  730.          return matchedToken;

  731.       }

  732.       else

  733.       {

  734.          continue EOFLoop;

  735.       }

  736.    }

  737.    int error_line = input_stream.getEndLine();

  738.    int error_column = input_stream.getEndColumn();

  739.    String error_after = null;

  740.    boolean EOFSeen = false;

  741.    try { input_stream.readChar(); input_stream.backup(1); }

  742.    catch (java.io.IOException e1) {

  743.       EOFSeen = true;

  744.       error_after = curPos <= 1 ? "" : input_stream.GetImage();

  745.       if (curChar == '\n' || curChar == '\r') {

  746.          error_line++;

  747.          error_column = 0;

  748.       }

  749.       else

  750.          error_column++;

  751.    }

  752.    if (!EOFSeen) {

  753.       input_stream.backup(1);

  754.       error_after = curPos <= 1 ? "" : input_stream.GetImage();

  755.    }

  756.    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);

  757.   }

  758. }

  759. 

  760. }