if (lowercaseExpandedTerms) {      termStr = termStr.toLowerCase();    }    Term t = new Term(field, termStr);    return newWildcardQuery(t);  }  /**   * Factory method for generating a query (similar to   * {@link #getWildcardQuery}). Called when parser parses an input term   * token that uses prefix notation; that is, contains a single '*' wildcard   * character as its last character. Since this is a special case   * of generic wildcard term, and such a query can be optimized easily,   * this usually results in a different query object.   *<p>   * Depending on settings, a prefix term may be lower-cased   * automatically. It will not go through the default Analyzer,   * however, since normal Analyzers are unlikely to work properly   * with wildcard templates.   *<p>   * Can be overridden by extending classes, to provide custom handling for   * wild card queries, which may be necessary due to missing analyzer calls.   *   * @param field Name of the field query will use.   * @param termStr Term token to use for building term for the query   *    (<b>without</b> trailing '*' character!)   *   * @return Resulting {@link Query} built for the term   * @exception ParseException throw in overridden method to disallow   */  protected Query getPrefixQuery(String field, String termStr) throws ParseException  {    if (!allowLeadingWildcard && termStr.startsWith("*"))      throw new ParseException("'*' not allowed as first character in PrefixQuery");    if (lowercaseExpandedTerms) {      termStr = termStr.toLowerCase();    }    Term t = new Term(field, termStr);    return newPrefixQuery(t);  }   /**   * Factory method for generating a query (similar to   * {@link #getWildcardQuery}). Called when parser parses   * an input term token that has the fuzzy suffix (~) appended.   *   * @param field Name of the field query will use.   * @param termStr Term token to use for building term for the query   *   * @return Resulting {@link Query} built for the term   * @exception ParseException throw in overridden method to disallow   */  protected Query getFuzzyQuery(String field, String termStr, float minSimilarity) throws ParseException  {    if (lowercaseExpandedTerms) {      termStr = termStr.toLowerCase();    }    Term t = new Term(field, termStr);    return newFuzzyQuery(t, minSimilarity, fuzzyPrefixLength);  }  /**   * Returns a String where the escape char has been   * removed, or kept only once if there was a double escape.   *    * Supports escaped unicode characters, e. g. translates   * <code>\\u0041</code> to <code>A</code>.   *    */  private String discardEscapeChar(String input) throws ParseException {    // Create char array to hold unescaped char sequence    char[] output = new char[input.length()];    // The length of the output can be less than the input    // due to discarded escape chars. This variable holds    // the actual length of the output    int length = 0;    // We remember whether the last processed character was     // an escape character    boolean lastCharWasEscapeChar = false;    // The multiplier the current unicode digit must be multiplied with.    // E. g. the first digit must be multiplied with 16^3, the second with 16^2...    int codePointMultiplier = 0;    // Used to calculate the codepoint of the escaped unicode character    int codePoint = 0;    for (int i = 0; i < input.length(); i++) {      char curChar = input.charAt(i);      if (codePointMultiplier > 0) {        codePoint += hexToInt(curChar) * codePointMultiplier;        codePointMultiplier >>>= 4;        if (codePointMultiplier == 0) {          output[length++] = (char)codePoint;          codePoint = 0;        }      } else if (lastCharWasEscapeChar) {        if (curChar == 'u') {          // found an escaped unicode character          codePointMultiplier = 16 * 16 * 16;        } else {          // this character was escaped          output[length] = curChar;          length++;        }        lastCharWasEscapeChar = false;      } else {        if (curChar == '\\') {          lastCharWasEscapeChar = true;        } else {          output[length] = curChar;          length++;        }      }    }    if (codePointMultiplier > 0) {      throw new ParseException("Truncated unicode escape sequence.");    }    if (lastCharWasEscapeChar) {      throw new ParseException("Term can not end with escape character.");    }    return new String(output, 0, length);  }  /** Returns the numeric value of the hexadecimal character */  private static final int hexToInt(char c) throws ParseException {    if ('0' <= c && c <= '9') {      return c - '0';    } else if ('a' <= c && c <= 'f'){      return c - 'a' + 10;    } else if ('A' <= c && c <= 'F') {      return c - 'A' + 10;    } else {      throw new ParseException("None-hex character in unicode escape sequence: " + c);    }  }  /**   * Returns a String where those characters that QueryParser   * expects to be escaped are escaped by a preceding <code>\</code>.   */  public static String escape(String s) {    StringBuffer sb = new StringBuffer();    for (int i = 0; i < s.length(); i++) {      char c = s.charAt(i);      // These characters are part of the query syntax and must be escaped      if (c == '\\' || c == '+' || c == '-' || c == '!' || c == '(' || c == ')' || c == ':'        || c == '^' || c == '[' || c == ']' || c == '\"' || c == '{' || c == '}' || c == '~'        || c == '*' || c == '?' || c == '|' || c == '&') {        sb.append('\\');      }      sb.append(c);    }    return sb.toString();  }  /**   * Command line tool to test QueryParser, using {@link org.apache.lucene.analysis.SimpleAnalyzer}.   * Usage:<br>   * <code>java org.apache.lucene.queryParser.QueryParser &lt;input&gt;</code>   */  public static void main(String[] args) throws Exception {    if (args.length == 0) {      System.out.println("Usage: java org.apache.lucene.queryParser.QueryParser <input>");      System.exit(0);    }    QueryParser qp = new QueryParser("field",                           new org.apache.lucene.analysis.SimpleAnalyzer());    Query q = qp.parse(args[0]);    System.out.println(q.toString("field"));  }// *   Query  ::= ( Clause )*// *   Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")" )  final public int Conjunction() throws ParseException {  int ret = CONJ_NONE;    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {    case AND:    case OR:      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {      case AND:        jj_consume_token(AND);            ret = CONJ_AND;        break;      case OR:        jj_consume_token(OR);              ret = CONJ_OR;        break;      default:        jj_la1[0] = jj_gen;        jj_consume_token(-1);        throw new ParseException();      }      break;    default:      jj_la1[1] = jj_gen;      ;    }    {if (true) return ret;}    throw new Error("Missing return statement in function");  }  final public int Modifiers() throws ParseException {  int ret = MOD_NONE;    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {    case NOT:    case PLUS:    case MINUS:      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {      case PLUS:        jj_consume_token(PLUS);              ret = MOD_REQ;        break;      case MINUS:        jj_consume_token(MINUS);                 ret = MOD_NOT;        break;      case NOT:        jj_consume_token(NOT);               ret = MOD_NOT;        break;      default:        jj_la1[2] = jj_gen;        jj_consume_token(-1);        throw new ParseException();      }      break;    default:      jj_la1[3] = jj_gen;      ;    }    {if (true) return ret;}    throw new Error("Missing return statement in function");  }// This makes sure that there is no garbage after the query string  final public Query TopLevelQuery(String field) throws ParseException {        Query q;    q = Query(field);    jj_consume_token(0);                {if (true) return q;}    throw new Error("Missing return statement in function");  }  final public Query Query(String field) throws ParseException {  List clauses = new ArrayList();  Query q, firstQuery=null;  int conj, mods;    mods = Modifiers();    q = Clause(field);    addClause(clauses, CONJ_NONE, mods, q);    if (mods == MOD_NONE)        firstQuery=q;    label_1:    while (true) {      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {      case AND:      case OR:      case NOT:      case PLUS:      case MINUS:      case LPAREN:      case STAR:      case QUOTED:      case TERM:      case PREFIXTERM:      case WILDTERM:      case RANGEIN_START:      case RANGEEX_START:      case NUMBER:        ;        break;      default:        jj_la1[4] = jj_gen;        break label_1;      }      conj = Conjunction();      mods = Modifiers();      q = Clause(field);      addClause(clauses, conj, mods, q);    }      if (clauses.size() == 1 && firstQuery != null)        {if (true) return firstQuery;}      else {  {if (true) return getBooleanQuery(clauses);}      }    throw new Error("Missing return statement in function");  }  final public Query Clause(String field) throws ParseException {  Query q;  Token fieldToken=null, boost=null;    if (jj_2_1(2)) {      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {      case TERM:        fieldToken = jj_consume_token(TERM);        jj_consume_token(COLON);                               field=discardEscapeChar(fieldToken.image);        break;      case STAR:        jj_consume_token(STAR);        jj_consume_token(COLON);                      field="*";        break;      default:        jj_la1[5] = jj_gen;        jj_consume_token(-1);        throw new ParseException();      }    } else {      ;    }    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {    case STAR:    case QUOTED:    case TERM:    case PREFIXTERM:    case WILDTERM:    case RANGEIN_START:    case RANGEEX_START:    case NUMBER:      q = Term(field);      break;    case LPAREN:      jj_consume_token(LPAREN);      q = Query(field);      jj_consume_token(RPAREN);      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {      case CARAT:        jj_consume_token(CARAT);        boost = jj_consume_token(NUMBER);        break;      default:        jj_la1[6] = jj_gen;        ;      }      break;    default:      jj_la1[7] = jj_gen;      jj_consume_token(-1);      throw new ParseException();    }      if (boost != null) {        float f = (float)1.0;  try {    f = Float.valueOf(boost.image).floatValue();          q.setBoost(f);  } catch (Exception ignored) { }      }      {if (true) return q;}    throw new Error("Missing return statement in function");  }  final public Query Term(String field) throws ParseException {  Token term, boost=null, fuzzySlop=null, goop1, goop2;  boolean prefix = false;  boolean wildcard = false;  boolean fuzzy = false;  boolean rangein = false;  Query q;    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {    case STAR:    case TERM:    case PREFIXTERM:    case WILDTERM:    case NUMBER:      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {      case TERM:        term = jj_consume_token(TERM);        break;      case STAR:        term = jj_consume_token(STAR);                       wildcard=true;        break;      case PREFIXTERM:        term = jj_consume_token(PREFIXTERM);                             prefix=true;        break;      case WILDTERM:        term = jj_consume_token(WILDTERM);                           wildcard=true;        break;      case NUMBER:        term = jj_consume_token(NUMBER);        break;      default:        jj_la1[8] = jj_gen;        jj_consume_token(-1);        throw new ParseException();      }      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {      case FUZZY_SLOP:        fuzzySlop = jj_consume_token(FUZZY_SLOP);                                fuzzy=true;        break;      default:        jj_la1[9] = jj_gen;        ;      }      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {      case CARAT:        jj_consume_token(CARAT);        boost = jj_consume_token(NUMBER);        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {        case FUZZY_SLOP:          fuzzySlop = jj_consume_token(FUZZY_SLOP);                                                         fuzzy=true;          break;        default:          jj_la1[10] = jj_gen;          ;        }        break;      default:        jj_la1[11] = jj_gen;        ;      }       String termImage=discardEscapeChar(term.image);       if (wildcard) {       q = getWildcardQuery(field, termImage);       } else if (prefix) {         q = getPrefixQuery(field,           discardEscapeChar(term.image.substring          (0, term.image.length()-1)));       } else if (fuzzy) {          float fms = fuzzyMinSim;          try {            fms = Float.valueOf(fuzzySlop.image.substring(1)).floatValue();          } catch (Exception ignored) { }         if(fms < 0.0f || fms > 1.0f){           {if (true) throw new ParseException("Minimum similarity for a FuzzyQuery has to be between 0.0f and 1.0f !");}         }         q = getFuzzyQuery(field, termImage,fms);       } else {         q = getFieldQuery(field, termImage);       }      break;