QueryParserTokenManager.java

  1. /* Generated By:JavaCC: Do not edit this line. QueryParserTokenManager.java */
  2. package gate.mimir.search.query.parser;
  3. import gate.Annotation;
  4. import gate.Corpus;
  5. import gate.Document;
  6. import gate.Factory;
  7. import gate.Gate;
  8. import gate.LanguageAnalyser;
  9. import gate.creole.ANNIEConstants;
  10. import gate.creole.ExecutionException;
  11. import gate.creole.ResourceInstantiationException;
  12. import gate.util.OffsetComparator;
  13. import gate.mimir.search.query.QueryNode;
  14. import gate.mimir.search.query.SequenceQuery.Gap;
  15. import gate.mimir.ConstraintType;
  16. import gate.mimir.Constraint;
  17. import java.io.StringReader;
  18. import java.util.ArrayList;
  19. import java.util.Collections;
  20. import java.util.List;

  22. public class QueryParserTokenManager implements QueryParserConstants
  23. {
  24.   public  java.io.PrintStream debugStream = System.out;
  25.   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  26. private final int jjStopStringLiteralDfa_0(int pos, long active0)
  27. {
  28.    switch (pos)
  29.    {
  30.       case 0:
  31.          if ((active0 & 0x40L) != 0L)
  32.             return 15;
  33.          if ((active0 & 0x10000000000L) != 0L)
  34.          {
  35.             jjmatchedKind = 44;
  36.             return 2;
  37.          }
  38.          if ((active0 & 0x84800000000L) != 0L)
  39.          {
  40.             jjmatchedKind = 44;
  41.             return 46;
  42.          }
  43.          return -1;
  44.       case 1:
  45.          if ((active0 & 0x4000000000L) != 0L)
  46.             return 46;
  47.          if ((active0 & 0x90800000000L) != 0L)
  48.          {
  49.             jjmatchedKind = 44;
  50.             jjmatchedPos = 1;
  51.             return 46;
  52.          }
  53.          return -1;
  54.       case 2:
  55.          if ((active0 & 0x90800000000L) != 0L)
  56.          {
  57.             jjmatchedKind = 44;
  58.             jjmatchedPos = 2;
  59.             return 46;
  60.          }
  61.          return -1;
  62.       case 3:
  63.          if ((active0 & 0x10000000000L) != 0L)
  64.             return 46;
  65.          if ((active0 & 0x80800000000L) != 0L)
  66.          {
  67.             jjmatchedKind = 44;
  68.             jjmatchedPos = 3;
  69.             return 46;
  70.          }
  71.          return -1;
  72.       default :
  73.          return -1;
  74.    }
  75. }
  76. private final int jjStartNfa_0(int pos, long active0)
  77. {
  78.    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
  79. }
  80. private final int jjStopAtPos(int pos, int kind)
  81. {
  82.    jjmatchedKind = kind;
  83.    jjmatchedPos = pos;
  84.    return pos + 1;
  85. }
  86. private final int jjStartNfaWithStates_0(int pos, int kind, int state)
  87. {
  88.    jjmatchedKind = kind;
  89.    jjmatchedPos = pos;
  90.    try { curChar = input_stream.readChar(); }
  91.    catch(java.io.IOException e) { return pos + 1; }
  92.    return jjMoveNfa_0(state, pos + 1);
  93. }
  94. private final int jjMoveStringLiteralDfa0_0()
  95. {
  96.    switch(curChar)
  97.    {
  98.       case 13:
  99.          jjmatchedKind = 2;
  100.          return jjMoveStringLiteralDfa1_0(0x8L);
  101.       case 34:
  102.          return jjStartNfaWithStates_0(0, 6, 15);
  103.       case 40:
  104.          return jjStopAtPos(0, 27);
  105.       case 41:
  106.          return jjStopAtPos(0, 28);
  107.       case 43:
  108.          return jjStopAtPos(0, 36);
  109.       case 44:
  110.          return jjStopAtPos(0, 32);
  111.       case 45:
  112.          return jjStopAtPos(0, 39);
  113.       case 46:
  114.          return jjStopAtPos(0, 29);
  115.       case 58:
  116.          return jjStopAtPos(0, 31);
  117.       case 60:
  118.          jjmatchedKind = 23;
  119.          return jjMoveStringLiteralDfa1_0(0x200000L);
  120.       case 61:
  121.          return jjStopAtPos(0, 30);
  122.       case 62:
  123.          jjmatchedKind = 24;
  124.          return jjMoveStringLiteralDfa1_0(0x400000L);
  125.       case 63:
  126.          return jjStopAtPos(0, 37);
  127.       case 73:
  128.          return jjMoveStringLiteralDfa1_0(0x4000000000L);
  129.       case 77:
  130.          return jjMoveStringLiteralDfa1_0(0x800000000L);
  131.       case 79:
  132.          return jjMoveStringLiteralDfa1_0(0x10000000000L);
  133.       case 82:
  134.          return jjMoveStringLiteralDfa1_0(0x80000000000L);
  135.       case 91:
  136.          return jjStopAtPos(0, 41);
  137.       case 93:
  138.          return jjStopAtPos(0, 42);
  139.       case 123:
  140.          return jjStopAtPos(0, 25);
  141.       case 125:
  142.          return jjStopAtPos(0, 26);
  143.       default :
  144.          return jjMoveNfa_0(1, 0);
  145.    }
  146. }
  147. private final int jjMoveStringLiteralDfa1_0(long active0)
  148. {
  149.    try { curChar = input_stream.readChar(); }
  150.    catch(java.io.IOException e) {
  151.       jjStopStringLiteralDfa_0(0, active0);
  152.       return 1;
  153.    }
  154.    switch(curChar)
  155.    {
  156.       case 10:
  157.          if ((active0 & 0x8L) != 0L)
  158.             return jjStopAtPos(1, 3);
  159.          break;
  160.       case 61:
  161.          if ((active0 & 0x200000L) != 0L)
  162.             return jjStopAtPos(1, 21);
  163.          else if ((active0 & 0x400000L) != 0L)
  164.             return jjStopAtPos(1, 22);
  165.          break;
  166.       case 69:
  167.          return jjMoveStringLiteralDfa2_0(active0, 0x80000000000L);
  168.       case 73:
  169.          return jjMoveStringLiteralDfa2_0(active0, 0x800000000L);
  170.       case 78:
  171.          if ((active0 & 0x4000000000L) != 0L)
  172.             return jjStartNfaWithStates_0(1, 38, 46);
  173.          break;
  174.       case 86:
  175.          return jjMoveStringLiteralDfa2_0(active0, 0x10000000000L);
  176.       default :
  177.          break;
  178.    }
  179.    return jjStartNfa_0(0, active0);
  180. }
  181. private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
  182. {
  183.    if (((active0 &= old0)) == 0L)
  184.       return jjStartNfa_0(0, old0); 
  185.    try { curChar = input_stream.readChar(); }
  186.    catch(java.io.IOException e) {
  187.       jjStopStringLiteralDfa_0(1, active0);
  188.       return 2;
  189.    }
  190.    switch(curChar)
  191.    {
  192.       case 69:
  193.          return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L);
  194.       case 71:
  195.          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L);
  196.       case 78:
  197.          return jjMoveStringLiteralDfa3_0(active0, 0x800000000L);
  198.       default :
  199.          break;
  200.    }
  201.    return jjStartNfa_0(1, active0);
  202. }
  203. private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
  204. {
  205.    if (((active0 &= old0)) == 0L)
  206.       return jjStartNfa_0(1, old0); 
  207.    try { curChar = input_stream.readChar(); }
  208.    catch(java.io.IOException e) {
  209.       jjStopStringLiteralDfa_0(2, active0);
  210.       return 3;
  211.    }
  212.    switch(curChar)
  213.    {
  214.       case 69:
  215.          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L);
  216.       case 82:
  217.          if ((active0 & 0x10000000000L) != 0L)
  218.             return jjStartNfaWithStates_0(3, 40, 46);
  219.          break;
  220.       case 85:
  221.          return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
  222.       default :
  223.          break;
  224.    }
  225.    return jjStartNfa_0(2, active0);
  226. }
  227. private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
  228. {
  229.    if (((active0 &= old0)) == 0L)
  230.       return jjStartNfa_0(2, old0); 
  231.    try { curChar = input_stream.readChar(); }
  232.    catch(java.io.IOException e) {
  233.       jjStopStringLiteralDfa_0(3, active0);
  234.       return 4;
  235.    }
  236.    switch(curChar)
  237.    {
  238.       case 83:
  239.          if ((active0 & 0x800000000L) != 0L)
  240.             return jjStartNfaWithStates_0(4, 35, 46);
  241.          break;
  242.       case 88:
  243.          if ((active0 & 0x80000000000L) != 0L)
  244.             return jjStartNfaWithStates_0(4, 43, 46);
  245.          break;
  246.       default :
  247.          break;
  248.    }
  249.    return jjStartNfa_0(3, active0);
  250. }
  251. private final void jjCheckNAdd(int state)
  252. {
  253.    if (jjrounds[state] != jjround)
  254.    {
  255.       jjstateSet[jjnewStateCnt++] = state;
  256.       jjrounds[state] = jjround;
  257.    }
  258. }
  259. private final void jjAddStates(int start, int end)
  260. {
  261.    do {
  262.       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
  263.    } while (start++ != end);
  264. }
  265. private final void jjCheckNAddTwoStates(int state1, int state2)
  266. {
  267.    jjCheckNAdd(state1);
  268.    jjCheckNAdd(state2);
  269. }
  270. private final void jjCheckNAddStates(int start, int end)
  271. {
  272.    do {
  273.       jjCheckNAdd(jjnextStates[start]);
  274.    } while (start++ != end);
  275. }
  276. private final void jjCheckNAddStates(int start)
  277. {
  278.    jjCheckNAdd(jjnextStates[start]);
  279.    jjCheckNAdd(jjnextStates[start + 1]);
  280. }
  281. static final long[] jjbitVec0 = {
  282.    0x0L, 0x0L, 0x100c00000000L, 0x0L
  283. };
  284. static final long[] jjbitVec1 = {
  285.    0x0L, 0x0L, 0x100000000000L, 0x0L
  286. };
  287. static final long[] jjbitVec2 = {
  288.    0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
  289. };
  290. static final long[] jjbitVec4 = {
  291.    0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
  292. };
  293. static final long[] jjbitVec5 = {
  294.    0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
  295. };
  296. static final long[] jjbitVec6 = {
  297.    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
  298. };
  299. static final long[] jjbitVec7 = {
  300.    0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
  301. };
  302. static final long[] jjbitVec8 = {
  303.    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
  304. };
  305. private final int jjMoveNfa_0(int startState, int curPos)
  306. {
  307.    int[] nextStates;
  308.    int startsAt = 0;
  309.    jjnewStateCnt = 47;
  310.    int i = 1;
  311.    jjstateSet[0] = startState;
  312.    int j, kind = 0x7fffffff;
  313.    for (;;)
  314.    {
  315.       if (++jjround == 0x7fffffff)
  316.          ReInitRounds();
  317.       if (curChar < 64)
  318.       {
  319.          long l = 1L << curChar;
  320.          MatchLoop: do
  321.          {
  322.             switch(jjstateSet[--i])
  323.             {
  324.                case 1:
  325.                   if ((0x3ff000000000000L & l) != 0L)
  326.                   {
  327.                      if (kind > 18)
  328.                         kind = 18;
  329.                      jjCheckNAdd(0);
  330.                   }
  331.                   else if ((0x4ba00000000L & l) != 0L)
  332.                   {
  333.                      if (kind > 44)
  334.                         kind = 44;
  335.                      jjCheckNAddStates(0, 2);
  336.                   }
  337.                   else if (curChar == 34)
  338.                      jjAddStates(3, 7);
  339.                   else if (curChar == 38)
  340.                   {
  341.                      if (kind > 34)
  342.                         kind = 34;
  343.                   }
  344.                   if (curChar == 36)
  345.                   {
  346.                      if (kind > 44)
  347.                         kind = 44;
  348.                      jjCheckNAdd(46);
  349.                   }
  350.                   break;
  351.                case 2:
  352.                case 46:
  353.                   if ((0x3ff001000000000L & l) == 0L)
  354.                      break;
  355.                   if (kind > 44)
  356.                      kind = 44;
  357.                   jjCheckNAdd(46);
  358.                   break;
  359.                case 0:
  360.                   if ((0x3ff000000000000L & l) == 0L)
  361.                      break;
  362.                   if (kind > 18)
  363.                      kind = 18;
  364.                   jjCheckNAdd(0);
  365.                   break;
  366.                case 4:
  367.                   if (curChar == 38 && kind > 34)
  368.                      kind = 34;
  369.                   break;
  370.                case 8:
  371.                   if ((0x4ba00000000L & l) == 0L)
  372.                      break;
  373.                   if (kind > 44)
  374.                      kind = 44;
  375.                   jjCheckNAddStates(0, 2);
  376.                   break;
  377.                case 11:
  378.                   if (curChar == 34)
  379.                      jjAddStates(3, 7);
  380.                   break;
  381.                case 12:
  382.                   if (curChar != 34)
  383.                      break;
  384.                   if (kind > 44)
  385.                      kind = 44;
  386.                   jjCheckNAddStates(0, 2);
  387.                   break;
  388.                case 30:
  389.                   if (curChar != 40)
  390.                      break;
  391.                   kind = 44;
  392.                   jjCheckNAddStates(0, 2);
  393.                   break;
  394.                case 31:
  395.                   if (curChar != 41)
  396.                      break;
  397.                   kind = 44;
  398.                   jjCheckNAddStates(0, 2);
  399.                   break;
  400.                case 32:
  401.                   if (curChar != 58)
  402.                      break;
  403.                   kind = 44;
  404.                   jjCheckNAddStates(0, 2);
  405.                   break;
  406.                case 33:
  407.                   if (curChar != 43)
  408.                      break;
  409.                   kind = 44;
  410.                   jjCheckNAddStates(0, 2);
  411.                   break;
  412.                case 34:
  413.                   if (curChar != 38)
  414.                      break;
  415.                   if (kind > 44)
  416.                      kind = 44;
  417.                   jjCheckNAddStates(0, 2);
  418.                   break;
  419.                case 36:
  420.                   if (curChar != 63)
  421.                      break;
  422.                   kind = 44;
  423.                   jjCheckNAddStates(0, 2);
  424.                   break;
  425.                case 38:
  426.                   if (curChar != 46)
  427.                      break;
  428.                   kind = 44;
  429.                   jjCheckNAddStates(0, 2);
  430.                   break;
  431.                case 39:
  432.                   if (curChar != 61)
  433.                      break;
  434.                   kind = 44;
  435.                   jjCheckNAddStates(0, 2);
  436.                   break;
  437.                case 42:
  438.                   if (curChar != 60)
  439.                      break;
  440.                   kind = 44;
  441.                   jjCheckNAddStates(0, 2);
  442.                   break;
  443.                case 43:
  444.                   if (curChar != 62)
  445.                      break;
  446.                   kind = 44;
  447.                   jjCheckNAddStates(0, 2);
  448.                   break;
  449.                case 44:
  450.                   if (curChar != 44)
  451.                      break;
  452.                   kind = 44;
  453.                   jjCheckNAddStates(0, 2);
  454.                   break;
  455.                case 45:
  456.                   if (curChar != 36)
  457.                      break;
  458.                   if (kind > 44)
  459.                      kind = 44;
  460.                   jjCheckNAdd(46);
  461.                   break;
  462.                default : break;
  463.             }
  464.          } while(i != startsAt);
  465.       }
  466.       else if (curChar < 128)
  467.       {
  468.          long l = 1L << (curChar & 077);
  469.          MatchLoop: do
  470.          {
  471.             switch(jjstateSet[--i])
  472.             {
  473.                case 1:
  474.                   if ((0x7fffffe87fffffeL & l) != 0L)
  475.                   {
  476.                      if (kind > 44)
  477.                         kind = 44;
  478.                      jjCheckNAdd(46);
  479.                   }
  480.                   else if (curChar == 92)
  481.                      jjCheckNAddStates(8, 25);
  482.                   else if (curChar == 124)
  483.                   {
  484.                      if (kind > 33)
  485.                         kind = 33;
  486.                   }
  487.                   if ((0x40000001c0000001L & l) != 0L)
  488.                   {
  489.                      if (kind > 44)
  490.                         kind = 44;
  491.                      jjCheckNAddStates(0, 2);
  492.                   }
  493.                   else if (curChar == 65)
  494.                      jjstateSet[jjnewStateCnt++] = 6;
  495.                   else if (curChar == 79)
  496.                      jjstateSet[jjnewStateCnt++] = 2;
  497.                   break;
  498.                case 15:
  499.                   if (curChar == 82)
  500.                      jjstateSet[jjnewStateCnt++] = 27;
  501.                   else if (curChar == 79)
  502.                      jjstateSet[jjnewStateCnt++] = 22;
  503.                   else if (curChar == 73)
  504.                      jjstateSet[jjnewStateCnt++] = 18;
  505.                   else if (curChar == 65)
  506.                      jjstateSet[jjnewStateCnt++] = 14;
  507.                   if (curChar == 79)
  508.                      jjstateSet[jjnewStateCnt++] = 16;
  509.                   break;
  510.                case 2:
  511.                   if ((0x7fffffe87fffffeL & l) != 0L)
  512.                   {
  513.                      if (kind > 44)
  514.                         kind = 44;
  515.                      jjCheckNAdd(46);
  516.                   }
  517.                   if (curChar == 82)
  518.                   {
  519.                      if (kind > 33)
  520.                         kind = 33;
  521.                   }
  522.                   break;
  523.                case 3:
  524.                   if (curChar == 79)
  525.                      jjstateSet[jjnewStateCnt++] = 2;
  526.                   break;
  527.                case 5:
  528.                   if (curChar == 68 && kind > 34)
  529.                      kind = 34;
  530.                   break;
  531.                case 6:
  532.                   if (curChar == 78)
  533.                      jjstateSet[jjnewStateCnt++] = 5;
  534.                   break;
  535.                case 7:
  536.                   if (curChar == 65)
  537.                      jjstateSet[jjnewStateCnt++] = 6;
  538.                   break;
  539.                case 8:
  540.                   if ((0x40000001c0000001L & l) == 0L)
  541.                      break;
  542.                   if (kind > 44)
  543.                      kind = 44;
  544.                   jjCheckNAddStates(0, 2);
  545.                   break;
  546.                case 9:
  547.                   if (curChar == 92)
  548.                      jjCheckNAddStates(8, 25);
  549.                   break;
  550.                case 10:
  551.                   if (curChar != 91)
  552.                      break;
  553.                   kind = 44;
  554.                   jjCheckNAddStates(0, 2);
  555.                   break;
  556.                case 13:
  557.                   if (curChar == 68)
  558.                      jjCheckNAdd(12);
  559.                   break;
  560.                case 14:
  561.                   if (curChar == 78)
  562.                      jjstateSet[jjnewStateCnt++] = 13;
  563.                   break;
  564.                case 16:
  565.                case 20:
  566.                   if (curChar == 82)
  567.                      jjCheckNAdd(12);
  568.                   break;
  569.                case 17:
  570.                   if (curChar == 79)
  571.                      jjstateSet[jjnewStateCnt++] = 16;
  572.                   break;
  573.                case 18:
  574.                   if (curChar == 78)
  575.                      jjCheckNAdd(12);
  576.                   break;
  577.                case 19:
  578.                   if (curChar == 73)
  579.                      jjstateSet[jjnewStateCnt++] = 18;
  580.                   break;
  581.                case 21:
  582.                   if (curChar == 69)
  583.                      jjstateSet[jjnewStateCnt++] = 20;
  584.                   break;
  585.                case 22:
  586.                   if (curChar == 86)
  587.                      jjstateSet[jjnewStateCnt++] = 21;
  588.                   break;
  589.                case 23:
  590.                   if (curChar == 79)
  591.                      jjstateSet[jjnewStateCnt++] = 22;
  592.                   break;
  593.                case 24:
  594.                   if (curChar == 88)
  595.                      jjCheckNAdd(12);
  596.                   break;
  597.                case 25:
  598.                   if (curChar == 69)
  599.                      jjstateSet[jjnewStateCnt++] = 24;
  600.                   break;
  601.                case 26:
  602.                   if (curChar == 71)
  603.                      jjstateSet[jjnewStateCnt++] = 25;
  604.                   break;
  605.                case 27:
  606.                   if (curChar == 69)
  607.                      jjstateSet[jjnewStateCnt++] = 26;
  608.                   break;
  609.                case 28:
  610.                   if (curChar == 82)
  611.                      jjstateSet[jjnewStateCnt++] = 27;
  612.                   break;
  613.                case 29:
  614.                   if (curChar != 93)
  615.                      break;
  616.                   kind = 44;
  617.                   jjCheckNAddStates(0, 2);
  618.                   break;
  619.                case 35:
  620.                   if (curChar != 124)
  621.                      break;
  622.                   if (kind > 44)
  623.                      kind = 44;
  624.                   jjCheckNAddStates(0, 2);
  625.                   break;
  626.                case 37:
  627.                   if (curChar != 92)
  628.                      break;
  629.                   if (kind > 44)
  630.                      kind = 44;
  631.                   jjCheckNAddStates(0, 2);
  632.                   break;
  633.                case 40:
  634.                   if (curChar != 123)
  635.                      break;
  636.                   kind = 44;
  637.                   jjCheckNAddStates(0, 2);
  638.                   break;
  639.                case 41:
  640.                   if (curChar != 125)
  641.                      break;
  642.                   kind = 44;
  643.                   jjCheckNAddStates(0, 2);
  644.                   break;
  645.                case 45:
  646.                   if ((0x7fffffe87fffffeL & l) == 0L)
  647.                      break;
  648.                   if (kind > 44)
  649.                      kind = 44;
  650.                   jjCheckNAdd(46);
  651.                   break;
  652.                case 46:
  653.                   if ((0x7fffffe87fffffeL & l) == 0L)
  654.                      break;
  655.                   if (kind > 44)
  656.                      kind = 44;
  657.                   jjCheckNAdd(46);
  658.                   break;
  659.                default : break;
  660.             }
  661.          } while(i != startsAt);
  662.       }
  663.       else
  664.       {
  665.          int hiByte = (int)(curChar >> 8);
  666.          int i1 = hiByte >> 6;
  667.          long l1 = 1L << (hiByte & 077);
  668.          int i2 = (curChar & 0xff) >> 6;
  669.          long l2 = 1L << (curChar & 077);
  670.          MatchLoop: do
  671.          {
  672.             switch(jjstateSet[--i])
  673.             {
  674.                case 1:
  675.                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
  676.                   {
  677.                      if (kind > 44)
  678.                         kind = 44;
  679.                      jjCheckNAddStates(0, 2);
  680.                   }
  681.                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
  682.                   {
  683.                      if (kind > 44)
  684.                         kind = 44;
  685.                      jjCheckNAdd(46);
  686.                   }
  687.                   break;
  688.                case 2:
  689.                case 46:
  690.                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
  691.                      break;
  692.                   if (kind > 44)
  693.                      kind = 44;
  694.                   jjCheckNAdd(46);
  695.                   break;
  696.                case 8:
  697.                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
  698.                      break;
  699.                   if (kind > 44)
  700.                      kind = 44;
  701.                   jjCheckNAddStates(0, 2);
  702.                   break;
  703.                case 45:
  704.                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
  705.                      break;
  706.                   if (kind > 44)
  707.                      kind = 44;
  708.                   jjCheckNAdd(46);
  709.                   break;
  710.                default : break;
  711.             }
  712.          } while(i != startsAt);
  713.       }
  714.       if (kind != 0x7fffffff)
  715.       {
  716.          jjmatchedKind = kind;
  717.          jjmatchedPos = curPos;
  718.          kind = 0x7fffffff;
  719.       }
  720.       ++curPos;
  721.       if ((i = jjnewStateCnt) == (startsAt = 47 - (jjnewStateCnt = startsAt)))
  722.          return curPos;
  723.       try { curChar = input_stream.readChar(); }
  724.       catch(java.io.IOException e) { return curPos; }
  725.    }
  726. }
  727. private final int jjStopStringLiteralDfa_1(int pos, long active0)
  728. {
  729.    switch (pos)
  730.    {
  731.       case 0:
  732.          if ((active0 & 0x7f80L) != 0L)
  733.             return 0;
  734.          return -1;
  735.       default :
  736.          return -1;
  737.    }
  738. }
  739. private final int jjStartNfa_1(int pos, long active0)
  740. {
  741.    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
  742. }
  743. private final int jjStartNfaWithStates_1(int pos, int kind, int state)
  744. {
  745.    jjmatchedKind = kind;
  746.    jjmatchedPos = pos;
  747.    try { curChar = input_stream.readChar(); }
  748.    catch(java.io.IOException e) { return pos + 1; }
  749.    return jjMoveNfa_1(state, pos + 1);
  750. }
  751. private final int jjMoveStringLiteralDfa0_1()
  752. {
  753.    switch(curChar)
  754.    {
  755.       case 34:
  756.          return jjStopAtPos(0, 17);
  757.       case 92:
  758.          return jjMoveStringLiteralDfa1_1(0x7f80L);
  759.       default :
  760.          return jjMoveNfa_1(5, 0);
  761.    }
  762. }
  763. private final int jjMoveStringLiteralDfa1_1(long active0)
  764. {
  765.    try { curChar = input_stream.readChar(); }
  766.    catch(java.io.IOException e) {
  767.       jjStopStringLiteralDfa_1(0, active0);
  768.       return 1;
  769.    }
  770.    switch(curChar)
  771.    {
  772.       case 34:
  773.          if ((active0 & 0x1000L) != 0L)
  774.             return jjStopAtPos(1, 12);
  775.          break;
  776.       case 39:
  777.          if ((active0 & 0x2000L) != 0L)
  778.             return jjStopAtPos(1, 13);
  779.          break;
  780.       case 92:
  781.          if ((active0 & 0x4000L) != 0L)
  782.             return jjStopAtPos(1, 14);
  783.          break;
  784.       case 98:
  785.          if ((active0 & 0x400L) != 0L)
  786.             return jjStopAtPos(1, 10);
  787.          break;
  788.       case 102:
  789.          if ((active0 & 0x800L) != 0L)
  790.             return jjStopAtPos(1, 11);
  791.          break;
  792.       case 110:
  793.          if ((active0 & 0x80L) != 0L)
  794.             return jjStopAtPos(1, 7);
  795.          break;
  796.       case 114:
  797.          if ((active0 & 0x100L) != 0L)
  798.             return jjStopAtPos(1, 8);
  799.          break;
  800.       case 116:
  801.          if ((active0 & 0x200L) != 0L)
  802.             return jjStopAtPos(1, 9);
  803.          break;
  804.       default :
  805.          break;
  806.    }
  807.    return jjStartNfa_1(0, active0);
  808. }
  809. static final long[] jjbitVec9 = {
  810.    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
  811. };
  812. static final long[] jjbitVec10 = {
  813.    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
  814. };
  815. private final int jjMoveNfa_1(int startState, int curPos)
  816. {
  817.    int[] nextStates;
  818.    int startsAt = 0;
  819.    jjnewStateCnt = 7;
  820.    int i = 1;
  821.    jjstateSet[0] = startState;
  822.    int j, kind = 0x7fffffff;
  823.    for (;;)
  824.    {
  825.       if (++jjround == 0x7fffffff)
  826.          ReInitRounds();
  827.       if (curChar < 64)
  828.       {
  829.          long l = 1L << curChar;
  830.          MatchLoop: do
  831.          {
  832.             switch(jjstateSet[--i])
  833.             {
  834.                case 5:
  835.                   if ((0xfffffffbffffffffL & l) != 0L && kind > 16)
  836.                      kind = 16;
  837.                   break;
  838.                case 1:
  839.                   if ((0x3ff000000000000L & l) != 0L)
  840.                      jjstateSet[jjnewStateCnt++] = 2;
  841.                   break;
  842.                case 2:
  843.                   if ((0x3ff000000000000L & l) != 0L)
  844.                      jjstateSet[jjnewStateCnt++] = 3;
  845.                   break;
  846.                case 3:
  847.                   if ((0x3ff000000000000L & l) != 0L)
  848.                      jjstateSet[jjnewStateCnt++] = 4;
  849.                   break;
  850.                case 4:
  851.                   if ((0x3ff000000000000L & l) != 0L && kind > 15)
  852.                      kind = 15;
  853.                   break;
  854.                default : break;
  855.             }
  856.          } while(i != startsAt);
  857.       }
  858.       else if (curChar < 128)
  859.       {
  860.          long l = 1L << (curChar & 077);
  861.          MatchLoop: do
  862.          {
  863.             switch(jjstateSet[--i])
  864.             {
  865.                case 5:
  866.                   if ((0xffffffffefffffffL & l) != 0L)
  867.                   {
  868.                      if (kind > 16)
  869.                         kind = 16;
  870.                   }
  871.                   else if (curChar == 92)
  872.                      jjstateSet[jjnewStateCnt++] = 0;
  873.                   break;
  874.                case 0:
  875.                   if (curChar == 117)
  876.                      jjstateSet[jjnewStateCnt++] = 1;
  877.                   break;
  878.                case 1:
  879.                   if ((0x7e0000007eL & l) != 0L)
  880.                      jjstateSet[jjnewStateCnt++] = 2;
  881.                   break;
  882.                case 2:
  883.                   if ((0x7e0000007eL & l) != 0L)
  884.                      jjstateSet[jjnewStateCnt++] = 3;
  885.                   break;
  886.                case 3:
  887.                   if ((0x7e0000007eL & l) != 0L)
  888.                      jjstateSet[jjnewStateCnt++] = 4;
  889.                   break;
  890.                case 4:
  891.                   if ((0x7e0000007eL & l) != 0L && kind > 15)
  892.                      kind = 15;
  893.                   break;
  894.                case 6:
  895.                   if ((0xffffffffefffffffL & l) != 0L && kind > 16)
  896.                      kind = 16;
  897.                   break;
  898.                default : break;
  899.             }
  900.          } while(i != startsAt);
  901.       }
  902.       else
  903.       {
  904.          int hiByte = (int)(curChar >> 8);
  905.          int i1 = hiByte >> 6;
  906.          long l1 = 1L << (hiByte & 077);
  907.          int i2 = (curChar & 0xff) >> 6;
  908.          long l2 = 1L << (curChar & 077);
  909.          MatchLoop: do
  910.          {
  911.             switch(jjstateSet[--i])
  912.             {
  913.                case 5:
  914.                   if (jjCanMove_2(hiByte, i1, i2, l1, l2) && kind > 16)
  915.                      kind = 16;
  916.                   break;
  917.                default : break;
  918.             }
  919.          } while(i != startsAt);
  920.       }
  921.       if (kind != 0x7fffffff)
  922.       {
  923.          jjmatchedKind = kind;
  924.          jjmatchedPos = curPos;
  925.          kind = 0x7fffffff;
  926.       }
  927.       ++curPos;
  928.       if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
  929.          return curPos;
  930.       try { curChar = input_stream.readChar(); }
  931.       catch(java.io.IOException e) { return curPos; }
  932.    }
  933. }
  934. static final int[] jjnextStates = {
  935.    8, 9, 11, 15, 17, 19, 23, 28, 10, 29, 30, 31, 32, 33, 34, 35, 
  936.    36, 37, 38, 12, 39, 40, 41, 42, 43, 44, 
  937. };
  938. private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
  939. {
  940.    switch(hiByte)
  941.    {
  942.       case 0:
  943.          return ((jjbitVec0[i2] & l2) != 0L);
  944.       case 32:
  945.          return ((jjbitVec1[i2] & l2) != 0L);
  946.       default : 
  947.          return false;
  948.    }
  949. }
  950. private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
  951. {
  952.    switch(hiByte)
  953.    {
  954.       case 0:
  955.          return ((jjbitVec4[i2] & l2) != 0L);
  956.       case 48:
  957.          return ((jjbitVec5[i2] & l2) != 0L);
  958.       case 49:
  959.          return ((jjbitVec6[i2] & l2) != 0L);
  960.       case 51:
  961.          return ((jjbitVec7[i2] & l2) != 0L);
  962.       case 61:
  963.          return ((jjbitVec8[i2] & l2) != 0L);
  964.       default : 
  965.          if ((jjbitVec2[i1] & l1) != 0L)
  966.             return true;
  967.          return false;
  968.    }
  969. }
  970. private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
  971. {
  972.    switch(hiByte)
  973.    {
  974.       case 0:
  975.          return ((jjbitVec10[i2] & l2) != 0L);
  976.       default : 
  977.          if ((jjbitVec9[i1] & l1) != 0L)
  978.             return true;
  979.          return false;
  980.    }
  981. }
  982. public static final String[] jjstrLiteralImages = {
  983. "", null, null, null, null, null, null, null, null, null, null, null, null, 
  984. null, null, null, null, null, null, null, null, "\74\75", "\76\75", "\74", "\76", 
  985. "\173", "\175", "\50", "\51", "\56", "\75", "\72", "\54", null, null, 
  986. "\115\111\116\125\123", "\53", "\77", "\111\116", "\55", "\117\126\105\122", "\133", "\135", 
  987. "\122\105\107\105\130", null, null, null, };
  988. public static final String[] lexStateNames = {
  989.    "DEFAULT", 
  990.    "IN_STRING", 
  991. };
  992. public static final int[] jjnewLexState = {
  993.    -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, 
  994.    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
  995. };
  996. static final long[] jjtoToken = {
  997.    0x1fffffe60001L, 
  998. };
  999. static final long[] jjtoSkip = {
  1000.    0x3eL, 
  1001. };
  1002. static final long[] jjtoMore = {
  1003.    0x1ffc0L, 
  1004. };
  1005. protected SimpleCharStream input_stream;
  1006. private final int[] jjrounds = new int[47];
  1007. private final int[] jjstateSet = new int[94];
  1008. StringBuffer image;
  1009. int jjimageLen;
  1010. int lengthOfMatch;
  1011. protected char curChar;
  1012. public QueryParserTokenManager(SimpleCharStream stream){
  1013.    if (SimpleCharStream.staticFlag)
  1014.       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
  1015.    input_stream = stream;
  1016. }
  1017. public QueryParserTokenManager(SimpleCharStream stream, int lexState){
  1018.    this(stream);
  1019.    SwitchTo(lexState);
  1020. }
  1021. public void ReInit(SimpleCharStream stream)
  1022. {
  1023.    jjmatchedPos = jjnewStateCnt = 0;
  1024.    curLexState = defaultLexState;
  1025.    input_stream = stream;
  1026.    ReInitRounds();
  1027. }
  1028. private final void ReInitRounds()
  1029. {
  1030.    int i;
  1031.    jjround = 0x80000001;
  1032.    for (i = 47; i-- > 0;)
  1033.       jjrounds[i] = 0x80000000;
  1034. }
  1035. public void ReInit(SimpleCharStream stream, int lexState)
  1036. {
  1037.    ReInit(stream);
  1038.    SwitchTo(lexState);
  1039. }
  1040. public void SwitchTo(int lexState)
  1041. {
  1042.    if (lexState >= 2 || lexState < 0)
  1043.       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
  1044.    else
  1045.       curLexState = lexState;
  1046. }

  1048. protected Token jjFillToken()
  1049. {
  1050.    Token t = Token.newToken(jjmatchedKind);
  1051.    t.kind = jjmatchedKind;
  1052.    String im = jjstrLiteralImages[jjmatchedKind];
  1053.    t.image = (im == null) ? input_stream.GetImage() : im;
  1054.    t.beginLine = input_stream.getBeginLine();
  1055.    t.beginColumn = input_stream.getBeginColumn();
  1056.    t.endLine = input_stream.getEndLine();
  1057.    t.endColumn = input_stream.getEndColumn();
  1058.    return t;
  1059. }

  1061. int curLexState = 0;
  1062. int defaultLexState = 0;
  1063. int jjnewStateCnt;
  1064. int jjround;
  1065. int jjmatchedPos;
  1066. int jjmatchedKind;

  1068. public Token getNextToken() 
  1069. {
  1070.   int kind;
  1071.   Token specialToken = null;
  1072.   Token matchedToken;
  1073.   int curPos = 0;

  1075.   EOFLoop :
  1076.   for (;;)
  1077.   {   
  1078.    try   
  1079.    {     
  1080.       curChar = input_stream.BeginToken();
  1081.    }     
  1082.    catch(java.io.IOException e)
  1083.    {        
  1084.       jjmatchedKind = 0;
  1085.       matchedToken = jjFillToken();
  1086.       return matchedToken;
  1087.    }
  1088.    image = null;
  1089.    jjimageLen = 0;

  1091.    for (;;)
  1092.    {
  1093.      switch(curLexState)
  1094.      {
  1095.        case 0:
  1096.          try { input_stream.backup(0);
  1097.             while (curChar <= 32 && (0x100000600L & (1L << curChar)) != 0L)
  1098.                curChar = input_stream.BeginToken();
  1099.          }
  1100.          catch (java.io.IOException e1) { continue EOFLoop; }
  1101.          jjmatchedKind = 0x7fffffff;
  1102.          jjmatchedPos = 0;
  1103.          curPos = jjMoveStringLiteralDfa0_0();
  1104.          break;
  1105.        case 1:
  1106.          jjmatchedKind = 0x7fffffff;
  1107.          jjmatchedPos = 0;
  1108.          curPos = jjMoveStringLiteralDfa0_1();
  1109.          break;
  1110.      }
  1111.      if (jjmatchedKind != 0x7fffffff)
  1112.      {
  1113.         if (jjmatchedPos + 1 < curPos)
  1114.            input_stream.backup(curPos - jjmatchedPos - 1);
  1115.         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
  1116.         {
  1117.            matchedToken = jjFillToken();
  1118.            TokenLexicalActions(matchedToken);
  1119.        if (jjnewLexState[jjmatchedKind] != -1)
  1120.          curLexState = jjnewLexState[jjmatchedKind];
  1121.            return matchedToken;
  1122.         }
  1123.         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
  1124.         {
  1125.          if (jjnewLexState[jjmatchedKind] != -1)
  1126.            curLexState = jjnewLexState[jjmatchedKind];
  1127.            continue EOFLoop;
  1128.         }
  1129.         MoreLexicalActions();
  1130.       if (jjnewLexState[jjmatchedKind] != -1)
  1131.         curLexState = jjnewLexState[jjmatchedKind];
  1132.         curPos = 0;
  1133.         jjmatchedKind = 0x7fffffff;
  1134.         try {
  1135.            curChar = input_stream.readChar();
  1136.            continue;
  1137.         }
  1138.         catch (java.io.IOException e1) { }
  1139.      }
  1140.      int error_line = input_stream.getEndLine();
  1141.      int error_column = input_stream.getEndColumn();
  1142.      String error_after = null;
  1143.      boolean EOFSeen = false;
  1144.      try { input_stream.readChar(); input_stream.backup(1); }
  1145.      catch (java.io.IOException e1) {
  1146.         EOFSeen = true;
  1147.         error_after = curPos <= 1 ? "" : input_stream.GetImage();
  1148.         if (curChar == '\n' || curChar == '\r') {
  1149.            error_line++;
  1150.            error_column = 0;
  1151.         }
  1152.         else
  1153.            error_column++;
  1154.      }
  1155.      if (!EOFSeen) {
  1156.         input_stream.backup(1);
  1157.         error_after = curPos <= 1 ? "" : input_stream.GetImage();
  1158.      }
  1159.      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
  1160.    }
  1161.   }
  1162. }

  1164. void MoreLexicalActions()
  1165. {
  1166.    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
  1167.    switch(jjmatchedKind)
  1168.    {
  1169.       case 7 :
  1170.          if (image == null)
  1171.             image = new StringBuffer();
  1172.          image.append(input_stream.GetSuffix(jjimageLen));
  1173.          jjimageLen = 0;
  1174.              image.setLength(image.length() - 2); image.append("\n");
  1175.          break;
  1176.       case 8 :
  1177.          if (image == null)
  1178.             image = new StringBuffer();
  1179.          image.append(input_stream.GetSuffix(jjimageLen));
  1180.          jjimageLen = 0;
  1181.              image.setLength(image.length() - 2); image.append("\r");
  1182.          break;
  1183.       case 9 :
  1184.          if (image == null)
  1185.             image = new StringBuffer();
  1186.          image.append(input_stream.GetSuffix(jjimageLen));
  1187.          jjimageLen = 0;
  1188.              image.setLength(image.length() - 2); image.append("\t");
  1189.          break;
  1190.       case 10 :
  1191.          if (image == null)
  1192.             image = new StringBuffer();
  1193.          image.append(input_stream.GetSuffix(jjimageLen));
  1194.          jjimageLen = 0;
  1195.              image.setLength(image.length() - 2); image.append("\b");
  1196.          break;
  1197.       case 11 :
  1198.          if (image == null)
  1199.             image = new StringBuffer();
  1200.          image.append(input_stream.GetSuffix(jjimageLen));
  1201.          jjimageLen = 0;
  1202.              image.setLength(image.length() - 2); image.append("\f");
  1203.          break;
  1204.       case 12 :
  1205.          if (image == null)
  1206.             image = new StringBuffer();
  1207.          image.append(input_stream.GetSuffix(jjimageLen));
  1208.          jjimageLen = 0;
  1209.               image.setLength(image.length() - 2); image.append("\"");
  1210.          break;
  1211.       case 13 :
  1212.          if (image == null)
  1213.             image = new StringBuffer();
  1214.          image.append(input_stream.GetSuffix(jjimageLen));
  1215.          jjimageLen = 0;
  1216.               image.setLength(image.length() - 2); image.append("\'");
  1217.          break;
  1218.       case 14 :
  1219.          if (image == null)
  1220.             image = new StringBuffer();
  1221.          image.append(input_stream.GetSuffix(jjimageLen));
  1222.          jjimageLen = 0;
  1223.               image.setLength(image.length() - 2); image.append("\\");
  1224.          break;
  1225.       case 15 :
  1226.          if (image == null)
  1227.             image = new StringBuffer();
  1228.          image.append(input_stream.GetSuffix(jjimageLen));
  1229.          jjimageLen = 0;
  1230.              String digits = image.substring(image.length() - 4, image.length());
  1231.              image.setLength(image.length() - 6);
  1232.              image.append((char)Integer.parseInt(digits, 16));
  1233.          break;
  1234.       default : 
  1235.          break;
  1236.    }
  1237. }
  1238. void TokenLexicalActions(Token matchedToken)
  1239. {
  1240.    switch(jjmatchedKind)
  1241.    {
  1242.       case 17 :
  1243.         if (image == null)
  1244.             image = new StringBuffer();
  1245.             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
  1246.     // image.setLength(image.length() - 1);
  1247.      matchedToken.image = image.toString();
  1248.          break;
  1249.       default : 
  1250.          break;
  1251.    }
  1252. }
  1253. }
Created with JaCoCo 0.8.5.201910111838