QueryParser.java

  1. /* Generated By:JavaCC: Do not edit this line. QueryParser.java */
  2. package gate.mimir.search.query.parser;

  4. import gate.Annotation;
  5. import gate.Corpus;
  6. import gate.Document;
  7. import gate.Factory;
  8. import gate.Gate;
  9. import gate.LanguageAnalyser;
  10. import gate.creole.ANNIEConstants;
  11. import gate.creole.ExecutionException;
  12. import gate.creole.ResourceInstantiationException;
  13. import gate.util.OffsetComparator;

  15. import gate.mimir.search.query.QueryNode;
  16. import gate.mimir.search.query.SequenceQuery.Gap;
  17. import gate.mimir.ConstraintType;
  18. import gate.mimir.Constraint;

  20. import java.io.StringReader;
  21. import java.util.ArrayList;
  22. import java.util.Collections;
  23. import java.util.List;

  25. /**
  26.  * QueryParser. Given a text query, this parser returns a QueryNode object
  27.  * that can be used for querying the Mimir index.
  28.  */
  29. public class QueryParser implements QueryParserConstants {

  31.   // keeping track of row and column for gap queries
  32.   // please note that this variable is updated only on certain occassions
  33.   int column;
  34.   int row;
  35.   boolean debug = false;

  37.   private static final OffsetComparator OFFSET_COMPARATOR = new OffsetComparator();

  39.   /**
  40.    * The GATE LanguageAnalyser used to tokenise plain term queries and quoted
  41.    * strings.  Typically this will just be a tokeniser PR but we allow any
  42.    * LanguageAnalyser so more complex processing can be injected if required.
  43.    * The only requirement is that the LA can take an un-annotated document and
  44.    * return one with {@link ANNIEConstants#TOKEN_ANNOTATION_TYPE} annotations
  45.    * in the default annotation set.
  46.    */
  47.   private LanguageAnalyser queryTokeniser;

  49.   /**
  50.    * Set the GATE LanguageAnalyser used to parse quoted strings in queries.
  51.    * This allows clients to override the default tokeniser if required, and
  52.    * should be called before the first use of {@link #parse}.
  53.    */
  54.   public void setQueryTokeniser(LanguageAnalyser tok) {
  55.     queryTokeniser = tok;
  56.   }

  58.   /**
  59.    * Default query tokeniser, used if no specific tokeniser has been passed to
  60.    * a particular parser instance.  Initialized lazily on first use.
  61.    */
  62.   private static LanguageAnalyser defaultQueryTokeniser;

  64.   public static final String DEFAULT_TOKENISER_CLASS_NAME =
  65.     "gate.creole.tokeniser.DefaultTokeniser";

  67.   /**
  68.    * Returns the default query tokeniser, initializing it if necessary.
  69.    */
  70.   private static synchronized LanguageAnalyser getDefaultQueryTokeniser() throws ParseException {
  71.     if(defaultQueryTokeniser == null) {
  72.       try {
  73.         defaultQueryTokeniser = (LanguageAnalyser)Factory.createResource(
  74.             DEFAULT_TOKENISER_CLASS_NAME);
  75.       }
  76.       catch(ResourceInstantiationException e) {
  77.         throw (ParseException)new ParseException("Couldn't create query tokeniser")
  78.           .initCause(e);
  79.       }
  80.     }

  82.     return defaultQueryTokeniser;
  83.   }

  85.   public static void main(String[] args) throws Exception {
  86.     String query = args[0];
  87.     Gate.init();
  88.     QueryNode node = QueryParser.parse(query);
  89.     System.out.println(query);
  90.     System.out.println(node.getClass().getName());
  91.   }

  93.   /**
  94.    * Parses the query and returns a top level QueryNode object.
  95.    * @param query the query to parse
  96.    * @return instance of the QueryNode
  97.    */
  98.   public static QueryNode parse(String query) throws ParseException {
  99.     return parse(query, getDefaultQueryTokeniser());
  100.   }

  102.   /**
  103.    * Parses the query and returns a top level QueryNode object.
  104.    * @param query the query to parse
  105.    * @param tokeniser the GATE {@link LanguageAnalyser} used to parse strings
  106.    *         in the query.
  107.    * @return instance of the QueryNode
  108.    */
  109.   public static QueryNode parse(String query, LanguageAnalyser tokeniser) throws ParseException {
  110.       // start parsing
  111.       QueryParser parser = new QueryParser(new StringReader(query));
  112.       parser.setQueryTokeniser(tokeniser);
  113.       Query queryInst = parser.start();
  114.       return parser.convert(queryInst, "");
  115.   }

  117.   /**
  118.    * converts the given query object into an appropriate QueryNode.
  119.    * @param queryInst
  120.    * @return instance of QueryNode 
  121.    */
  122.   private QueryNode convert(Query queryInst, String space)
  123.                                              throws ParseException {
  124.     // need to convert queryInst into appropriate query objects
  125.     // TermQuery, AnnotationQuery, GapQuery, InQuery, OverQuery, KleneQuery
  126.     // OrQuery, AndQuery, SequenceQuery
  127.     if(queryInst instanceof TermQuery) {
  128.       return toTermQuery((TermQuery)queryInst, space);
  129.     } else if(queryInst instanceof AnnotationQuery) {
  130.       return toAnnotationQuery((AnnotationQuery) queryInst, space);
  131.     } else if(queryInst instanceof GapQuery) {
  132.       throw new ParseException(
  133.            "Gap cannot be specified as a first or last element in the query");
  134.     } else if(queryInst instanceof InQuery) {
  135.       return toWithinQuery((InQuery)queryInst, space);
  136.     } else if(queryInst instanceof OverQuery) {
  137.       return toContainsQuery((OverQuery)queryInst, space);
  138.     } else if(queryInst instanceof KleneQuery) {
  139.       return toRepeatsQuery((KleneQuery)queryInst, space);
  140.     } else if(queryInst instanceof ORQuery) {
  141.       return toOrQuery((ORQuery)queryInst, space);
  142.     } else if(queryInst instanceof ANDQuery) {
  143.       return toAndQuery((ANDQuery)queryInst, space);
  144.     } else if(queryInst instanceof MinusQuery) {
  145.       return toMinusQuery((MinusQuery)queryInst, space);
  146.     } else if(queryInst instanceof SequenceQuery) {
  147.       return toSequenceQuery((SequenceQuery)queryInst, space);
  148.     }
  149.     else {
  150.       throw new ParseException("Invalid query type:" +
  151.                                  queryInst.getClass().getName());
  152.     }
  153.   }

  155.   /**
  156.    * Conversion of the TermQuery
  157.    * @param query
  158.    * @return
  159.    */
  160.   private QueryNode toTermQuery(TermQuery query, String space) {
  161.     if(debug) System.out.println(space + "Term="+query.index+":"+query.term);
  162.     return new gate.mimir.search.query.TermQuery(query.index, query.term);
  163.   }

  165.   /**
  166.    * Conversion of the AnnotationQuery
  167.    * @param query
  168.    * @return
  169.    */
  170.   private QueryNode toAnnotationQuery(AnnotationQuery query, String space) {
  171.     if(debug) System.out.println(space + "Annotation="+query.type);
  172.     List<Constraint> featureConstraints = new ArrayList<Constraint>();
  173.     for(FeatureValuePair fvp : query.pairs) {
  174.       Constraint c = null;
  175.       if(fvp.constraintType == FeatureValuePair.EQ) {
  176.         if(debug)
  177.           System.out.println("\t"+fvp.feature+"="+fvp.value);
  178.         c = new Constraint(ConstraintType.EQ, fvp.feature, fvp.value);
  179.       } else if(fvp.constraintType == FeatureValuePair.REGEX) {
  180.         if(fvp.value instanceof String[]) {
  181.           if(debug) {
  182.             String[] values = (String[]) fvp.value;
  183.             System.out.println("\t"+fvp.feature+".REGEX("+values[0]+"," +
  184.                                values[1]+")");
  185.           }
  186.         } else {
  187.           if(debug) System.out.println("\t"+fvp.feature+".REGEX("
  188.                                         +fvp.value+")");
  189.         }
  190.         c = new Constraint(ConstraintType.REGEX, fvp.feature, fvp.value);
  191.       } else if(fvp.constraintType == FeatureValuePair.LT) {
  192.         if(debug)
  193.           System.out.println("\t"+fvp.feature+"<"+fvp.value);
  194.         c = new Constraint(ConstraintType.LT, fvp.feature, fvp.value);
  195.       } else if(fvp.constraintType == FeatureValuePair.GT) {
  196.         if(debug)
  197.           System.out.println("\t"+fvp.feature+">"+fvp.value);
  198.         c = new Constraint(ConstraintType.GT, fvp.feature, fvp.value);
  199.       } else if(fvp.constraintType == FeatureValuePair.LE) {
  200.         if(debug)
  201.           System.out.println("\t"+fvp.feature+"<="+fvp.value);
  202.         c = new Constraint(ConstraintType.LE, fvp.feature, fvp.value);
  203.       } else {
  204.         if(debug)
  205.           System.out.println("\t"+fvp.feature+">="+fvp.value);
  206.         c = new Constraint(ConstraintType.GE, fvp.feature, fvp.value);
  207.       }
  208.       featureConstraints.add(c);
  209.     }
  210.     return new gate.mimir.search.query.AnnotationQuery(query.type,
  211.                                                           featureConstraints);
  212.   }

  214.   /**
  215.    * Conversion of the InQuery into WithinQuery
  216.    * @param query
  217.    * @return
  218.    * @throws ParseException
  219.    */
  220.   private QueryNode toWithinQuery(InQuery query, String space)
  221.                                                  throws ParseException {
  222.     if(debug) System.out.println(space + "WithinQuery:");
  223.     QueryNode targetQuery = convert(query.innerQuery, space + " ");
  224.     QueryNode surroundingQuery = convert(query.outerQuery, space + " ");
  225.     return new gate.mimir.search.query.WithinQuery(targetQuery,
  226.                                                     surroundingQuery);
  227.   }

  229.   /**
  230.    * Conversion of the OverQuery into ContainsQuery
  231.    * @param query
  232.    * @return
  233.    * @throws ParseException
  234.    */
  235.   private QueryNode toContainsQuery(OverQuery query, String space)
  236.                                                      throws ParseException {
  237.     if(debug) System.out.println(space + "ContainsQuery");
  238.     QueryNode targetQuery = convert(query.overQuery, space + " ");
  239.     QueryNode nestedQuery = convert(query.innerQuery, space + " ");
  240.     return new gate.mimir.search.query.ContainsQuery(targetQuery, nestedQuery);
  241.   }

  243.   /**
  244.    * Conversion of the KleneQuery into RepeatsQuery
  245.    * @param query
  246.    * @return
  247.    * @throws ParseException
  248.    */
  249.   private QueryNode toRepeatsQuery(KleneQuery query, String space)
  250.                                                      throws ParseException {
  251.     if(debug) System.out.println(space + "Repeats:"+query.min+".."+query.max);
  252.     QueryNode queryNode = convert(query.query, space + " ");
  253.     return new gate.mimir.search.query.RepeatsQuery(queryNode, query.min,
  254.                                                                    query.max);
  255.   }

  257.   /**
  258.    * Conversion of the ORQuery
  259.    * @param query
  260.    * @return
  261.    * @throws ParseException
  262.    */
  263.   private QueryNode toOrQuery(ORQuery query, String space)
  264.                                              throws ParseException {
  265.     int totalQueries = query.queriesToOr.size();
  266.     if(debug) System.out.println(space + "OrQuery:"+totalQueries);
  267.     QueryNode [] orQueries = new QueryNode[totalQueries];
  268.     for(int i=0;i<totalQueries;i++) {
  269.       orQueries[i] = convert(query.queriesToOr.get(i), space + " ");
  270.     }
  271.     return new gate.mimir.search.query.OrQuery(orQueries);
  272.   }

  274.   /**
  275.    * Conversion of the ANDQuery
  276.    * @param query
  277.    * @return
  278.    * @throws ParseException
  279.    */
  280.   private QueryNode toAndQuery(ANDQuery query, String space)
  281.                                              throws ParseException {
  282.     int totalQueries = query.queriesToAnd.size();
  283.     if(debug) System.out.println(space + "AndQuery:"+totalQueries);
  284.     QueryNode [] andQueries = new QueryNode[totalQueries];
  285.     for(int i=0;i<totalQueries;i++) {
  286.       andQueries[i] = convert(query.queriesToAnd.get(i), space + " ");
  287.     }
  288.     return new gate.mimir.search.query.AndQuery(andQueries);
  289.   }

  291.   /**
  292.    * Conversion of the MinusQuery
  293.    * @param query
  294.    * @return
  295.    * @throws ParseException
  296.    */
  297.   private QueryNode toMinusQuery(MinusQuery query, String space)
  298.                                              throws ParseException {
  299.     if(debug) System.out.println(space + "MinusQuery:");
  300.     QueryNode leftQuery = convert(query.leftQuery, space + " ");
  301.     QueryNode rightQuery = convert(query.rightQuery, space + " ");
  302.     return new gate.mimir.search.query.MinusQuery(leftQuery,
  303.                                                     rightQuery);
  304.   }

  306.   /**
  307.    * Conversion of the SequenceQuery
  308.    * @param query
  309.    * @return
  310.    * @throws ParseException
  311.    */
  312.   private QueryNode toSequenceQuery(SequenceQuery query, String space)
  313.                                                          throws ParseException {
  314.     if(query.queriesInOrder.size() > 1) {
  315.       if(debug) System.out.println(space +
  316.                                  "SequenceQuery:"+query.queriesInOrder.size());
  317.     }
  318.     List<QueryNode> queries = new ArrayList<QueryNode>();
  319.     List<Gap> queryGaps = new ArrayList<Gap>();

  321.     boolean canBeGapQuery = false;

  323.     for(int i=0;i<query.queriesInOrder.size();i++) {
  324.       Query q = query.queriesInOrder.get(i);
  325.       if(q instanceof GapQuery) {
  326.         if(!canBeGapQuery) {
  327.           throw new ParseException("Improper use of the Gap");
  328.         }

  330.         if(i == query.queriesInOrder.size()-1) {
  331.           throw new ParseException(
  332.                          "Last element in the SequenceQuery cannot be gap");
  333.         }

  335.         GapQuery gq = (GapQuery) q;
  336.         Gap gap =
  337.            gate.mimir.search.query.SequenceQuery.getGap(gq.minGap, gq.maxGap);
  338.         if(debug) System.out.println(space +
  339.                                      " GapQuery:"+gq.minGap+".."+gq.maxGap);
  340.         queryGaps.add(gap);
  341.         // next element cannot be a gap query
  342.         canBeGapQuery = false;
  343.         continue;
  344.       }

  346.       // expecting a gap?
  347.       if(canBeGapQuery) {
  348.         // yes but this is not a gap, so add an empty gap
  349.         queryGaps.add(gate.mimir.search.query.SequenceQuery.getGap(0, 0));
  350.       }
  351.       queries.add(convert(q, query.queriesInOrder.size() > 1 ? space + " " : space));
  352.       canBeGapQuery = true;
  353.     }

  355.     if(queries.size() == 1) {
  356.       return queries.get(0);
  357.     } else {
  358.       return new gate.mimir.search.query.SequenceQuery(
  359.             queryGaps.toArray(new Gap[0]), queries.toArray(new QueryNode[0]));
  360.     }
  361.   }

  363.   /** converts escape sequences into normal sequences */
  364.   public String unescape(String s) {
  365.     return s.replaceAll("\\\"IN\\\"","IN")
  366.                       .replaceAll("\\\"OVER\\\"","OVER")
  367.                       .replaceAll("\\\"AND\\\"","AND")
  368.                       .replaceAll("\\\"OR\\\"","OR")
  369.                       .replaceAll("\\\"REGEX\\\"","REGEX")
  370.                       .replaceAll("\\\\\\{","{").replaceAll("\\\\\\}","}")
  371.                       .replaceAll("\\\\\\<","<").replaceAll("\\\\\\>",">")
  372.                       .replaceAll("\\\\\\-","-")
  373.                       .replaceAll("\\\\\\[","[").replaceAll("\\\\\\]","]")
  374.                       .replaceAll("\\\\\\(","(").replaceAll("\\\\\\)",")")
  375.                       .replaceAll("\\\\\\:",":").replaceAll("\\\\\\+","+")
  376.                       .replaceAll("\\\\\\|","|").replaceAll("\\\\\\?","?")
  377.                       .replaceAll("\\\\\\&","&")
  378.                       .replaceAll("\\\\\\.",".").replaceAll("\\\\\"","\"")
  379.                       .replaceAll("\\\\\\=","=").replaceAll("(\\\\){2}","\\\\");
  380.   }

  382.   // parse string and obtain the appropriate query object
  383.   public Query parseString(String s) throws ParseException {
  384.     Document document = null;
  385.     Corpus corpus = null;
  386.     synchronized(queryTokeniser) {
  387.       try {
  388.         document = Factory.newDocument(s);
  389.         corpus = Factory.newCorpus("QueryParser corpus");
  390.         corpus.add(document);
  391.         queryTokeniser.setCorpus(corpus);
  392.         queryTokeniser.setDocument(document);
  393.         queryTokeniser.execute();

  395.         List<Annotation> tokens = new ArrayList<Annotation>(
  396.             document.getAnnotations().get(ANNIEConstants.TOKEN_ANNOTATION_TYPE));
  397.         Collections.sort(tokens, OFFSET_COMPARATOR);

  399.         if(tokens.size() > 1) {
  400.           SequenceQuery sq = new SequenceQuery();
  401.           for(Annotation term : tokens) {
  402.             TermQuery tq = new TermQuery();
  403.             tq.term = (String)term.getFeatures()
  404.                         .get(ANNIEConstants.TOKEN_STRING_FEATURE_NAME);
  405.             tq.index = null;  // as valy suggested using null instead of "string";
  406.             sq.add(tq);
  407.           }
  408.           return sq;
  409.         }
  410.         else {
  411.           TermQuery tq = new TermQuery();
  412.           tq.term = (String)tokens.get(0).getFeatures()
  413.                       .get(ANNIEConstants.TOKEN_STRING_FEATURE_NAME);
  414.           tq.index = null;  // as valy suggested using null instead of "string";
  415.           return tq;
  416.         }
  417.       }
  418.       catch(ResourceInstantiationException e) {
  419.         throw (ParseException)new ParseException(
  420.             "Error creating GATE document for string parser").initCause(e);
  421.       }
  422.       catch(ExecutionException e) {
  423.         throw (ParseException)new ParseException(
  424.             "Error tokenising string").initCause(e);
  425.       }
  426.       finally {
  427.         queryTokeniser.setCorpus(null);
  428.         queryTokeniser.setDocument(null);
  429.         if(corpus != null) {
  430.           corpus.clear();
  431.           Factory.deleteResource(corpus);
  432.         }
  433.         if(document != null) {
  434.           Factory.deleteResource(document);
  435.         }
  436.       }
  437.     }
  438.   }

  440. // lexical analyser

  442. // starting method with EOF
  443.   final public Query start() throws ParseException {
  444.   Query q;
  445.     q = QueryPlus();
  446.     {if (true) return q;}
  447.     jj_consume_token(0);
  448.     throw new Error("Missing return statement in function");
  449.   }

  451. /**
  452.  * Query+
  453.  * If more than one query detected, an object of sequence query is returned. 
  454.  * If there is only one query, that particular instance of query is returned.
  455.  */
  456.   final public Query QueryPlus() throws ParseException {
  457.   Query q;
  458.   Query q1;
  459.   SequenceQuery sq = new SequenceQuery();
  460.     q = Query(null);
  461.     sq.add(q);
  462.     label_1:
  463.     while (true) {
  464.       if (jj_2_1(2147483647)) {
  465.         ;
  466.       } else {
  467.         break label_1;
  468.       }
  469.       q1 = Query(q);
  470.       if(q1 instanceof InQuery ||
  471.          q1 instanceof OverQuery ||
  472.          q1 instanceof MinusQuery ||
  473.          q1 instanceof ORQuery ||
  474.          q1 instanceof ANDQuery ||
  475.          q1 instanceof KleneQuery) {
  476.         sq.removeLastElement();
  477.       }

  479.       q = q1;
  480.       sq.add(q);
  481.     }
  482.     if(q instanceof GapQuery)
  483.       {if (true) throw new ParseException(
  484.       "Gap cannot be the first/last element. See line:"+row+", column:"+column);}

  486.     if(sq.size() == 1 && !(q instanceof InQuery ||
  487.          q instanceof OverQuery || q instanceof ORQuery ||
  488.          q instanceof ANDQuery || q instanceof KleneQuery ||
  489.          q instanceof MinusQuery))
  490.       {if (true) return q;}
  491.     else
  492.       {if (true) return sq;}
  493.     throw new Error("Missing return statement in function");
  494.   }

  496. /**
  497.  * Returns true if the next token in the stream is a reserved word
  498.  */
  499.   final public boolean reserved() throws ParseException {
  500.     switch (jj_nt.kind) {
  501.     case string:
  502.       jj_consume_token(string);
  503.       break;
  504.     case leftbrace:
  505.       jj_consume_token(leftbrace);
  506.       break;
  507.     case leftbracket:
  508.       jj_consume_token(leftbracket);
  509.       break;
  510.     case or:
  511.       jj_consume_token(or);
  512.       break;
  513.     case and:
  514.       jj_consume_token(and);
  515.       break;
  516.     case in:
  517.       jj_consume_token(in);
  518.       break;
  519.     case over:
  520.       jj_consume_token(over);
  521.       break;
  522.     case minus:
  523.       jj_consume_token(minus);
  524.       break;
  525.     case plus:
  526.       jj_consume_token(plus);
  527.       break;
  528.     case tok:
  529.       jj_consume_token(tok);
  530.       break;
  531.     case leftsquarebracket:
  532.       jj_consume_token(leftsquarebracket);
  533.       break;
  534.     case hyphen:
  535.       jj_consume_token(hyphen);
  536.       break;
  537.     case number:
  538.       jj_consume_token(number);
  539.    {if (true) return true;}
  540.       break;
  541.     default:
  542.       jj_la1[0] = jj_gen;
  543.       jj_consume_token(-1);
  544.       throw new ParseException();
  545.     }
  546.     throw new Error("Missing return statement in function");
  547.   }

  549. /**
  550.  * parse a single query.
  551.  */
  552.   final public Query Query(Query previousQuery) throws ParseException {
  553.   Query q;
  554.   Query[] qs = new Query[2];
  555.     switch (jj_nt.kind) {
  556.     case leftbracket:
  557.       jj_consume_token(leftbracket);
  558.       // a query can be surrounded by ( and )
  559.               q = QueryPlus();
  560.       jj_consume_token(rightbracket);
  561.       break;
  562.     case leftbrace:
  563.       q = AnnotationQuery();
  564.       break;
  565.     case number:
  566.     case hyphen:
  567.     case tok:
  568.       q = TermOrNamedIndexQuery();
  569.       break;
  570.     case string:
  571.       q = QuotedTextQuery();
  572.       break;
  573.     case leftsquarebracket:
  574.       q = GapQuery();
  575.       break;
  576.     case in:
  577.       q = InQuery(previousQuery);
  578.       break;
  579.     case over:
  580.       q = OverQuery(previousQuery);
  581.       break;
  582.     case minus:
  583.       q = MinusQuery(previousQuery);
  584.       break;
  585.     default:
  586.       jj_la1[1] = jj_gen;
  587.       if (jj_2_2(2147483647)) {
  588.         q = OrQuery(previousQuery);
  589.       } else if (jj_2_3(2147483647)) {
  590.         q = AndQuery(previousQuery);
  591.       } else {
  592.         switch (jj_nt.kind) {
  593.         case plus:
  594.           q = KleneQuery(previousQuery);
  595.           break;
  596.         default:
  597.           jj_la1[2] = jj_gen;
  598.           jj_consume_token(-1);
  599.           throw new ParseException();
  600.         }
  601.       }
  602.     }
  603.     {if (true) return q;}
  604.     throw new Error("Missing return statement in function");
  605.   }

  607. /**
  608.  * Gap. Only valid if it is a part of a sequence query.
  609.  * Cannot appear at the start or at the end of a query
  610.  */
  611.   final public Query GapQuery() throws ParseException {
  612.   GapQuery gq = new GapQuery();
  613.   Token t;
  614.     t = jj_consume_token(leftsquarebracket);
  615.     column = t.beginColumn;
  616.     row = t.beginLine;
  617.     t = jj_consume_token(number);
  618.    gq.maxGap = Integer.parseInt(t.image);
  619.     switch (jj_nt.kind) {
  620.     case period:
  621.       jj_consume_token(period);
  622.       jj_consume_token(period);
  623.       t = jj_consume_token(number);
  624.      gq.minGap = gq.maxGap; gq.maxGap = Integer.parseInt(t.image);
  625.       break;
  626.     default:
  627.       jj_la1[3] = jj_gen;
  628.       ;
  629.     }
  630.     jj_consume_token(rightsquarebracket);
  631.     {if (true) return gq;}
  632.     throw new Error("Missing return statement in function");
  633.   }

  635. /**
  636.  * Returns true if the next token in the stream is a regex word
  637.  */
  638.   final public boolean regex() throws ParseException {
  639.     jj_consume_token(period);
  640.     jj_consume_token(regex);
  641.    {if (true) return true;}
  642.     throw new Error("Missing return statement in function");
  643.   }

  645. /**
  646.  * Returns true if the next token in the stream is a double number
  647.  */
  648.   final public String number() throws ParseException {
  649.   StringBuffer sb = new StringBuffer();
  650.   Token t;
  651.     switch (jj_nt.kind) {
  652.     case hyphen:
  653.       t = jj_consume_token(hyphen);
  654.     sb.append(t.image);
  655.       break;
  656.     default:
  657.       jj_la1[4] = jj_gen;
  658.       ;
  659.     }
  660.     t = jj_consume_token(number);
  661.     sb.append(t.image);
  662.     switch (jj_nt.kind) {
  663.     case period:
  664.       t = jj_consume_token(period);
  665.       sb.append(t.image);
  666.       t = jj_consume_token(number);
  667.       sb.append(t.image);
  668.       break;
  669.     default:
  670.       jj_la1[5] = jj_gen;
  671.       ;
  672.     }
  673.    {if (true) return sb.toString();}
  674.     throw new Error("Missing return statement in function");
  675.   }

  677. // Regext Query
  678.   final public void RegexQuery(AnnotationQuery aq, String feature) throws ParseException {
  679.   Token t;
  680.   String flags = null;
  681.   Object value;
  682.   int constraintType = 0;
  683.     jj_consume_token(period);
  684.     jj_consume_token(regex);
  685.     jj_consume_token(leftbracket);
  686.     t = jj_consume_token(string);
  687.     value = t.image.substring(1, t.image.length()-1);
  688.     constraintType = FeatureValuePair.REGEX;
  689.     switch (jj_nt.kind) {
  690.     case comma:
  691.       jj_consume_token(comma);
  692.       t = jj_consume_token(string);
  693.       flags = t.image.substring(1, t.image.length()-1);
  694.       value = new String[]{value.toString(), flags};
  695.       break;
  696.     default:
  697.       jj_la1[6] = jj_gen;
  698.       ;
  699.     }
  700.     jj_consume_token(rightbracket);
  701.    aq.add(constraintType, feature, value, flags);
  702.   }

  704. /**
  705.  * Annotation Query
  706.  * e.g. {AnnotationType featureName=featureValue}
  707.  * e.g. featureValue can be a quoted value
  708.  */
  709.   final public Query AnnotationQuery() throws ParseException {
  710.   AnnotationQuery aq = new AnnotationQuery();
  711.   Token t;
  712.   String feature = null;
  713.   Object value = null;
  714.   String flags = null;
  715.   String numberStr = "";
  716.   int constraintType = 0;
  717.     jj_consume_token(leftbrace);
  718.     t = jj_consume_token(tok);
  719.     aq.type = unescape(t.image);
  720.     label_2:
  721.     while (true) {
  722.       switch (jj_nt.kind) {
  723.       case tok:
  724.         ;
  725.         break;
  726.       default:
  727.         jj_la1[7] = jj_gen;
  728.         break label_2;
  729.       }
  730.       // feature name
  731.           t = jj_consume_token(tok);
  732.      feature = unescape(t.image);
  733.       if (jj_2_4(2147483647)) {
  734.         RegexQuery(aq, feature);
  735.       } else {
  736.         switch (jj_nt.kind) {
  737.         case le:
  738.         case ge:
  739.         case lt:
  740.         case gt:
  741.         case equals:
  742.           switch (jj_nt.kind) {
  743.           case equals:
  744.             t = jj_consume_token(equals);
  745.                 constraintType = FeatureValuePair.EQ;
  746.             break;
  747.           case le:
  748.             t = jj_consume_token(le);
  749.                 constraintType = FeatureValuePair.LE;
  750.             break;
  751.           case ge:
  752.             t = jj_consume_token(ge);
  753.                 constraintType = FeatureValuePair.GE;
  754.             break;
  755.           case gt:
  756.             t = jj_consume_token(gt);
  757.                 constraintType = FeatureValuePair.GT;
  758.             break;
  759.           case lt:
  760.             t = jj_consume_token(lt);
  761.                 constraintType = FeatureValuePair.LT;
  762.             break;
  763.           default:
  764.             jj_la1[8] = jj_gen;
  765.             jj_consume_token(-1);
  766.             throw new ParseException();
  767.           }
  768.           switch (jj_nt.kind) {
  769.           case string:
  770.             t = jj_consume_token(string);
  771.                 value = t.image.substring(1, t.image.length()-1);
  772.             break;
  773.           case tok:
  774.             t = jj_consume_token(tok);
  775.                 value = unescape(t.image);
  776.             break;
  777.           case number:
  778.           case hyphen:
  779.             numberStr = number();
  780.                 try {
  781.                   value = new Double(Double.parseDouble(numberStr));
  782.                 } catch(NumberFormatException nfe) {
  783.                   {if (true) throw new ParseException("Invalid Number :" + numberStr);}
  784.                 }
  785.             break;
  786.           default:
  787.             jj_la1[9] = jj_gen;
  788.             jj_consume_token(-1);
  789.             throw new ParseException();
  790.           }
  791.          aq.add(constraintType, feature, value);
  792.           break;
  793.         default:
  794.           jj_la1[10] = jj_gen;
  795.           jj_consume_token(-1);
  796.           throw new ParseException();
  797.         }
  798.       }
  799.     }
  800.     jj_consume_token(rightbrace);
  801.    {if (true) return aq;}
  802.     throw new Error("Missing return statement in function");
  803.   }

  805. /**
  806.  * UnQuotedText or NamedIndexQuery
  807.  * e.g. microsoft corporation 
  808.  * e.g. root:value
  809.  */
  810.   final public Query TermOrNamedIndexQuery() throws ParseException {
  811.   Token t;
  812.   Token t1;
  813.   String n;
  814.   TermQuery tq;
  815.     if (jj_2_5(2)) {
  816.       t = jj_consume_token(tok);
  817.       jj_consume_token(colon);
  818.           tq = new TermQuery();
  819.           tq.index = unescape(t.image);
  820.       switch (jj_nt.kind) {
  821.       case tok:
  822.         t1 = jj_consume_token(tok);
  823.             tq.term = unescape(t1.image);
  824.         break;
  825.       case string:
  826.         t1 = jj_consume_token(string);
  827.             tq.term = t1.image.substring(1, t1.image.length()-1);
  828.         break;
  829.       default:
  830.         jj_la1[11] = jj_gen;
  831.         jj_consume_token(-1);
  832.         throw new ParseException();
  833.       }
  834.         {if (true) return tq;}
  835.     } else {
  836.       switch (jj_nt.kind) {
  837.       case tok:
  838.         t = jj_consume_token(tok);
  839.         // if no index name is specified, parse the token like a quoted
  840.         // string.
  841.         {if (true) return parseString(unescape(t.image));}
  842.         break;
  843.       case number:
  844.       case hyphen:
  845.         // bare number is treated as a query for that number as a string
  846.               n = number();
  847.         {if (true) return parseString(unescape(n));}
  848.         break;
  849.       default:
  850.         jj_la1[12] = jj_gen;
  851.         jj_consume_token(-1);
  852.         throw new ParseException();
  853.       }
  854.     }
  855.     throw new Error("Missing return statement in function");
  856.   }

  858. /**
  859.  * obtaining a term or sequence query with all terms in it.
  860.  * e.g. "amazing videos"
  861.  */
  862.   final public Query QuotedTextQuery() throws ParseException {
  863.   String s;
  864.   Token t;
  865.     t = jj_consume_token(string);
  866.     s= t.image.substring(1, t.image.length()-1);
  867.    {if (true) return parseString(s);}
  868.     throw new Error("Missing return statement in function");
  869.   }

  871. /** 
  872.  * OrQuery
  873.  * e.g. Query | Query
  874.  * In the example above, first "Query" is supplied in the previousQuery parameter.
  875.  * This method starts parsing tokens after the previousQuery has ended.
  876.  * i.e. first character after the previous query must be "|"
  877.  */
  878.   final public Query OrQuery(Query previousQuery) throws ParseException {
  879.   ORQuery orQuery = new ORQuery();
  880.   Query q;
  881.   Token t;
  882.     t = jj_consume_token(or);
  883.     if(previousQuery instanceof GapQuery)
  884.       {if (true) throw new ParseException("First element cannot be Gap. See line:"+row+", column:"+column);}

  886.     column = t.beginColumn;
  887.     row = t.beginLine;

  889.     if(previousQuery == null)
  890.       {if (true) throw new ParseException(
  891.          "Use of OR at the start of a query is not permitted. See line:"+row+", column:"+column);}

  893.     orQuery.add(previousQuery);
  894.     q = QueryPlus();
  895.     // merging all ORQueries into one
  896.     // i.e. ORQuery { query1, ORQuery {query2, query3}}
  897.     // will become ORQuery {query1, query2, query3}
  898.     if(q instanceof ORQuery) {
  899.       ORQuery oq = (ORQuery) q;
  900.       for(Query qq : oq.getQueries()) {
  901.         orQuery.add(qq);
  902.       }
  903.     } else {
  904.       orQuery.add(q);
  905.     }
  906.     {if (true) return orQuery;}
  907.     throw new Error("Missing return statement in function");
  908.   }

  910. /** 
  911.  * AndQuery
  912.  * e.g. Query & Query
  913.  * In the example above, first "Query" is supplied in the previousQuery parameter.
  914.  * This method starts parsing tokens after the previousQuery has ended.
  915.  * i.e. first character after the previous query must be "&" Or AND
  916.  */
  917.   final public Query AndQuery(Query previousQuery) throws ParseException {
  918.   ANDQuery andQuery = new ANDQuery();
  919.   Query q;
  920.   Token t;
  921.     t = jj_consume_token(and);
  922.     if(previousQuery instanceof GapQuery)
  923.       {if (true) throw new ParseException("First element cannot be Gap. See line:"+row+", column:"+column);}

  925.     column = t.beginColumn;
  926.     row = t.beginLine;

  928.     if(previousQuery == null)
  929.       {if (true) throw new ParseException(
  930.          "Use of AND at the start of a query is not permitted. See line:"+row+", column:"+column);}

  932.     andQuery.add(previousQuery);
  933.     q = QueryPlus();
  934.     // merging all ANDQueries into one
  935.     // i.e. ANDQuery { query1, ANDQuery {query2, query3}}
  936.     // will become ANDQuery {query1, query2, query3}
  937.     if(q instanceof ANDQuery) {
  938.       ANDQuery aq = (ANDQuery) q;
  939.       for(Query qq : aq.getQueries()) {
  940.         andQuery.add(qq);
  941.       }
  942.     } else {
  943.       andQuery.add(q);
  944.     }
  945.     {if (true) return andQuery;}
  946.     throw new Error("Missing return statement in function");
  947.   }

  949. /** 
  950.  * InQuery
  951.  * e.g. Query IN Query
  952.  * In the example above, first "Query" is supplied in the previousQuery parameter.
  953.  * This method starts parsing tokens after the previousQuery has ended.
  954.  * i.e. first character after the previous query must be "IN"
  955.  */
  956.   final public Query InQuery(Query previousQuery) throws ParseException {
  957.   InQuery inQuery = new InQuery();
  958.   Query q;
  959.   Token t;
  960.     t = jj_consume_token(in);
  961.     if(previousQuery instanceof GapQuery)
  962.       {if (true) throw new ParseException("First element cannot be Gap. See line:"+row+", column:"+column);}

  964.     column = t.beginColumn;
  965.     row = t.beginLine;

  967.     if(previousQuery == null)
  968.       {if (true) throw new ParseException(
  969.          "Use of IN at the start of a query is not permitted. See line:"+row+", column:"+column);}

  971.     inQuery.innerQuery = previousQuery;
  972.     q = QueryPlus();
  973.     inQuery.outerQuery = q;
  974.     {if (true) return inQuery;}
  975.     throw new Error("Missing return statement in function");
  976.   }

  978. /** 
  979.  * OverQuery
  980.  * e.g. Query OVER Query
  981.  * In the example above, first "Query" is supplied in the previousQuery parameter.
  982.  * This method starts parsing tokens after the previousQuery has ended.
  983.  * i.e. first character after the previous query must be "OVER"
  984.  */
  985.   final public Query OverQuery(Query previousQuery) throws ParseException {
  986.   OverQuery overQuery = new OverQuery();
  987.   Query q;
  988.   Token t;
  989.     t = jj_consume_token(over);
  990.     if(previousQuery instanceof GapQuery)
  991.       {if (true) throw new ParseException(
  992.         "First element cannot be Gap. See line:"+row+", column:"+column);}

  994.     column = t.beginColumn;
  995.     row = t.beginLine;

  997.     if(previousQuery == null)
  998.       {if (true) throw new ParseException(
  999.          "Use of Over at the start of a query is not permitted. " +
  1000.          "See line:"+row+", column:"+column);}

  1002.     overQuery.overQuery = previousQuery;
  1003.     q = QueryPlus();
  1004.     overQuery.innerQuery = q;
  1005.     {if (true) return overQuery;}
  1006.     throw new Error("Missing return statement in function");
  1007.   }

  1009. /** 
  1010.  * MinusQuery
  1011.  * e.g. Query MINUS Query
  1012.  * In the example above, first "Query" is supplied in the previousQuery parameter.
  1013.  * This method starts parsing tokens after the previousQuery has ended.
  1014.  * i.e. first character after the previous query must be "MINUS" or "-"
  1015.  */
  1016.   final public Query MinusQuery(Query previousQuery) throws ParseException {
  1017.   MinusQuery minusQuery = new MinusQuery();
  1018.   Query q;
  1019.   Token t;
  1020.     t = jj_consume_token(minus);
  1021.     if(previousQuery instanceof GapQuery)
  1022.       {if (true) throw new ParseException(
  1023.         "First element cannot be Gap. See line:"+row+", column:"+column);}

  1025.     column = t.beginColumn;
  1026.     row = t.beginLine;

  1028.     if(previousQuery == null)
  1029.       {if (true) throw new ParseException(
  1030.          "Use of MINUS at the start of a query is not permitted. " +
  1031.          "See line:"+row+", column:"+column);}

  1033.     minusQuery.leftQuery = previousQuery;
  1034.     q = QueryPlus();
  1035.     minusQuery.rightQuery = q;
  1036.     {if (true) return minusQuery;}
  1037.     throw new Error("Missing return statement in function");
  1038.   }

  1040. /** 
  1041.  * KleneQuery
  1042.  * e.g. Query+3, Query+3..5
  1043.  * In all the above examples, "Query" is supplied in the previousQuery parameter.
  1044.  * This method starts parsing tokens after the previousQuery has ended.
  1045.  * i.e. first character after the previous query must be "+"
  1046.  */
  1047.   final public Query KleneQuery(Query previousQuery) throws ParseException {
  1048.   KleneQuery kq = new KleneQuery();
  1049.   Token t;
  1050.   Query q;
  1051.     t = jj_consume_token(plus);
  1052.     if(previousQuery instanceof GapQuery)
  1053.       {if (true) throw new ParseException("First element cannot be Gap." +
  1054.       " See line:"+row+", column:"+column);}

  1056.     column = t.beginColumn;
  1057.     row = t.beginLine;

  1059.     if(previousQuery == null)
  1060.       {if (true) throw new ParseException(
  1061.          "Use of KleneOperator + at the start of a query is not permitted." +
  1062.          " See line:"+row+", column:"+column);}

  1064.     q = previousQuery;
  1065.     kq.query = q;
  1066.     kq.min = 1;
  1067.     kq.max = 1;
  1068.     t = jj_consume_token(number);
  1069.       kq.max = Integer.parseInt(t.image);
  1070.     switch (jj_nt.kind) {
  1071.     case period:
  1072.       jj_consume_token(period);
  1073.       jj_consume_token(period);
  1074.       t = jj_consume_token(number);
  1075.         kq.min = kq.max;
  1076.         kq.max = Integer.parseInt(t.image);
  1077.       break;
  1078.     default:
  1079.       jj_la1[13] = jj_gen;
  1080.       ;
  1081.     }
  1082.    {if (true) return kq;}
  1083.     throw new Error("Missing return statement in function");
  1084.   }

  1086.   final private boolean jj_2_1(int xla) {
  1087.     jj_la = xla; jj_lastpos = jj_scanpos = token;
  1088.     try { return !jj_3_1(); }
  1089.     catch(LookaheadSuccess ls) { return true; }
  1090.     finally { jj_save(0, xla); }
  1091.   }

  1093.   final private boolean jj_2_2(int xla) {
  1094.     jj_la = xla; jj_lastpos = jj_scanpos = token;
  1095.     try { return !jj_3_2(); }
  1096.     catch(LookaheadSuccess ls) { return true; }
  1097.     finally { jj_save(1, xla); }
  1098.   }

  1100.   final private boolean jj_2_3(int xla) {
  1101.     jj_la = xla; jj_lastpos = jj_scanpos = token;
  1102.     try { return !jj_3_3(); }
  1103.     catch(LookaheadSuccess ls) { return true; }
  1104.     finally { jj_save(2, xla); }
  1105.   }

  1107.   final private boolean jj_2_4(int xla) {
  1108.     jj_la = xla; jj_lastpos = jj_scanpos = token;
  1109.     try { return !jj_3_4(); }
  1110.     catch(LookaheadSuccess ls) { return true; }
  1111.     finally { jj_save(3, xla); }
  1112.   }

  1114.   final private boolean jj_2_5(int xla) {
  1115.     jj_la = xla; jj_lastpos = jj_scanpos = token;
  1116.     try { return !jj_3_5(); }
  1117.     catch(LookaheadSuccess ls) { return true; }
  1118.     finally { jj_save(4, xla); }
  1119.   }

  1121.   final private boolean jj_3R_4() {
  1122.     if (jj_scan_token(period)) return true;
  1123.     if (jj_scan_token(regex)) return true;
  1124.     return false;
  1125.   }

  1127.   final private boolean jj_3_2() {
  1128.     if (jj_scan_token(or)) return true;
  1129.     return false;
  1130.   }

  1132.   final private boolean jj_3R_3() {
  1133.     Token xsp;
  1134.     xsp = jj_scanpos;
  1135.     if (jj_scan_token(17)) {
  1136.     jj_scanpos = xsp;
  1137.     if (jj_scan_token(25)) {
  1138.     jj_scanpos = xsp;
  1139.     if (jj_scan_token(27)) {
  1140.     jj_scanpos = xsp;
  1141.     if (jj_scan_token(33)) {
  1142.     jj_scanpos = xsp;
  1143.     if (jj_scan_token(34)) {
  1144.     jj_scanpos = xsp;
  1145.     if (jj_scan_token(38)) {
  1146.     jj_scanpos = xsp;
  1147.     if (jj_scan_token(40)) {
  1148.     jj_scanpos = xsp;
  1149.     if (jj_scan_token(35)) {
  1150.     jj_scanpos = xsp;
  1151.     if (jj_scan_token(36)) {
  1152.     jj_scanpos = xsp;
  1153.     if (jj_scan_token(44)) {
  1154.     jj_scanpos = xsp;
  1155.     if (jj_scan_token(41)) {
  1156.     jj_scanpos = xsp;
  1157.     if (jj_scan_token(39)) {
  1158.     jj_scanpos = xsp;
  1159.     if (jj_3R_5()) return true;
  1160.     }
  1161.     }
  1162.     }
  1163.     }
  1164.     }
  1165.     }
  1166.     }
  1167.     }
  1168.     }
  1169.     }
  1170.     }
  1171.     }
  1172.     return false;
  1173.   }

  1175.   final private boolean jj_3_4() {
  1176.     if (jj_3R_4()) return true;
  1177.     return false;
  1178.   }

  1180.   final private boolean jj_3_5() {
  1181.     if (jj_scan_token(tok)) return true;
  1182.     if (jj_scan_token(colon)) return true;
  1183.     return false;
  1184.   }

  1186.   final private boolean jj_3_3() {
  1187.     if (jj_scan_token(and)) return true;
  1188.     return false;
  1189.   }

  1191.   final private boolean jj_3_1() {
  1192.     if (jj_3R_3()) return true;
  1193.     return false;
  1194.   }

  1196.   final private boolean jj_3R_5() {
  1197.     if (jj_scan_token(number)) return true;
  1198.     return false;
  1199.   }

  1201.   public QueryParserTokenManager token_source;
  1202.   SimpleCharStream jj_input_stream;
  1203.   public Token token, jj_nt;
  1204.   private Token jj_scanpos, jj_lastpos;
  1205.   private int jj_la;
  1206.   public boolean lookingAhead = false;
  1207.   private boolean jj_semLA;
  1208.   private int jj_gen;
  1209.   final private int[] jj_la1 = new int[14];
  1210.   static private int[] jj_la1_0;
  1211.   static private int[] jj_la1_1;
  1212.   static {
  1213.       jj_la1_0();
  1214.       jj_la1_1();
  1215.    }
  1216.    private static void jj_la1_0() {
  1217.       jj_la1_0 = new int[] {0xa060000,0xa060000,0x0,0x20000000,0x0,0x20000000,0x0,0x0,0x41e00000,0x60000,0x41e00000,0x20000,0x40000,0x20000000,};
  1218.    }
  1219.    private static void jj_la1_1() {
  1220.       jj_la1_1 = new int[] {0x13de,0x13c8,0x10,0x0,0x80,0x0,0x1,0x1000,0x0,0x1080,0x0,0x1000,0x1080,0x0,};
  1221.    }
  1222.   final private JJCalls[] jj_2_rtns = new JJCalls[5];
  1223.   private boolean jj_rescan = false;
  1224.   private int jj_gc = 0;

  1226.   public QueryParser(java.io.InputStream stream) {
  1227.      this(stream, null);
  1228.   }
  1229.   public QueryParser(java.io.InputStream stream, String encoding) {
  1230.     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
  1231.     token_source = new QueryParserTokenManager(jj_input_stream);
  1232.     token = new Token();
  1233.     token.next = jj_nt = token_source.getNextToken();
  1234.     jj_gen = 0;
  1235.     for (int i = 0; i < 14; i++) jj_la1[i] = -1;
  1236.     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  1237.   }

  1239.   public void ReInit(java.io.InputStream stream) {
  1240.      ReInit(stream, null);
  1241.   }
  1242.   public void ReInit(java.io.InputStream stream, String encoding) {
  1243.     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
  1244.     token_source.ReInit(jj_input_stream);
  1245.     token = new Token();
  1246.     token.next = jj_nt = token_source.getNextToken();
  1247.     jj_gen = 0;
  1248.     for (int i = 0; i < 14; i++) jj_la1[i] = -1;
  1249.     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  1250.   }

  1252.   public QueryParser(java.io.Reader stream) {
  1253.     jj_input_stream = new SimpleCharStream(stream, 1, 1);
  1254.     token_source = new QueryParserTokenManager(jj_input_stream);
  1255.     token = new Token();
  1256.     token.next = jj_nt = token_source.getNextToken();
  1257.     jj_gen = 0;
  1258.     for (int i = 0; i < 14; i++) jj_la1[i] = -1;
  1259.     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  1260.   }

  1262.   public void ReInit(java.io.Reader stream) {
  1263.     jj_input_stream.ReInit(stream, 1, 1);
  1264.     token_source.ReInit(jj_input_stream);
  1265.     token = new Token();
  1266.     token.next = jj_nt = token_source.getNextToken();
  1267.     jj_gen = 0;
  1268.     for (int i = 0; i < 14; i++) jj_la1[i] = -1;
  1269.     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  1270.   }

  1272.   public QueryParser(QueryParserTokenManager tm) {
  1273.     token_source = tm;
  1274.     token = new Token();
  1275.     token.next = jj_nt = token_source.getNextToken();
  1276.     jj_gen = 0;
  1277.     for (int i = 0; i < 14; i++) jj_la1[i] = -1;
  1278.     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  1279.   }

  1281.   public void ReInit(QueryParserTokenManager tm) {
  1282.     token_source = tm;
  1283.     token = new Token();
  1284.     token.next = jj_nt = token_source.getNextToken();
  1285.     jj_gen = 0;
  1286.     for (int i = 0; i < 14; i++) jj_la1[i] = -1;
  1287.     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  1288.   }

  1290.   final private Token jj_consume_token(int kind) throws ParseException {
  1291.     Token oldToken = token;
  1292.     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
  1293.     else jj_nt = jj_nt.next = token_source.getNextToken();
  1294.     if (token.kind == kind) {
  1295.       jj_gen++;
  1296.       if (++jj_gc > 100) {
  1297.         jj_gc = 0;
  1298.         for (int i = 0; i < jj_2_rtns.length; i++) {
  1299.           JJCalls c = jj_2_rtns[i];
  1300.           while (c != null) {
  1301.             if (c.gen < jj_gen) c.first = null;
  1302.             c = c.next;
  1303.           }
  1304.         }
  1305.       }
  1306.       return token;
  1307.     }
  1308.     jj_nt = token;
  1309.     token = oldToken;
  1310.     jj_kind = kind;
  1311.     throw generateParseException();
  1312.   }

  1314.   static private final class LookaheadSuccess extends java.lang.Error { }
  1315.   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
  1316.   final private boolean jj_scan_token(int kind) {
  1317.     if (jj_scanpos == jj_lastpos) {
  1318.       jj_la--;
  1319.       if (jj_scanpos.next == null) {
  1320.         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
  1321.       } else {
  1322.         jj_lastpos = jj_scanpos = jj_scanpos.next;
  1323.       }
  1324.     } else {
  1325.       jj_scanpos = jj_scanpos.next;
  1326.     }
  1327.     if (jj_rescan) {
  1328.       int i = 0; Token tok = token;
  1329.       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
  1330.       if (tok != null) jj_add_error_token(kind, i);
  1331.     }
  1332.     if (jj_scanpos.kind != kind) return true;
  1333.     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
  1334.     return false;
  1335.   }

  1337.   final public Token getNextToken() {
  1338.     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
  1339.     else jj_nt = jj_nt.next = token_source.getNextToken();
  1340.     jj_gen++;
  1341.     return token;
  1342.   }

  1344.   final public Token getToken(int index) {
  1345.     Token t = lookingAhead ? jj_scanpos : token;
  1346.     for (int i = 0; i < index; i++) {
  1347.       if (t.next != null) t = t.next;
  1348.       else t = t.next = token_source.getNextToken();
  1349.     }
  1350.     return t;
  1351.   }

  1353.   private java.util.Vector jj_expentries = new java.util.Vector();
  1354.   private int[] jj_expentry;
  1355.   private int jj_kind = -1;
  1356.   private int[] jj_lasttokens = new int[100];
  1357.   private int jj_endpos;

  1359.   private void jj_add_error_token(int kind, int pos) {
  1360.     if (pos >= 100) return;
  1361.     if (pos == jj_endpos + 1) {
  1362.       jj_lasttokens[jj_endpos++] = kind;
  1363.     } else if (jj_endpos != 0) {
  1364.       jj_expentry = new int[jj_endpos];
  1365.       for (int i = 0; i < jj_endpos; i++) {
  1366.         jj_expentry[i] = jj_lasttokens[i];
  1367.       }
  1368.       boolean exists = false;
  1369.       for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
  1370.         int[] oldentry = (int[])(e.nextElement());
  1371.         if (oldentry.length == jj_expentry.length) {
  1372.           exists = true;
  1373.           for (int i = 0; i < jj_expentry.length; i++) {
  1374.             if (oldentry[i] != jj_expentry[i]) {
  1375.               exists = false;
  1376.               break;
  1377.             }
  1378.           }
  1379.           if (exists) break;
  1380.         }
  1381.       }
  1382.       if (!exists) jj_expentries.addElement(jj_expentry);
  1383.       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
  1384.     }
  1385.   }

  1387.   public ParseException generateParseException() {
  1388.     jj_expentries.removeAllElements();
  1389.     boolean[] la1tokens = new boolean[47];
  1390.     for (int i = 0; i < 47; i++) {
  1391.       la1tokens[i] = false;
  1392.     }
  1393.     if (jj_kind >= 0) {
  1394.       la1tokens[jj_kind] = true;
  1395.       jj_kind = -1;
  1396.     }
  1397.     for (int i = 0; i < 14; i++) {
  1398.       if (jj_la1[i] == jj_gen) {
  1399.         for (int j = 0; j < 32; j++) {
  1400.           if ((jj_la1_0[i] & (1<<j)) != 0) {
  1401.             la1tokens[j] = true;
  1402.           }
  1403.           if ((jj_la1_1[i] & (1<<j)) != 0) {
  1404.             la1tokens[32+j] = true;
  1405.           }
  1406.         }
  1407.       }
  1408.     }
  1409.     for (int i = 0; i < 47; i++) {
  1410.       if (la1tokens[i]) {
  1411.         jj_expentry = new int[1];
  1412.         jj_expentry[0] = i;
  1413.         jj_expentries.addElement(jj_expentry);
  1414.       }
  1415.     }
  1416.     jj_endpos = 0;
  1417.     jj_rescan_token();
  1418.     jj_add_error_token(0, 0);
  1419.     int[][] exptokseq = new int[jj_expentries.size()][];
  1420.     for (int i = 0; i < jj_expentries.size(); i++) {
  1421.       exptokseq[i] = (int[])jj_expentries.elementAt(i);
  1422.     }
  1423.     return new ParseException(token, exptokseq, tokenImage);
  1424.   }

  1426.   final public void enable_tracing() {
  1427.   }

  1429.   final public void disable_tracing() {
  1430.   }

  1432.   final private void jj_rescan_token() {
  1433.     jj_rescan = true;
  1434.     for (int i = 0; i < 5; i++) {
  1435.     try {
  1436.       JJCalls p = jj_2_rtns[i];
  1437.       do {
  1438.         if (p.gen > jj_gen) {
  1439.           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
  1440.           switch (i) {
  1441.             case 0: jj_3_1(); break;
  1442.             case 1: jj_3_2(); break;
  1443.             case 2: jj_3_3(); break;
  1444.             case 3: jj_3_4(); break;
  1445.             case 4: jj_3_5(); break;
  1446.           }
  1447.         }
  1448.         p = p.next;
  1449.       } while (p != null);
  1450.       } catch(LookaheadSuccess ls) { }
  1451.     }
  1452.     jj_rescan = false;
  1453.   }

  1455.   final private void jj_save(int index, int xla) {
  1456.     JJCalls p = jj_2_rtns[index];
  1457.     while (p.gen > jj_gen) {
  1458.       if (p.next == null) { p = p.next = new JJCalls(); break; }
  1459.       p = p.next;
  1460.     }
  1461.     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
  1462.   }

  1464.   static final class JJCalls {
  1465.     int gen;
  1466.     Token first;
  1467.     int arg;
  1468.     JJCalls next;
  1469.   }

  1471. }
Created with JaCoCo 0.8.5.201910111838