it = listOfProcessors.listIterator();
+ while (it.hasNext()) {
+ newPipeline.add(it.next());
+ }
+ this.setQueryNodeProcessor(newPipeline);
+
+
+ QueryBuilder newBuilder = builder.getClass().newInstance();
+ if (newBuilder instanceof AqpQueryTreeBuilder) {
+ ((AqpQueryTreeBuilder) newBuilder).setDebug(debug);
+ this.setQueryBuilder(newBuilder);
+ }
+
+ }
+ debugMode = debug;
+ }
+
+ public boolean getDebug() {
+ return debugMode;
+ }
+
+ /**
+ * Overrides {@link QueryParserHelper#parse(String, String)} so it casts the
+ * return object to {@link Query}. For more reference about this method, check
+ * {@link QueryParserHelper#parse(String, String)}.
+ *
+ * @param query
+ * the query string
+ * @param defaultField
+ * the default field used by the text parser
+ *
+ * @return the object built from the query
+ *
+ * @throws QueryNodeException
+ * if something wrong happens along the three phases
+ */
+ @Override
+ public Query parse(String query, String defaultField)
+ throws QueryNodeException {
+
+ if (defaultField != null) {
+ setDefaultField(defaultField);
+ }
+ try {
+ return (Query) super.parse(query, defaultField);
+ } catch (NestedParseException e) {
+ throw new QueryNodeException(e);
+ }
+
+ }
+
+ public String getDefaultField() {
+ return getQueryConfigHandler().get(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.DEFAULT_FIELD);
+ }
+
+ public void setDefaultField(String field) {
+ getQueryConfigHandler().set(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.DEFAULT_FIELD, field);
+ }
+
+ public Integer getDefaultProximity() {
+ return getQueryConfigHandler().get(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.DEFAULT_PROXIMITY);
+ }
+
+ public void setDefaultProximity(Integer value) {
+ getQueryConfigHandler().set(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.DEFAULT_PROXIMITY,
+ value);
+ }
+
+ public Float getImplicitBoost() {
+ return getQueryConfigHandler().get(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_BOOST);
+ }
+
+ public void setImplicitBoost(Float value) {
+ getQueryConfigHandler().set(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_BOOST, value);
+ }
+
+ public AqpFeedback getFeedback() {
+ return getQueryConfigHandler().get(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.FEEDBACK);
+ }
+
+ public void setFeedback(AqpFeedback feedbackInstance) {
+ getQueryConfigHandler().set(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.FEEDBACK,
+ feedbackInstance);
+ }
+
+ public Float getImplicitFuzzy() {
+ return getQueryConfigHandler().get(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_FUZZY);
+ }
+
+ public void setImplicitFuzzy(Float value) {
+ getQueryConfigHandler().set(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_FUZZY, value);
+ }
+
+ public Boolean getAllowSlowFuzzy() {
+ return getQueryConfigHandler().get(
+ AqpStandardQueryConfigHandler.ConfigurationKeys.ALLOW_SLOW_FUZZY);
+ }
+
+ public void setAllowSlowFuzzy(Boolean value) {
+ getQueryConfigHandler()
+ .set(AqpStandardQueryConfigHandler.ConfigurationKeys.ALLOW_SLOW_FUZZY,
+ value);
+ }
+
+ /********************************************************************
+ * Everything below is simpy copy of the StandardQueryParser *
+ *******************************************************************/
+
+ /**
+ * Gets implicit operator setting, which will be either {@link Operator#AND}
+ * or {@link Operator#OR}.
+ */
+ public StandardQueryConfigHandler.Operator getDefaultOperator() {
+ return getQueryConfigHandler().get(ConfigurationKeys.DEFAULT_OPERATOR);
+
+ }
+
+ /**
+ * Sets the boolean operator of the QueryParser. In default mode (
+ * {@link Operator#OR}) terms without any modifiers are considered optional:
+ * for example capital of Hungary is equal to
+ * capital OR of OR Hungary.
+ * In {@link Operator#AND} mode terms are considered to be in conjunction: the
+ * above mentioned query is parsed as capital AND of AND Hungary
+ */
+ public void setDefaultOperator(StandardQueryConfigHandler.Operator operator) {
+ getQueryConfigHandler().set(ConfigurationKeys.DEFAULT_OPERATOR, operator);
+ }
+
+ /**
+ * Set to true to allow leading wildcard characters.
+ *
+ * When set, * or ? are allowed as the first
+ * character of a PrefixQuery and WildcardQuery. Note that this can produce
+ * very slow queries on big indexes.
+ *
+ * Default: false.
+ */
+ public void setLowercaseExpandedTerms(boolean lowercaseExpandedTerms) {
+ getQueryConfigHandler().set(ConfigurationKeys.LOWERCASE_EXPANDED_TERMS,
+ lowercaseExpandedTerms);
+ }
+
+ /**
+ * @see #setLowercaseExpandedTerms(boolean)
+ */
+ public boolean getLowercaseExpandedTerms() {
+ Boolean lowercaseExpandedTerms = getQueryConfigHandler().get(
+ ConfigurationKeys.LOWERCASE_EXPANDED_TERMS);
+
+ if (lowercaseExpandedTerms == null) {
+ return true;
+
+ } else {
+ return lowercaseExpandedTerms;
+ }
+
+ }
+
+ /**
+ * Set to true to allow leading wildcard characters.
+ *
+ * When set, * or ? are allowed as the first
+ * character of a PrefixQuery and WildcardQuery. Note that this can produce
+ * very slow queries on big indexes.
+ *
+ * Default: false.
+ */
+ public void setAllowLeadingWildcard(boolean allowLeadingWildcard) {
+ getQueryConfigHandler().set(ConfigurationKeys.ALLOW_LEADING_WILDCARD,
+ allowLeadingWildcard);
+ }
+
+ /**
+ * Set to true to enable position increments in result query.
+ *
+ * When set, result phrase and multi-phrase queries will be aware of position
+ * increments. Useful when e.g. a StopFilter increases the position increment
+ * of the token that follows an omitted token.
+ *
+ * Default: false.
+ */
+ public void setEnablePositionIncrements(boolean enabled) {
+ getQueryConfigHandler().set(ConfigurationKeys.ENABLE_POSITION_INCREMENTS,
+ enabled);
+ }
+
+ /**
+ * @see #setEnablePositionIncrements(boolean)
+ */
+ public boolean getEnablePositionIncrements() {
+ Boolean enablePositionsIncrements = getQueryConfigHandler().get(
+ ConfigurationKeys.ENABLE_POSITION_INCREMENTS);
+
+ if (enablePositionsIncrements == null) {
+ return false;
+
+ } else {
+ return enablePositionsIncrements;
+ }
+
+ }
+
+ /**
+ * By default, it uses
+ * {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} when creating a
+ * prefix, wildcard and range queries. This implementation is generally
+ * preferable because it a) Runs faster b) Does not have the scarcity of terms
+ * unduly influence score c) avoids any {@link TooManyListenersException}
+ * exception. However, if your application really needs to use the
+ * old-fashioned boolean queries expansion rewriting and the above points are
+ * not relevant then use this change the rewrite method.
+ */
+ public void setMultiTermRewriteMethod(MultiTermQuery.RewriteMethod method) {
+ getQueryConfigHandler().set(ConfigurationKeys.MULTI_TERM_REWRITE_METHOD,
+ method);
+ }
+
+ /**
+ * @see #setMultiTermRewriteMethod(org.apache.lucene.search.MultiTermQuery.RewriteMethod)
+ */
+ public MultiTermQuery.RewriteMethod getMultiTermRewriteMethod() {
+ return getQueryConfigHandler().get(
+ ConfigurationKeys.MULTI_TERM_REWRITE_METHOD);
+ }
+
+ /**
+ * Set the fields a query should be expanded to when the field is
+ * null
+ *
+ * @param fields
+ * the fields used to expand the query
+ */
+ public void setMultiFields(CharSequence[] fields) {
+
+ if (fields == null) {
+ fields = new CharSequence[0];
+ }
+
+ getQueryConfigHandler().set(ConfigurationKeys.MULTI_FIELDS, fields);
+
+ }
+
+ /**
+ * Returns the fields used to expand the query when the field for a certain
+ * query is null
+ *
+ * @param fields
+ * the fields used to expand the query
+ */
+ public void getMultiFields(CharSequence[] fields) {
+ getQueryConfigHandler().get(ConfigurationKeys.MULTI_FIELDS);
+ }
+
+ /**
+ * Set the prefix length for fuzzy queries. Default is 0.
+ *
+ * @param fuzzyPrefixLength
+ * The fuzzyPrefixLength to set.
+ */
+ public void setFuzzyPrefixLength(int fuzzyPrefixLength) {
+ QueryConfigHandler config = getQueryConfigHandler();
+ FuzzyConfig fuzzyConfig = config.get(ConfigurationKeys.FUZZY_CONFIG);
+
+ if (fuzzyConfig == null) {
+ fuzzyConfig = new FuzzyConfig();
+ config.set(ConfigurationKeys.FUZZY_CONFIG, fuzzyConfig);
+ }
+
+ fuzzyConfig.setPrefixLength(fuzzyPrefixLength);
+
+ }
+
+ public void setNumericConfigMap(Map numericConfigMap) {
+ getQueryConfigHandler().set(ConfigurationKeys.NUMERIC_CONFIG_MAP,
+ numericConfigMap);
+ }
+
+ public Map getNumericConfigMap() {
+ return getQueryConfigHandler().get(ConfigurationKeys.NUMERIC_CONFIG_MAP);
+ }
+
+ /**
+ * Set locale used by date range parsing.
+ */
+ public void setLocale(Locale locale) {
+ getQueryConfigHandler().set(ConfigurationKeys.LOCALE, locale);
+ }
+
+ /**
+ * Returns current locale, allowing access by subclasses.
+ */
+ public Locale getLocale() {
+ return getQueryConfigHandler().get(ConfigurationKeys.LOCALE);
+ }
+
+ /**
+ * Sets the default slop for phrases. If zero, then exact phrase matches are
+ * required. Default value is zero.
+ *
+ * @deprecated renamed to {@link #setPhraseSlop(int)}
+ */
+ @Deprecated
+ public void setDefaultPhraseSlop(int defaultPhraseSlop) {
+ getQueryConfigHandler().set(ConfigurationKeys.PHRASE_SLOP,
+ defaultPhraseSlop);
+ }
+
+ /**
+ * Sets the default slop for phrases. If zero, then exact phrase matches are
+ * required. Default value is zero.
+ */
+ public void setPhraseSlop(int defaultPhraseSlop) {
+ getQueryConfigHandler().set(ConfigurationKeys.PHRASE_SLOP,
+ defaultPhraseSlop);
+ }
+
+ public void setAnalyzer(Analyzer analyzer) {
+ getQueryConfigHandler().set(ConfigurationKeys.ANALYZER, analyzer);
+ }
+
+ public Analyzer getAnalyzer() {
+ return getQueryConfigHandler().get(ConfigurationKeys.ANALYZER);
+ }
+
+ /**
+ * @see #setAllowLeadingWildcard(boolean)
+ */
+ public boolean getAllowLeadingWildcard() {
+ Boolean allowLeadingWildcard = getQueryConfigHandler().get(
+ ConfigurationKeys.ALLOW_LEADING_WILDCARD);
+
+ if (allowLeadingWildcard == null) {
+ return false;
+
+ } else {
+ return allowLeadingWildcard;
+ }
+ }
+
+ /**
+ * Get the minimal similarity for fuzzy queries.
+ */
+ public float getFuzzyMinSim() {
+ FuzzyConfig fuzzyConfig = getQueryConfigHandler().get(
+ ConfigurationKeys.FUZZY_CONFIG);
+
+ if (fuzzyConfig == null) {
+ return FuzzyQuery.defaultMinSimilarity;
+ } else {
+ return fuzzyConfig.getMinSimilarity();
+ }
+ }
+
+ /**
+ * Get the prefix length for fuzzy queries.
+ *
+ * @return Returns the fuzzyPrefixLength.
+ */
+ public int getFuzzyPrefixLength() {
+ FuzzyConfig fuzzyConfig = getQueryConfigHandler().get(
+ ConfigurationKeys.FUZZY_CONFIG);
+
+ if (fuzzyConfig == null) {
+ return FuzzyQuery.defaultPrefixLength;
+ } else {
+ return fuzzyConfig.getPrefixLength();
+ }
+ }
+
+ /**
+ * Gets the default slop for phrases.
+ */
+ public int getPhraseSlop() {
+ Integer phraseSlop = getQueryConfigHandler().get(
+ ConfigurationKeys.PHRASE_SLOP);
+
+ if (phraseSlop == null) {
+ return 0;
+
+ } else {
+ return phraseSlop;
+ }
+ }
+
+ /**
+ * Set the minimum similarity for fuzzy queries. Default is defined on
+ * {@link FuzzyQuery#defaultMinSimilarity}.
+ */
+ public void setFuzzyMinSim(float fuzzyMinSim) {
+ QueryConfigHandler config = getQueryConfigHandler();
+ FuzzyConfig fuzzyConfig = config.get(ConfigurationKeys.FUZZY_CONFIG);
+
+ if (fuzzyConfig == null) {
+ fuzzyConfig = new FuzzyConfig();
+ config.set(ConfigurationKeys.FUZZY_CONFIG, fuzzyConfig);
+ }
+
+ fuzzyConfig.setMinSimilarity(fuzzyMinSim);
+ }
+
+ /**
+ * Sets the boost used for each field.
+ *
+ * @param boosts
+ * a collection that maps a field to its boost
+ */
+ public void setFieldsBoost(Map boosts) {
+ getQueryConfigHandler().set(ConfigurationKeys.FIELD_BOOST_MAP, boosts);
+ }
+
+ /**
+ * Returns the field to boost map used to set boost for each field.
+ *
+ * @return the field to boost map
+ */
+ public Map getFieldsBoost() {
+ return getQueryConfigHandler().get(ConfigurationKeys.FIELD_BOOST_MAP);
+ }
+
+ /**
+ * Sets the default {@link Resolution} used for certain field when no
+ * {@link Resolution} is defined for this field.
+ *
+ * @param dateResolution
+ * the default {@link Resolution}
+ */
+ public void setDateResolution(DateTools.Resolution dateResolution) {
+ getQueryConfigHandler().set(ConfigurationKeys.DATE_RESOLUTION,
+ dateResolution);
+ }
+
+ /**
+ * Returns the default {@link Resolution} used for certain field when no
+ * {@link Resolution} is defined for this field.
+ *
+ * @return the default {@link Resolution}
+ */
+ public DateTools.Resolution getDateResolution() {
+ return getQueryConfigHandler().get(ConfigurationKeys.DATE_RESOLUTION);
+ }
+
+ /**
+ * Sets the {@link Resolution} used for each field
+ *
+ * @param dateRes
+ * a collection that maps a field to its {@link Resolution}
+ *
+ * @deprecated this method was renamed to {@link #setDateResolutionMap(Map)}
+ */
+ @Deprecated
+ public void setDateResolution(Map dateRes) {
+ setDateResolutionMap(dateRes);
+ }
+
+ /**
+ * Returns the field to {@link Resolution} map used to normalize each date
+ * field.
+ *
+ * @return the field to {@link Resolution} map
+ */
+ public Map getDateResolutionMap() {
+ return getQueryConfigHandler().get(
+ ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP);
+ }
+
+ /**
+ * Sets the {@link Resolution} used for each field
+ *
+ * @param dateRes
+ * a collection that maps a field to its {@link Resolution}
+ */
+ public void setDateResolutionMap(
+ Map dateRes) {
+ getQueryConfigHandler().set(ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP,
+ dateRes);
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParser.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParser.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParser.java (revision 0)
@@ -0,0 +1,40 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+import org.antlr.runtime.TokenStream;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeParseException;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.parser.SyntaxParser;
+
+public interface AqpSyntaxParser extends SyntaxParser {
+ /**
+ * @param grammarName
+ * - the name of the query
+ * @throws Exception
+ * - there are different implementations (should we want different
+ * interfaces?) some may be loading grammars on the fly, others will
+ * load grammars directly
+ *
+ * @return AqpSyntaxParser
+ */
+ public AqpSyntaxParser initializeGrammar(String grammarName)
+ throws QueryNodeParseException;
+
+ /**
+ * This method should return the stream of tokens, it can be used to modify
+ * the original query before it gets executed
+ *
+ * @param input
+ * - original query
+ * @return TokenStream
+ * - (un)modified stream of tokens
+ * @throws QueryNodeParseException
+ */
+ public TokenStream getTokenStream(CharSequence input)
+ throws QueryNodeParseException;
+
+ public QueryNode parseTokenStream(TokenStream tokens, CharSequence query,
+ CharSequence field) throws QueryNodeParseException;
+
+ public QueryNode parse(CharSequence query, CharSequence field)
+ throws QueryNodeParseException;
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEventHandler.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEventHandler.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEventHandler.java (revision 0)
@@ -0,0 +1,21 @@
+package org.apache.lucene.queryparser.flexible.aqp.config;
+
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedbackEvent;
+
+public interface AqpFeedbackEventHandler {
+
+ public enum ACTION {
+ STOP, SAVE_EVENT
+ };
+
+ /**
+ * Handles the {@link AqpFeedbackEvent}
+ *
+ * If it returns false, the next registered event handler will not get a
+ * chance to handle the event.
+ *
+ * @param event
+ * @return
+ */
+ public ACTION handle(AqpFeedbackEvent event);
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedback.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedback.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedback.java (revision 0)
@@ -0,0 +1,48 @@
+package org.apache.lucene.queryparser.flexible.aqp.config;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.util.Attribute;
+
+/**
+ * This attribute is used to collect feedback messages and suggestions from the
+ * query parser
+ *
+ * WARNING: experimental, may change soon!
+ */
+public interface AqpFeedback extends Attribute {
+
+ public enum TYPE {
+ DEBUG, INFO, WARN, ERROR, SYNTAX_SUGGESTION, DEPRECATED
+ };
+
+ /*
+ * I am NOT trying to re-implement a wheel, I am just confused what is the
+ * proper way to wrap SLF4J used by SOLR (but not by Lucene) and not introduce
+ * it as a dependency to Lucene
+ */
+ public AqpFeedbackEvent createEvent(TYPE level,
+ Class qnClass, QueryNode node, String msg,
+ Object... args);
+
+ public void sendEvent(AqpFeedbackEvent event);
+
+ public void registerEventHandler(AqpFeedbackEventHandler handler);
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackImpl.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackImpl.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackImpl.java (revision 0)
@@ -0,0 +1,68 @@
+package org.apache.lucene.queryparser.flexible.aqp.config;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.util.AttributeImpl;
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedbackEventHandler.ACTION;
+
+public class AqpFeedbackImpl extends AttributeImpl implements AqpFeedback {
+
+ private static final long serialVersionUID = 5178148416076100953L;
+
+ private List events = new ArrayList();
+ private List handlers = new ArrayList();
+
+ @Override
+ public void clear() {
+ events.clear();
+ }
+
+ @Override
+ public void copyTo(AttributeImpl target) {
+ throw new UnsupportedOperationException();
+ }
+
+ public void registerEventHandler(AqpFeedbackEventHandler handler) {
+ handlers.add(handler);
+ }
+
+ public AqpFeedbackEvent createEvent(TYPE level,
+ Class qnClass, QueryNode node, String msg,
+ Object... args) {
+ return new AqpFeedbackEventImpl(level, qnClass, node, msg, args);
+ }
+
+ public void sendEvent(AqpFeedbackEvent event) {
+ for (AqpFeedbackEventHandler handler : handlers) {
+ ACTION r = handler.handle(event);
+ if (r == ACTION.STOP) {
+ return;
+ } else if (r == ACTION.SAVE_EVENT) {
+ if (!events.contains(event)) {
+ events.add(event);
+ }
+ }
+ }
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEvent.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEvent.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEvent.java (revision 0)
@@ -0,0 +1,19 @@
+package org.apache.lucene.queryparser.flexible.aqp.config;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.util.Attribute;
+
+public interface AqpFeedbackEvent extends Attribute {
+
+ public AqpFeedback.TYPE getType();
+
+ public Class getCaller();
+
+ public QueryNode getNode();
+
+ public String getMessage();
+
+ public Object[] getArgs();
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEventImpl.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEventImpl.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/config/AqpFeedbackEventImpl.java (revision 0)
@@ -0,0 +1,46 @@
+package org.apache.lucene.queryparser.flexible.aqp.config;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedback.TYPE;
+
+public class AqpFeedbackEventImpl implements AqpFeedbackEvent {
+
+ private AqpFeedback.TYPE type = null;
+ private Class caller = null;
+ private QueryNode node = null;
+ private String message = null;
+ private Object[] args = null;
+
+ AqpFeedbackEventImpl(AqpFeedback.TYPE type,
+ Class processorClass, QueryNode node,
+ String message, Object... args) {
+
+ this.type = type;
+ this.caller = processorClass;
+ this.node = node;
+ this.message = message;
+ this.args = args;
+
+ }
+
+ public TYPE getType() {
+ return type;
+ }
+
+ public Class getCaller() {
+ return caller;
+ }
+
+ public QueryNode getNode() {
+ return node;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+
+ public Object[] getArgs() {
+ return args;
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/SlowFuzzyQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/SlowFuzzyQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/SlowFuzzyQueryNode.java (revision 0)
@@ -0,0 +1,18 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.FuzzyQueryNode;
+
+/**
+ * Exactly the same as FuzzyQueryNode but it will be transformed into a
+ * SlowFuzzyQuery
+ *
+ *
+ */
+public class SlowFuzzyQueryNode extends FuzzyQueryNode {
+
+ public SlowFuzzyQueryNode(CharSequence field, CharSequence term,
+ float minSimilarity, int begin, int end) {
+ super(field, term, minSimilarity, begin, end);
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpANTLRNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpANTLRNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpANTLRNode.java (revision 0)
@@ -0,0 +1,249 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.antlr.runtime.CommonToken;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNodeImpl;
+import org.apache.lucene.queryparser.flexible.core.parser.EscapeQuerySyntax;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpCommonTree;
+
+/**
+ * When Aqp parser starts processing the AST (abstract syntax tree)
+ * every node in the tree is made of {@link AqpANTLRNode} and it wraps
+ * the {@link AqpCommonTree} through which you can access information
+ * about the string, its position, type etc... these are courtesy of
+ * ANTLR.
+ *
+ * We provide a few utility methods for setting different attributes
+ * of the original ANTLR object.
+ *
+ */
+public class AqpANTLRNode extends QueryNodeImpl {
+
+ private static final long serialVersionUID = 5128762709928473351L;
+
+ private AqpCommonTree tree;
+
+ private int tokenType;
+
+ private String tokenLabel;
+
+ private String tokenName;
+
+ private String tokenInput = null;
+
+ /**
+ * @param node
+ * - AST node
+ */
+ public AqpANTLRNode(AqpCommonTree node) {
+
+ tree = node;
+ String input = node.getTokenInput();
+
+ if (input != null) {
+ setTokenInput(input);
+ }
+
+ setTokenLabel(node.getTokenLabel());
+
+ setTokenType(node.getTokenType());
+
+ setTokenName(node.getTypeLabel());
+
+ if (node.getChildCount() > 0) {
+ setLeaf(false);
+ allocate();
+ }
+ }
+
+ public CharSequence toQueryString(EscapeQuerySyntax escaper) {
+ if (getTokenInput() != null) {
+ return "(" + getTokenLabel() + ":" + getTokenInput() + ")";
+ } else {
+ return getTokenLabel();
+ }
+ }
+
+ public String toStringNodeOnly() {
+ if (getTokenInput() != null) {
+ return "";
+ } else {
+ return "";
+ }
+ }
+
+ public String toString() {
+ return toString(0);
+ }
+
+ public String toString(int level) {
+ StringBuffer buf = new StringBuffer();
+ buf.append("\n");
+ for (int i = 0; i < level; i++) {
+ buf.append(" ");
+ }
+
+ buf.append(" children = this.getChildren();
+
+ if (children != null) {
+ buf.append(">");
+ for (QueryNode child : children) {
+ if (child instanceof AqpANTLRNode) {
+ buf.append(((AqpANTLRNode) child).toString(level + 4));
+ } else {
+ buf.append(child.toString());
+ }
+ }
+ }
+
+ if (isLeaf()) {
+ buf.append("/>");
+ } else {
+ buf.append("\n");
+ for (int i = 0; i < level; i++) {
+ buf.append(" ");
+ }
+ buf.append("");
+ }
+
+ return buf.toString();
+ }
+
+ public int getTokenType() {
+ return tokenType;
+ }
+
+ public void setTokenType(int tokenType) {
+ this.tokenType = tokenType;
+ }
+
+ /**
+ * Label is what is displayed in the AST tree, for example and, And, AND will
+ * all have label=AND
+ *
+ * (But their internal name is an 'OPERATOR')
+ *
+ * @return
+ */
+ public String getTokenLabel() {
+ return tokenLabel;
+ }
+
+ public void setTokenLabel(String tokenLabel) {
+ this.tokenLabel = tokenLabel;
+ }
+
+ public String getTokenName() {
+ return tokenName;
+ }
+
+ /**
+ * Name is the name of the group, ie. 'AND' is an OPERATOR (but its label
+ * says: 'AND')
+ *
+ * @param tokenName
+ */
+ public void setTokenName(String tokenName) {
+ this.tokenName = tokenName;
+ }
+
+ public String getTokenInput() {
+ return tokenInput;
+ }
+
+ public void setTokenInput(String tokenInput) {
+ this.tokenInput = tokenInput;
+ }
+
+ public int getTokenStart() {
+ return tree.getStartIndex();
+ }
+
+ public int getTokenEnd() {
+ return tree.getStopIndex();
+ }
+
+ public AqpCommonTree getTree() {
+ return tree;
+ }
+
+ public int getInputTokenStart() {
+ return ((CommonToken) tree.getToken()).getCharPositionInLine();// getStartIndex();
+ }
+
+ public int getInputTokenEnd() {
+ return ((CommonToken) tree.getToken()).getStopIndex();
+ }
+
+ public void setInputTokenEnd(int stop) {
+ ((CommonToken) tree.getToken()).setStopIndex(stop);
+ }
+
+ public void setInputTokenStart(int start) {
+ ((CommonToken) tree.getToken()).setStartIndex(start);
+ }
+
+ public AqpANTLRNode getChild(String tokenLabel) {
+ List children = getChildren();
+ if (children != null) {
+ for (QueryNode child : children) {
+ AqpANTLRNode n = (AqpANTLRNode) child;
+ if (n.getTokenLabel().equals(tokenLabel)) {
+ return n;
+ }
+ }
+
+ }
+ return null;
+ }
+
+ public AqpANTLRNode findChild(String tokenLabel) {
+ ArrayList lst = new ArrayList();
+ findChild(this, tokenLabel, lst);
+
+ if (lst.size() == 1) {
+ return (AqpANTLRNode) lst.get(0);
+ } else if (lst.size() > 1) {
+ throw new RuntimeException(
+ "This method is not meant to search for n>1 nodes");
+ }
+ return null;
+ }
+
+ private void findChild(QueryNode node, String tokenLabel,
+ ArrayList lst) {
+ if (((AqpANTLRNode) node).getTokenLabel().equals(tokenLabel)) {
+ lst.add(node);
+ } else {
+ if (!node.isLeaf()) {
+ for (QueryNode child : node.getChildren()) {
+ findChild(child, tokenLabel, lst);
+ }
+ }
+ }
+ }
+
+ public Float getTokenInputFloat() {
+ if (this.tokenInput != null) {
+ return Float.valueOf(this.tokenInput);
+ }
+ return null;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpDefopQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpDefopQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpDefopQueryNode.java (revision 0)
@@ -0,0 +1,67 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode.Modifier;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler;
+
+/**
+ * A {@link AqpDefopQueryNode} represents the default boolean operation
+ * performed on a list of nodes.
+ *
+ * This behaves the same way as any AqpBooleanQueryNode but we have the
+ * advantage of knowing which tokens were marked by the DEFOP operator and later
+ * on we can look at them and process specially (in the logic that explicit AND
+ * is stronger than implicit AND)
+ *
+ * @see AqpBooleanQueryNode
+ * @see StandardQueryConfigHandler.Operator
+ */
+public class AqpDefopQueryNode extends AqpBooleanQueryNode {
+
+ /**
+ * @param clauses
+ * - the query nodes to be joined
+ */
+ public AqpDefopQueryNode(List clauses,
+ StandardQueryConfigHandler.Operator op) {
+ super(clauses);
+
+ if ((clauses == null) || (clauses.size() == 0)) {
+ throw new IllegalArgumentException(
+ "DEFOP query must have at least one clause");
+ }
+
+ if (op.equals(StandardQueryConfigHandler.Operator.AND)) {
+ operator = "AND";
+ applyModifier(clauses, Modifier.MOD_REQ);
+ } else if (op.equals(StandardQueryConfigHandler.Operator.OR)) {
+ operator = "OR";
+ applyModifier(clauses, Modifier.MOD_NONE);
+ }
+
+ // unfortunately we have to do it like this (when subclassing from
+ // BooleanQueryNode)
+ set(clauses);
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpBooleanQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpBooleanQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpBooleanQueryNode.java (revision 0)
@@ -0,0 +1,114 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.BooleanQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.GroupQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode.Modifier;
+import org.apache.lucene.queryparser.flexible.core.parser.EscapeQuerySyntax;
+
+/**
+ * A {@link AqpBooleanQueryNode} represents base boolean operation performed on
+ * a list of nodes. It will apply the @{link ModifierQueryNode} to the clauses.
+ * The normal behaviour is not to override the ModifierQueryNode values, if
+ * already present.
+ */
+public class AqpBooleanQueryNode extends BooleanQueryNode {
+
+ private static final long serialVersionUID = -5974910790857168198L;
+
+ protected String operator = "DEFOP";
+ protected boolean overrideModifiers = false;
+
+ /**
+ * @param clauses
+ * - the query nodes to be op'ed
+ */
+ public AqpBooleanQueryNode(List clauses) {
+ super(clauses);
+
+ }
+
+ @Override
+ public String toString() {
+ if (getChildren() == null || getChildren().size() == 0)
+ return "";
+ StringBuilder sb = new StringBuilder();
+ sb.append("");
+ for (QueryNode child : getChildren()) {
+ sb.append("\n");
+ sb.append(child.toString());
+
+ }
+ sb.append("\n");
+ return sb.toString();
+ }
+
+ @Override
+ public CharSequence toQueryString(EscapeQuerySyntax escapeSyntaxParser) {
+ if (getChildren() == null || getChildren().size() == 0)
+ return "";
+
+ StringBuilder sb = new StringBuilder();
+ String filler = "";
+ for (QueryNode child : getChildren()) {
+ sb.append(filler).append(child.toQueryString(escapeSyntaxParser));
+ filler = " " + operator + " ";
+ }
+
+ // in case is root or the parent is a group node avoid parenthesis
+ if ((getParent() != null && getParent() instanceof GroupQueryNode)
+ || isRoot())
+ return sb.toString();
+ else
+ return "( " + sb.toString() + " )";
+ }
+
+ public void applyModifier(List clauses, Modifier mod) {
+ for (int i = 0; i < clauses.size(); i++) {
+ QueryNode child = clauses.get(i);
+
+ if (child instanceof ModifierQueryNode || child instanceof GroupQueryNode) {
+ if (overrideModifiers) {
+ clauses
+ .set(i,
+ new ModifierQueryNode(((ModifierQueryNode) child).getChild(),
+ mod));
+ }
+ } else {
+ clauses.set(i, new ModifierQueryNode(child, mod));
+ }
+ }
+ }
+
+ public void setOverrideModifiers(boolean val) {
+ this.overrideModifiers = val;
+ }
+
+ public void setOperator(String op) {
+ operator = op;
+ }
+
+ public String getOperator() {
+ return operator;
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpOrQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpOrQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpOrQueryNode.java (revision 0)
@@ -0,0 +1,51 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+
+/**
+ * A {@link AqpOrQueryNode} represents an OR boolean operation performed on a
+ * list of nodes.
+ *
+ * @see AqpBooleanQueryNode
+ */
+public class AqpOrQueryNode extends AqpBooleanQueryNode {
+
+ private static final long serialVersionUID = 8472252510866053747L;
+
+ /**
+ * @param clauses
+ * - the query nodes to be or'ed
+ */
+ public AqpOrQueryNode(List clauses) {
+ super(clauses);
+
+ operator = "OR";
+
+ // applyModifier(clauses, Modifier.MOD_NONE);
+
+ // unfortunately we have to do it like this (when subclassing from
+ // BooleanQueryNode)
+ set(clauses);
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNotQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNotQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNotQueryNode.java (revision 0)
@@ -0,0 +1,72 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode.Modifier;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+
+/**
+ * A {@link AqpNotQueryNode} represents an NOT boolean operation performed on a
+ * list of nodes.
+ *
+ *
+ *
+ * The first node is set to be required
+ * {@link ModifierQueryNode.Modifier#MOD_REQ} and the rest of the clauses will
+ * have a {@link ModifierQueryNode.Modifier#MOD_NOT}
+ *
+ * @see AqpBooleanQueryNode
+ */
+public class AqpNotQueryNode extends AqpBooleanQueryNode {
+
+ private static final long serialVersionUID = 4054514488434283069L;
+
+ /**
+ * @param clauses
+ * - the query nodes to be and'ed
+ */
+ public AqpNotQueryNode(List clauses) {
+ super(clauses);
+
+ operator = "NOT";
+
+ if ((clauses == null) || (clauses.size() < 2)) {
+ throw new IllegalArgumentException(
+ "NOT query must have at least two clauses");
+ }
+
+ QueryNode firstNode = clauses.get(0);
+ applyModifier(clauses, Modifier.MOD_NOT);
+ // reset the first node (if it was wrapped, ie not already having user
+ // specified MODIFIER)
+ if (!firstNode.equals(clauses.get(0))) {
+ clauses
+ .set(
+ 0,
+ new ModifierQueryNode(((ModifierQueryNode) clauses.get(0))
+ .getChild(), Modifier.MOD_REQ));
+ }
+
+ set(clauses);
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpFuzzyModifierNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpFuzzyModifierNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpFuzzyModifierNode.java (revision 0)
@@ -0,0 +1,69 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpFuzzyModifierProcessor;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeError;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNodeImpl;
+import org.apache.lucene.queryparser.flexible.core.parser.EscapeQuerySyntax;
+
+/**
+ * {@link AqpFuzzyModifierNode} is consumed by the {@link AqpFuzzyModifierProcessor}
+ * which will decide what is the appropriate operation for '~' operator. E.g.
+ *
+ *
+ *
+ * "foo bar"~5 == slop query node
+ * "foo"~5 == fuzzy search for 'foo'
+ *
+ */
+public class AqpFuzzyModifierNode extends QueryNodeImpl implements QueryNode {
+
+ private static final long serialVersionUID = -3059874057254791689L;
+ private Float fuzzy;
+
+ public AqpFuzzyModifierNode(QueryNode query, Float fuzzy) {
+ if (query == null) {
+ throw new QueryNodeError(new MessageImpl(
+ QueryParserMessages.PARAMETER_VALUE_NOT_SUPPORTED, "query", "null"));
+ }
+
+ allocate();
+ setLeaf(false);
+ add(query);
+ this.fuzzy = fuzzy;
+ }
+
+ public CharSequence toQueryString(EscapeQuerySyntax escapeSyntaxParser) {
+ if (getChild() == null)
+ return "";
+
+ String leftParenthensis = "";
+ String rightParenthensis = "";
+
+ if (getChild() != null && getChild() instanceof ModifierQueryNode) {
+ leftParenthensis = "(";
+ rightParenthensis = ")";
+ }
+
+ return leftParenthensis + getChild().toQueryString(escapeSyntaxParser)
+ + rightParenthensis + "~" + this.fuzzy.toString();
+
+ }
+
+ public String toString() {
+ return "" + "\n"
+ + getChild().toString() + "\n";
+ }
+
+ public QueryNode getChild() {
+ return getChildren().get(0);
+ }
+
+ public Float getFuzzyValue() {
+ return fuzzy;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAndQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAndQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAndQueryNode.java (revision 0)
@@ -0,0 +1,57 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode.Modifier;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+
+/**
+ * A {@link AqpAndQueryNode} represents an AND boolean operation performed on a
+ * list of nodes.
+ *
+ * @see AqpBooleanQueryNode
+ */
+public class AqpAndQueryNode extends AqpBooleanQueryNode {
+
+ private static final long serialVersionUID = -4148186404006404927L;
+
+ /**
+ * @param clauses
+ * - the query nodes to be and'ed
+ */
+ public AqpAndQueryNode(List clauses) {
+ super(clauses);
+
+ operator = "AND";
+
+ if ((clauses == null) || (clauses.size() == 0)) {
+ throw new IllegalArgumentException(
+ "AND query must have at least one clause");
+ }
+
+ applyModifier(clauses, Modifier.MOD_REQ);
+
+ // unfortunately we have to do it like this (when subclassing from
+ // BooleanQueryNode)
+ set(clauses);
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNonAnalyzedQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNonAnalyzedQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNonAnalyzedQueryNode.java (revision 0)
@@ -0,0 +1,66 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QuotedFieldQueryNode;
+
+/**
+ * A {@link NonAnalyzedQueryNode} represents a query that will not be processed
+ * by an analyzer. It will be served to the search engine as it is
+ *
+ * Example: e(+)
+ */
+public class AqpNonAnalyzedQueryNode extends QuotedFieldQueryNode {
+
+ private static final long serialVersionUID = 6921391439471630844L;
+
+ /**
+ * @param field
+ * - field name
+ * @param text
+ * - the query
+ * @param begin
+ * - position in the query string
+ * @param end
+ * - position in the query string
+ */
+ public AqpNonAnalyzedQueryNode(CharSequence field, CharSequence text,
+ int begin, int end) {
+ super(field, text, begin, end);
+ }
+
+ public AqpNonAnalyzedQueryNode(FieldQueryNode fqn) {
+ this(fqn.getField(), fqn.getText(), fqn.getBegin(), fqn.getEnd());
+ }
+
+ @Override
+ public String toString() {
+ return "";
+ }
+
+ @Override
+ public AqpNonAnalyzedQueryNode cloneTree() throws CloneNotSupportedException {
+ AqpNonAnalyzedQueryNode clone = (AqpNonAnalyzedQueryNode) super.cloneTree();
+
+ // nothing to do here
+
+ return clone;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNearQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNearQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpNearQueryNode.java (revision 0)
@@ -0,0 +1,89 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+import java.util.List;
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpOPERATORProcessor;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeError;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNodeImpl;
+import org.apache.lucene.queryparser.flexible.core.parser.EscapeQuerySyntax;
+
+/**
+ * For nodes connected through proximity operators, eg.
+ *
+ *
+ * foo NEAR bar
+ *
+ *
+ * @see AqpOPERATORProcessor
+ *
+ */
+public class AqpNearQueryNode extends QueryNodeImpl implements QueryNode {
+
+ private static final long serialVersionUID = 8806759327487974314L;
+ private Integer slop = null;
+ private boolean inOrder = true;
+
+ public AqpNearQueryNode(List children, int proximity) {
+ if (children == null) {
+ throw new QueryNodeError(
+ new MessageImpl(QueryParserMessages.PARAMETER_VALUE_NOT_SUPPORTED,
+ "children", "null"));
+ }
+ allocate();
+ setLeaf(false);
+ add(children);
+ this.slop = proximity;
+ }
+
+ public CharSequence toQueryString(EscapeQuerySyntax escapeSyntaxParser) {
+ if (getChild() == null)
+ return "";
+
+ String leftParenthensis = "";
+ String rightParenthensis = "";
+
+ if (getChild() != null && getChild() instanceof AqpNearQueryNode) {
+ leftParenthensis = "(";
+ rightParenthensis = ")";
+ }
+
+ return leftParenthensis + "#"
+ + getChild().toQueryString(escapeSyntaxParser) + rightParenthensis;
+
+ }
+
+ public String toString() {
+ StringBuffer bo = new StringBuffer();
+ bo.append("\n");
+ for (QueryNode child : this.getChildren()) {
+ bo.append(child.toString());
+ bo.append("\n");
+ }
+ bo.append("\n");
+ return bo.toString();
+ }
+
+ public QueryNode getChild() {
+ return getChildren().get(0);
+ }
+
+ public Integer getSlop() {
+ return slop;
+ }
+
+ public void setSlop(Integer prox) {
+ slop = prox;
+ }
+
+ public boolean getInOrder() {
+ return inOrder;
+ }
+
+ public void setInOrder(boolean order) {
+ inOrder = order;
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAnalyzedQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAnalyzedQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAnalyzedQueryNode.java (revision 0)
@@ -0,0 +1,63 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpAnalyzerQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNodeImpl;
+import org.apache.lucene.queryparser.flexible.core.parser.EscapeQuerySyntax;
+
+/**
+ * A {@link NonAnalyzedQueryNode} represents a query that was already be
+ * processed by an analyzer. The child (typically only one) is the result of a
+ * call to another analyzer.
+ *
+ * @see AqpAnalyzerQueryNodeProcessor
+ */
+public class AqpAnalyzedQueryNode extends QueryNodeImpl {
+
+ /**
+ * @param node
+ * - query node
+ */
+ public AqpAnalyzedQueryNode(QueryNode node) {
+ allocate();
+ setLeaf(false);
+ this.add(node);
+ }
+
+ @Override
+ public String toString() {
+ return "" + this.getChild() + "";
+ }
+
+ @Override
+ public AqpAnalyzedQueryNode cloneTree() throws CloneNotSupportedException {
+ AqpAnalyzedQueryNode clone = (AqpAnalyzedQueryNode) super.cloneTree();
+ // nothing to do here
+ return clone;
+ }
+
+ public CharSequence toQueryString(EscapeQuerySyntax escapeSyntaxParser) {
+ return this.getChildren().get(0).toQueryString(escapeSyntaxParser);
+ }
+
+ public QueryNode getChild() {
+ return this.getChildren().get(0);
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAdsabsRegexQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAdsabsRegexQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpAdsabsRegexQueryNode.java (revision 0)
@@ -0,0 +1,41 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+import org.apache.lucene.queryparser.flexible.aqp.builders.AqpFieldQueryNodeRegexBuilder;
+import org.apache.lucene.queryparser.flexible.core.builders.QueryTreeBuilder;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.search.RegexpQuery;
+
+/**
+ * This node will be turned into the {@link RegexpQuery} by
+ * {@link AqpFieldQueryNodeRegexBuilder}. But the appropriate
+ * builder must be configured.
+ *
+ * @see instances of {@link QueryTreeBuilder}
+ *
+ */
+public class AqpAdsabsRegexQueryNode extends AqpNonAnalyzedQueryNode {
+
+ public AqpAdsabsRegexQueryNode(CharSequence field, CharSequence text,
+ int begin, int end) {
+ super(field, text, begin, end);
+ }
+
+ public AqpAdsabsRegexQueryNode(FieldQueryNode fqn) {
+ this(fqn.getField(), fqn.getText(), fqn.getBegin(), fqn.getEnd());
+ }
+
+ @Override
+ public String toString() {
+ return "";
+ }
+
+ @Override
+ public AqpAdsabsRegexQueryNode cloneTree() throws CloneNotSupportedException {
+ AqpAdsabsRegexQueryNode clone = (AqpAdsabsRegexQueryNode) super.cloneTree();
+
+ // nothing to do here
+
+ return clone;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpDisjunctionQueryNode.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpDisjunctionQueryNode.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/nodes/AqpDisjunctionQueryNode.java (revision 0)
@@ -0,0 +1,68 @@
+package org.apache.lucene.queryparser.flexible.aqp.nodes;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeError;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNodeImpl;
+import org.apache.lucene.queryparser.flexible.core.parser.EscapeQuerySyntax;
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+
+public class AqpDisjunctionQueryNode extends QueryNodeImpl {
+
+ private Float tieBreaker = null;
+
+ public AqpDisjunctionQueryNode(List children, float tieBreaker) {
+ if (children == null) {
+ throw new QueryNodeError(
+ new MessageImpl(QueryParserMessages.PARAMETER_VALUE_NOT_SUPPORTED,
+ "children", "null"));
+ }
+ allocate();
+ setLeaf(false);
+ add(children);
+ this.tieBreaker = tieBreaker;
+ }
+
+ public CharSequence toQueryString(EscapeQuerySyntax escapeSyntaxParser) {
+ if (getChildren().size() == 0)
+ return "";
+
+ StringBuilder sb = new StringBuilder();
+ sb.append("(");
+ boolean notFirst = false;
+ for (QueryNode child : getChildren()) {
+ if (notFirst) {
+ sb.append(" | ");
+ }
+ sb.append(child.toQueryString(escapeSyntaxParser));
+ notFirst = true;
+ }
+ sb.append(")");
+ return sb.toString();
+
+ }
+
+ public String toString() {
+ StringBuffer bo = new StringBuffer();
+ bo.append("\n");
+ for (QueryNode child : this.getChildren()) {
+ bo.append(child.toString());
+ bo.append("\n");
+ }
+ bo.append("\n");
+ return bo.toString();
+ }
+
+ public Float getTieBreaker() {
+ return tieBreaker;
+ }
+
+ public void setTieBreaker(Float tieBreaker) {
+ this.tieBreaker = tieBreaker;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpNearQueryNodeBuilder.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpNearQueryNodeBuilder.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpNearQueryNodeBuilder.java (revision 0)
@@ -0,0 +1,213 @@
+package org.apache.lucene.queryparser.flexible.aqp.builders;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.builders.QueryBuilder;
+import org.apache.lucene.queryparser.flexible.core.builders.QueryTreeBuilder;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpNearQueryNode;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanClause.Occur;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.PrefixQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.search.spans.SpanMultiTermQueryWrapper;
+import org.apache.lucene.search.spans.SpanNearQuery;
+import org.apache.lucene.search.spans.SpanNotQuery;
+import org.apache.lucene.search.spans.SpanOrQuery;
+import org.apache.lucene.search.spans.SpanQuery;
+import org.apache.lucene.search.spans.SpanTermQuery;
+
+/**
+ * The builder for the {@link AqpNearQueryNode}, example query:
+ *
+ *
+ * dog NEAR/5 cat
+ *
+ *
+ *
+ * After the AST tree was parsed, and synonyms were found,
+ * we may have the following tree:
+ *
+ *
+ *
+ * AqpNearQueryNode(5)
+ * |
+ * ------------------------------
+ * / \
+ * OR QueryNode(cat)
+ * |
+ * -----------------
+ * / \
+ * QueryNode(dog) QueryNode(canin)
+ *
+ *
+ *
+ *
+ *
+ * Since Lucene cannot handle these queries, the flex builder
+ * must rewrite them, effectively producing
+ *
+ *
+ * SpanNear(SpanOr(dog | cat), SpanTerm(cat), 5)
+ *
+ *
+ *
+ * This builder does not know (yet) how to handle cases of
+ * mixed boolean operators, eg.
+ *
+ *
+ * (dog AND (cat OR fat)) NEAR/5 batman
+ *
+ *
+ * @see QueryNodeProcessorPipeline
+ * @see AqpNearQueryNode
+ *
+ */
+public class AqpNearQueryNodeBuilder implements QueryBuilder {
+
+ public AqpNearQueryNodeBuilder() {
+ // empty constructor
+ }
+
+ public Object build(QueryNode queryNode) throws QueryNodeException {
+ AqpNearQueryNode nearNode = (AqpNearQueryNode) queryNode;
+
+ List children = nearNode.getChildren();
+
+ if (children != null) {
+ SpanQuery[] clauses = new SpanQuery[children.size()];
+
+ int i = 0;
+ for (QueryNode child : children) {
+ Object obj = child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID);
+ if (obj != null) {
+ clauses[i++] = getSpanQuery(obj, nearNode);
+ } else {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "One of the clauses inside AqpNearQueryNode is null"));
+ }
+ }
+
+ return new SpanNearQuery(clauses, nearNode.getSlop(),
+ nearNode.getInOrder());
+ }
+
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "Illegal state for: " + nearNode.toString()));
+ }
+
+ protected SpanQuery getSpanQuery(Object obj, AqpNearQueryNode nearNode)
+ throws QueryNodeException {
+ Query q = (Query) obj;
+ if (q instanceof SpanQuery) {
+ return (SpanQuery) q;
+ } else if (q instanceof TermQuery) {
+ return new SpanTermQuery(((TermQuery) q).getTerm());
+ } else if (q instanceof WildcardQuery) {
+ return new SpanMultiTermQueryWrapper((WildcardQuery) q);
+ } else if (q instanceof PrefixQuery) {
+ return new SpanMultiTermQueryWrapper((PrefixQuery) q);
+ } else if (q instanceof BooleanQuery) {
+ return convertBooleanToSpan((BooleanQuery) q, nearNode);
+ } else {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, q.toString(),
+ "(yet) Unsupported clause inside span query: "
+ + q.getClass().getName()));
+ }
+ }
+
+ /*
+ * Silly convertor for now it can handle only boolean queries of the same type
+ * (ie not mixed cases). To do that, I have to build a graph (tree) and maybe
+ * of only pairs (?)
+ */
+ protected SpanQuery convertBooleanToSpan(BooleanQuery q,
+ AqpNearQueryNode nearNode) throws QueryNodeException {
+ BooleanClause[] clauses = q.getClauses();
+ SpanQuery[] spanClauses = new SpanQuery[clauses.length];
+ Occur o = null;
+ int i = 0;
+ for (BooleanClause c : clauses) {
+ if (o != null && !o.equals(c.getOccur())) {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, q.toString(),
+ "(yet) Unsupported clause inside span query: "
+ + q.getClass().getName()));
+ }
+ o = c.getOccur();
+ spanClauses[i] = getSpanQuery(c.getQuery(), nearNode);
+ i++;
+ }
+
+ if (o.equals(Occur.MUST)) {
+ return new SpanNearQuery(spanClauses, nearNode.getSlop(),
+ nearNode.getInOrder());
+ } else if (o.equals(Occur.SHOULD)) {
+ return new SpanOrQuery(spanClauses);
+ } else if (o.equals(Occur.MUST_NOT)) {
+ SpanQuery[] exclude = new SpanQuery[spanClauses.length - 1];
+ for (int j = 1; j < spanClauses.length; j++) {
+ exclude[j - 1] = spanClauses[j];
+ }
+ return new SpanNotQuery(spanClauses[0], new SpanOrQuery(exclude));
+ }
+
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR, q.toString(),
+ "Congratulations! You have hit (yet) unsupported case: "
+ + q.getClass().getName()));
+ }
+
+ class Leaf {
+ public List members = new ArrayList();
+ public BooleanClause left;
+ public Leaf right;
+
+ public Leaf(BooleanClause left, Leaf right) {
+ this.left = left;
+ this.right = right;
+ }
+ }
+
+ /*
+ * Creates a tree of the clauses, according to operator precedence:
+ *
+ * Thus: D +C -A -B becomes:
+ *
+ * - / \ A - / \ B + / \ C D
+ */
+ private Leaf constructTree(BooleanClause[] clauses) {
+ List toProcess = Arrays.asList(clauses);
+ Leaf leaf = new Leaf(null, null);
+ leaf.members = toProcess;
+
+ // from highest priority
+ // findNots(leaf);
+ // findAnds(leaf);
+ // findOrs(leaf);
+ return leaf;
+ }
+
+ private void findNots(Leaf leaf) {
+
+ for (BooleanClause m : leaf.members) {
+ if (m.getOccur().equals(Occur.MUST_NOT)) {
+ leaf.members.remove(m);
+ leaf.left = m;
+ }
+ }
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpQueryTreeBuilder.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpQueryTreeBuilder.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpQueryTreeBuilder.java (revision 0)
@@ -0,0 +1,113 @@
+package org.apache.lucene.queryparser.flexible.aqp.builders;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.builders.QueryBuilder;
+import org.apache.lucene.queryparser.flexible.core.builders.QueryTreeBuilder;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.builders.StandardQueryBuilder;
+import org.apache.lucene.queryparser.flexible.standard.processors.StandardQueryNodeProcessorPipeline;
+import org.apache.lucene.search.Query;
+
+/**
+ * This query tree builder only defines the necessary methods for
+ * debugging.
+ *
+ * @see QueryTreeBuilder
+ * @see StandardQueryNodeProcessorPipeline
+ */
+public class AqpQueryTreeBuilder extends QueryTreeBuilder implements
+ StandardQueryBuilder {
+
+ private boolean debug = false;
+ private int counter = 0;
+
+ public AqpQueryTreeBuilder(boolean debug) {
+ this.setDebug(debug);
+ init();
+ }
+
+ public AqpQueryTreeBuilder() {
+ init();
+ }
+
+ public void setDebug(boolean val) {
+ if (val != debug) {
+ debug = val;
+ init();
+ }
+ debug = val;
+ }
+
+ public boolean isInDebugMode() {
+ return debug;
+ }
+
+ public void init() {
+ throw new IllegalAccessError("AqpQueryTreeBuilder must be subclassed and has the init() method");
+ }
+
+ @Override
+ public Query build(QueryNode queryNode) throws QueryNodeException {
+ this.counter = 0;
+ return (Query) super.build(queryNode);
+ }
+
+
+ public void setBuilder(Class queryNodeClass,
+ QueryBuilder builder) {
+ if (this.debug) {
+ super.setBuilder(queryNodeClass, new DebuggingNodeBuilder(queryNodeClass,
+ builder));
+ } else {
+ super.setBuilder(queryNodeClass, builder);
+ }
+ }
+
+ class DebuggingNodeBuilder implements QueryBuilder {
+ private Class clazz = null;
+ private QueryBuilder realBuilder = null;
+
+ DebuggingNodeBuilder(Class queryNodeClass,
+ QueryBuilder builder) {
+ clazz = queryNodeClass;
+ realBuilder = builder;
+ }
+
+ public Object build(QueryNode queryNode) throws QueryNodeException {
+ System.out.println("--------------------------------------------");
+ System.out.println("step " + counter++ + ".");
+ System.out.println("builder: " + realBuilder.getClass().getName());
+ System.out.println("node: " + clazz.getName());
+ System.out.println(queryNode.toString());
+ System.out.println(" -->");
+ Object result = realBuilder.build(queryNode);
+ if (result != null) {
+ System.out.println(((Query) result).toString() + " <"
+ + result.getClass().getName() + ">");
+ } else {
+ System.out.println("null");
+ }
+ System.out.println("--------------------------------------------");
+ return result;
+ }
+
+ };
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpSlowFuzzyQueryNodeBuilder.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpSlowFuzzyQueryNodeBuilder.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpSlowFuzzyQueryNodeBuilder.java (revision 0)
@@ -0,0 +1,26 @@
+package org.apache.lucene.queryparser.flexible.aqp.builders;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.SlowFuzzyQueryNode;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.builders.StandardQueryBuilder;
+import org.apache.lucene.sandbox.queries.SlowFuzzyQuery;
+
+@SuppressWarnings("deprecation")
+public class AqpSlowFuzzyQueryNodeBuilder implements StandardQueryBuilder {
+
+ public AqpSlowFuzzyQueryNodeBuilder() {
+ // empty constructor
+ }
+
+ public SlowFuzzyQuery build(QueryNode queryNode) throws QueryNodeException {
+ SlowFuzzyQueryNode fuzzyNode = (SlowFuzzyQueryNode) queryNode;
+
+ return new SlowFuzzyQuery(new Term(fuzzyNode.getFieldAsString(),
+ fuzzyNode.getTextAsString()), fuzzyNode.getSimilarity(),
+ fuzzyNode.getPrefixLength());
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpFieldQueryNodeRegexBuilder.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpFieldQueryNodeRegexBuilder.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpFieldQueryNodeRegexBuilder.java (revision 0)
@@ -0,0 +1,26 @@
+package org.apache.lucene.queryparser.flexible.aqp.builders;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.builders.StandardQueryBuilder;
+import org.apache.lucene.search.Query;
+//import org.apache.lucene.sandbox.queries.regex.RegexQuery;
+import org.apache.lucene.search.RegexpQuery;
+
+public class AqpFieldQueryNodeRegexBuilder implements StandardQueryBuilder {
+
+ public AqpFieldQueryNodeRegexBuilder() {
+ // empty constructor
+ }
+
+ public Query build(QueryNode queryNode) throws QueryNodeException {
+ FieldQueryNode fieldNode = (FieldQueryNode) queryNode;
+
+ return new RegexpQuery(new Term(fieldNode.getFieldAsString(),
+ fieldNode.getTextAsString()));
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpFieldQueryNodeBuilder.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpFieldQueryNodeBuilder.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/builders/AqpFieldQueryNodeBuilder.java (revision 0)
@@ -0,0 +1,31 @@
+package org.apache.lucene.queryparser.flexible.aqp.builders;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.builders.StandardQueryBuilder;
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TermQuery;
+
+public class AqpFieldQueryNodeBuilder implements StandardQueryBuilder {
+
+ public AqpFieldQueryNodeBuilder() {
+ // empty constructor
+ }
+
+ public Query build(QueryNode queryNode) throws QueryNodeException {
+ FieldQueryNode fieldNode = (FieldQueryNode) queryNode;
+
+ if (fieldNode.getFieldAsString().equals("*")
+ && fieldNode.getTextAsString().equals("*")) {
+ return new MatchAllDocsQuery();
+ }
+
+ return new TermQuery(new Term(fieldNode.getFieldAsString(),
+ fieldNode.getTextAsString()));
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParserAbstract.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParserAbstract.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParserAbstract.java (revision 0)
@@ -0,0 +1,35 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+import org.antlr.runtime.TokenStream;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeParseException;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+
+/**
+ * All ANTLR parsers should subclass {@link AqpSyntaxParser} and
+ * provide two methods:
+ *
+ * {@link AqpSyntaxParser}{@link #getTokenStream(CharSequence)}
+ * {@link AqpSyntaxParser}{@link #parseTokenStream(TokenStream, CharSequence, CharSequence)
+ *
+ * Optionally, the new class can also override
+ *
+ * {@link AqpSyntaxParser}{@link #initializeGrammar(String)
+ *
+ * The default implementation is using reflection and is able
+ * to instantiate any grammar provided that the top parse rule
+ * is called mainQ and that the grammar is producing
+ * AST tree.
+ *
+ */
+public abstract class AqpSyntaxParserAbstract implements AqpSyntaxParser {
+
+ /**
+ * Parse the query and return the {@link QueryNode}. ANTLR will
+ * do the parsing and we return AST.
+ */
+ public QueryNode parse(CharSequence query, CharSequence field)
+ throws QueryNodeParseException {
+ TokenStream tokens = getTokenStream(query);
+ return parseTokenStream(tokens, query, field);
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParserLoadableImpl.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParserLoadableImpl.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/AqpSyntaxParserLoadableImpl.java (revision 0)
@@ -0,0 +1,180 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+import org.antlr.runtime.ANTLRStringStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.Lexer;
+import org.antlr.runtime.Parser;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.TokenSource;
+import org.antlr.runtime.TokenStream;
+import org.antlr.runtime.tree.TreeAdaptor;
+import org.apache.lucene.queryparser.flexible.messages.Message;
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeParseException;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardLuceneParser;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpCommonTree;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpCommonTreeAdaptor;
+
+/**
+ * This implementation can load any AST grammar from the repository of grammars
+ * without a need to provide a Java implementation. It uses reflection, so it
+ * might be slower than a dedicated parsing class.
+ *
+ * Every grammar must have a top-level rule called mainQ
+ *
+ * And every grammar must return AST.
+ *
+ * If you know that you are going to instantiate specific parser, then
+ * you should not use this generic class.
+ *
+ * @see AqpSyntaxParserAbstract
+ * @see AqpStandardLuceneParser#init()
+ *
+ */
+public class AqpSyntaxParserLoadableImpl extends AqpSyntaxParserAbstract {
+
+ @SuppressWarnings("rawtypes")
+ private Class clsLexer;
+ @SuppressWarnings("rawtypes")
+ private Class clsParser;
+
+ private Object iLexer;
+ private Object iParser;
+
+ private Method invokeMainQ;
+ private Method getTreeMethod;
+ private Method getNumberOfSyntaxErrorsMethod;
+
+ private Lexer lexer;
+ private Parser parser;
+
+ private String[] tokenNames;
+
+ public AqpSyntaxParserLoadableImpl() {
+ // empty constructor
+ }
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public AqpSyntaxParser initializeGrammar(String grammarName)
+ throws QueryNodeParseException {
+
+ try {
+ // get the Classes
+ clsLexer = Class
+ .forName("org.apache.lucene.queryparser.flexible.aqp.parser."
+ + grammarName + "Lexer");
+ clsParser = Class
+ .forName("org.apache.lucene.queryparser.flexible.aqp.parser."
+ + grammarName + "Parser");
+
+ // instantiate lexer with no parameter
+ Class partypes[] = new Class[0];
+ // partypes[0] = CharStream.class;
+ Constructor ctLexer = clsLexer.getConstructor(partypes);
+ Object arglist[] = new Object[0];
+ iLexer = ctLexer.newInstance(arglist);
+
+ // instantiate parser using no parameters
+ // ANTLRStringStream fakeInput = new ANTLRStringStream("none");
+ CommonTokenStream fakeTokens = new CommonTokenStream(
+ (TokenSource) clsLexer.cast(iLexer));
+ Class partypes2[] = new Class[1];
+ partypes2[0] = TokenStream.class;
+ Constructor ct = clsParser.getConstructor(partypes2);
+ iParser = ct.newInstance(fakeTokens);
+
+ parser = (Parser) iParser;
+ lexer = (Lexer) iLexer;
+
+ // get tokenNames
+ Method getTokenNames = clsParser.getDeclaredMethod("getTokenNames");
+ tokenNames = (String[]) getTokenNames.invoke(iParser);
+
+ // create adaptor
+ AqpCommonTreeAdaptor adaptor = new AqpCommonTreeAdaptor(tokenNames);
+
+ // set adaptor
+ Method setTreeAdaptor = clsParser.getDeclaredMethod("setTreeAdaptor",
+ TreeAdaptor.class);
+ setTreeAdaptor.invoke(iParser, adaptor);
+
+ // get the mainQ parser rule & return value
+ invokeMainQ = clsParser.getDeclaredMethod("mainQ");
+ getTreeMethod = invokeMainQ.getReturnType().getMethod("getTree");
+ getNumberOfSyntaxErrorsMethod = clsParser
+ .getMethod("getNumberOfSyntaxErrors");
+
+ // AqpCommonTree ast = parseTest("hey:joe");
+
+ return this;
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new QueryNodeParseException(e);
+ }
+
+ }
+
+ public TokenStream getTokenStream(CharSequence query) {
+ ANTLRStringStream input = new ANTLRStringStream(query.toString());
+ lexer.setCharStream(input);
+
+ // get tokens
+ CommonTokenStream tokens = new CommonTokenStream(
+ (TokenSource) clsLexer.cast(iLexer));
+ return tokens;
+ }
+
+ public QueryNode parseTokenStream(TokenStream tokens, CharSequence query,
+ CharSequence field) throws QueryNodeParseException {
+
+ // set tokens
+ parser.setTokenStream(tokens);
+
+ // get tree back
+ Object retVal;
+ AqpCommonTree astTree;
+
+ try {
+ retVal = invokeMainQ.invoke(iParser);
+ astTree = (AqpCommonTree) (getTreeMethod.invoke(retVal));
+
+ // this prevents parser from recovering, however it can also interfere
+ // with custom error handling (if present inside the grammar)
+ Object errNo = getNumberOfSyntaxErrorsMethod.invoke(iParser);
+
+ if (errNo instanceof Integer && ((Integer) errNo > 0)) {
+ throw new Error(
+ "The parser reported a syntax error, antlrqueryparser hates errors!");
+ }
+ } catch (Error e) {
+ Message message = new MessageImpl(
+ QueryParserMessages.INVALID_SYNTAX_CANNOT_PARSE, query,
+ e.getMessage());
+ QueryNodeParseException ee = new QueryNodeParseException(e);
+ ee.setQuery(query);
+ ee.setNonLocalizedMessage(message);
+ throw ee;
+ } catch (Exception e) { // TODO: these exceptions are from the code, should
+ // not be printed
+ // e.printStackTrace();
+ QueryNodeParseException ee = new QueryNodeParseException(e);
+ throw ee;
+ }
+
+ try {
+ return astTree.toQueryNodeTree();
+ } catch (RecognitionException e) {
+ throw new QueryNodeParseException(new MessageImpl(query + " >> "
+ + parser.getErrorMessage(e, parser.getTokenNames())));
+ }
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/NestedParseException.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/NestedParseException.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/NestedParseException.java (revision 0)
@@ -0,0 +1,32 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+/**
+ * This class is used explicitly (and only) for exceptions that happen inside a
+ * QueryParser (AQP). We want to have a mechanism to raise and exception that is
+ * not interfering with existing interfaces. But which is caught by the
+ * {@link AqpAdsabsQueryParser}
+ *
+ *
+ */
+
+public class NestedParseException extends RuntimeException {
+
+ private static final long serialVersionUID = -3943145526662562552L;
+
+ public NestedParseException() {
+ super();
+ }
+
+ public NestedParseException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public NestedParseException(String string) {
+ super(string);
+ }
+
+ public NestedParseException(Throwable cause) {
+ super(cause);
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/UnforgivingParser.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/UnforgivingParser.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/UnforgivingParser.java (revision 0)
@@ -0,0 +1,33 @@
+package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+import org.antlr.runtime.BitSet;
+import org.antlr.runtime.IntStream;
+import org.antlr.runtime.MismatchedTokenException;
+import org.antlr.runtime.Parser;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.RecognizerSharedState;
+import org.antlr.runtime.TokenStream;
+
+public class UnforgivingParser extends Parser {
+
+ public UnforgivingParser(TokenStream input) {
+ super(input);
+ // TODO Auto-generated constructor stub
+ }
+
+ public UnforgivingParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+ // TODO Auto-generated constructor stub
+ }
+
+ @Override
+ protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow)
+ throws RecognitionException
+ {
+ //do not try to recover
+ MismatchedTokenException e = new MismatchedTokenException(ttype, input);
+ throw e;
+ }
+
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardLuceneParser.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardLuceneParser.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardLuceneParser.java (revision 0)
@@ -0,0 +1,60 @@
+package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.queryparser.flexible.aqp.AqpQueryParser;
+import org.apache.lucene.queryparser.flexible.aqp.AqpSyntaxParserLoadableImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeParseException;
+import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser;
+
+public class AqpStandardLuceneParser {
+
+ /**
+ * Constructs a {@link StandardQueryParser} object. The default grammar used
+ * is "LuceneGrammar" {@see AqpQueryParser#AqpQueryParser(String)}
+ *
+ * @throws Exception
+ */
+
+ public static AqpQueryParser init(String grammarName)
+ throws QueryNodeParseException {
+ return new AqpQueryParser(new AqpStandardQueryConfigHandler(),
+ new AqpSyntaxParserLoadableImpl().initializeGrammar(grammarName),
+ new AqpStandardQueryNodeProcessorPipeline(null),
+ new AqpStandardQueryTreeBuilder());
+ }
+
+ /**
+ * Instantiates {@link StandardLuceneGrammarSyntaxParser}, this method
+ * is using a dedicated parser class, instead of loading the parser
+ * by its grammar name
+ *
+ * @return
+ * @throws QueryNodeParseException
+ */
+ public static AqpQueryParser init() throws QueryNodeParseException {
+ return new AqpQueryParser(new AqpStandardQueryConfigHandler(),
+ new StandardLuceneGrammarSyntaxParser(),
+ new AqpStandardQueryNodeProcessorPipeline(null),
+ new AqpStandardQueryTreeBuilder());
+
+ }
+
+ /**
+ * Constructs a {@link StandardQueryParser} object and sets an
+ * {@link Analyzer} to it. The same as:
+ *
+ *
+ * StandardQueryParser qp = new StandardQueryParser();
+ * qp.getQueryConfigHandler().setAnalyzer(analyzer);
+ *
+ *
+ * @param analyzer
+ * the analyzer to be used by this query parser helper
+ * @throws Exception
+ */
+ public AqpQueryParser init(Analyzer analyzer) throws Exception {
+ AqpQueryParser p = AqpStandardLuceneParser.init("StandardLuceneGrammar");
+ p.setAnalyzer(analyzer);
+ return p;
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryConfigHandler.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryConfigHandler.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryConfigHandler.java (revision 0)
@@ -0,0 +1,126 @@
+package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.lucene.queryparser.flexible.core.config.ConfigurationKey;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.standard.processors.PhraseSlopQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedback;
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedbackEvent;
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedbackEventHandler;
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedbackImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpFuzzyModifierNode;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpBOOSTProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpDEFOPProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpFUZZYProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpFuzzyModifierProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpQNORMALProcessor;
+
+public class AqpStandardQueryConfigHandler extends StandardQueryConfigHandler {
+
+ final public static class ConfigurationKeys {
+
+ /**
+ * This attribute is used by {@link AqpQNORMALProcessor} processor and must
+ * be defined in the {@link QueryConfigHandler}. This attribute tells the
+ * processor what is the default field when no field is defined in a phrase.
+ *
+ */
+ final public static ConfigurationKey DEFAULT_FIELD = ConfigurationKey
+ .newInstance();
+
+ /**
+ * This attribute is used by {@link PhraseSlopQueryNodeProcessor} processor
+ * and must be defined in the {@link QueryConfigHandler}. This attribute
+ * tells the processor what is the default phrase slop when no slop is
+ * defined in a phrase.
+ *
+ */
+ final public static ConfigurationKey DEFAULT_PROXIMITY = ConfigurationKey
+ .newInstance();
+
+ /**
+ * This attribute is used by {@link AqpDEFOPProcessor} processor and must be
+ * defined in the {@link QueryConfigHandler}. This attribute tells the
+ * processor what are the allowed values when user submits them.
+ *
+ */
+ final public static ConfigurationKey ALLOWED_PROXIMITY_RANGE = ConfigurationKey
+ .newInstance();
+
+ /**
+ * Value of the default boost, to be used when user specified '^' without a
+ * value
+ *
+ * @see AqpBOOSTProcessor
+ */
+ final public static ConfigurationKey IMPLICIT_BOOST = ConfigurationKey
+ .newInstance();
+
+ /**
+ * This attribute is used to collect feedback messages and suggestions from
+ * the query parser
+ *
+ * @see AqpFeedback#registerEventHandler(AqpFeedbackEventHandler)
+ * @see AqpFeedback#sendEvent(AqpFeedbackEvent)
+ */
+ final public static ConfigurationKey FEEDBACK = ConfigurationKey
+ .newInstance();
+
+ /**
+ * Default fuzzy value when user specified only 'term~'
+ *
+ * @see AqpFUZZYProcessor
+ * @see AqpFuzzyModifierNode
+ * @see AqpFuzzyModifierProcessor
+ */
+ final public static ConfigurationKey IMPLICIT_FUZZY = ConfigurationKey
+ .newInstance();
+
+ /**
+ * Allow to use the old-style 0.0-1.0f fuzzy value and let it be handled by
+ * the SlowFuzzyQuery
+ *
+ * @see AqpFuzzyModifierProcessor
+ *
+ */
+ final public static ConfigurationKey ALLOW_SLOW_FUZZY = ConfigurationKey
+ .newInstance();
+
+ /**
+ * Translation mapping for index names
+ */
+ final public static ConfigurationKey> FIELD_MAPPER = ConfigurationKey
+ .newInstance();
+
+ /**
+ * Translation mapping for index names (after analysis was done)
+ */
+ final public static ConfigurationKey> FIELD_MAPPER_POST_ANALYSIS = ConfigurationKey
+ .newInstance();
+
+ }
+
+ public AqpStandardQueryConfigHandler() {
+ super();
+
+ // Add listener that will build the FieldConfig attributes.
+ // None for now
+
+ // Default Values (besides the standard ones)
+ set(ConfigurationKeys.DEFAULT_FIELD, null);
+ set(ConfigurationKeys.DEFAULT_PROXIMITY, 5);
+ set(ConfigurationKeys.ALLOWED_PROXIMITY_RANGE, new int[] { 1, 5 });
+ set(ConfigurationKeys.IMPLICIT_BOOST, 1.0f);
+ set(ConfigurationKeys.IMPLICIT_FUZZY, 0.5f);
+ set(ConfigurationKeys.FEEDBACK, new AqpFeedbackImpl());
+ set(ConfigurationKeys.ALLOW_SLOW_FUZZY, false);
+ set(ConfigurationKeys.FIELD_MAPPER, new HashMap());
+ set(ConfigurationKeys.FIELD_MAPPER_POST_ANALYSIS,
+ new HashMap());
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryTreeBuilder.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryTreeBuilder.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryTreeBuilder.java (revision 0)
@@ -0,0 +1,96 @@
+package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.queryparser.flexible.core.nodes.BooleanQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.BoostQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.FuzzyQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.GroupQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.MatchAllDocsQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.MatchNoDocsQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.SlopQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.TokenizedPhraseQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.builders.BooleanQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.BoostQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.DummyQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.FuzzyQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.GroupQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.MatchAllDocsQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.MatchNoDocsQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.ModifierQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.MultiPhraseQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.NumericRangeQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.PhraseQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.PrefixWildcardQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.RegexpQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.SlopQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.StandardBooleanQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.StandardQueryBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.TermRangeQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.WildcardQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.nodes.MultiPhraseQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.NumericQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.NumericRangeQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.PrefixWildcardQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.RegexpQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.StandardBooleanQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.TermRangeQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.WildcardQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.builders.AqpFieldQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.aqp.builders.AqpQueryTreeBuilder;
+import org.apache.lucene.queryparser.flexible.aqp.builders.AqpSlowFuzzyQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.SlowFuzzyQueryNode;
+
+/**
+ * This query tree builder provides configuration for the standard
+ * lucene syntax.
+ *
+ * @see AqpStandardLuceneParser
+ */
+public class AqpStandardQueryTreeBuilder extends AqpQueryTreeBuilder implements
+ StandardQueryBuilder {
+
+
+ public void init() {
+ setBuilder(GroupQueryNode.class, new GroupQueryNodeBuilder());
+ setBuilder(FieldQueryNode.class, new AqpFieldQueryNodeBuilder());
+ setBuilder(BooleanQueryNode.class, new BooleanQueryNodeBuilder());
+ setBuilder(SlowFuzzyQueryNode.class, new AqpSlowFuzzyQueryNodeBuilder());
+ setBuilder(FuzzyQueryNode.class, new FuzzyQueryNodeBuilder());
+ setBuilder(NumericQueryNode.class, new DummyQueryNodeBuilder());
+ setBuilder(NumericRangeQueryNode.class, new NumericRangeQueryNodeBuilder());
+ setBuilder(BoostQueryNode.class, new BoostQueryNodeBuilder());
+ setBuilder(ModifierQueryNode.class, new ModifierQueryNodeBuilder());
+ setBuilder(WildcardQueryNode.class, new WildcardQueryNodeBuilder());
+ setBuilder(TokenizedPhraseQueryNode.class, new PhraseQueryNodeBuilder());
+ setBuilder(MatchNoDocsQueryNode.class, new MatchNoDocsQueryNodeBuilder());
+ setBuilder(PrefixWildcardQueryNode.class,
+ new PrefixWildcardQueryNodeBuilder());
+ setBuilder(TermRangeQueryNode.class, new TermRangeQueryNodeBuilder());
+ setBuilder(RegexpQueryNode.class, new RegexpQueryNodeBuilder());
+ setBuilder(SlopQueryNode.class, new SlopQueryNodeBuilder());
+ setBuilder(StandardBooleanQueryNode.class,
+ new StandardBooleanQueryNodeBuilder());
+ setBuilder(MultiPhraseQueryNode.class, new MultiPhraseQueryNodeBuilder());
+ setBuilder(MatchAllDocsQueryNode.class, new MatchAllDocsQueryNodeBuilder());
+ }
+
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarParser.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarParser.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarParser.java (revision 0)
@@ -0,0 +1,6655 @@
+// $ANTLR 3.4 /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g 2013-05-22 18:30:46
+
+ package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.antlr.runtime.tree.*;
+
+
+@SuppressWarnings({"all", "warnings", "unchecked"})
+public class StandardLuceneGrammarParser extends UnforgivingParser {
+ public static final String[] tokenNames = new String[] {
+ "", "", "", "", "AMPER", "AND", "ATOM", "BOOST", "CARAT", "CLAUSE", "COLON", "DATE_TOKEN", "DQUOTE", "ESC_CHAR", "FIELD", "FUZZY", "INT", "LBRACK", "LCURLY", "LPAREN", "MINUS", "MODIFIER", "NEAR", "NOT", "NUMBER", "OPERATOR", "OR", "PHRASE", "PHRASE_ANYTHING", "PLUS", "QANYTHING", "QDATE", "QMARK", "QNORMAL", "QPHRASE", "QPHRASETRUNC", "QRANGEEX", "QRANGEIN", "QTRUNCATED", "RBRACK", "RCURLY", "RPAREN", "SQUOTE", "STAR", "TERM_CHAR", "TERM_NORMAL", "TERM_START_CHAR", "TERM_TRUNCATED", "TILDE", "TMODIFIER", "TO", "VBAR", "WS", "'/'"
+ };
+
+ public static final int EOF=-1;
+ public static final int T__53=53;
+ public static final int AMPER=4;
+ public static final int AND=5;
+ public static final int ATOM=6;
+ public static final int BOOST=7;
+ public static final int CARAT=8;
+ public static final int CLAUSE=9;
+ public static final int COLON=10;
+ public static final int DATE_TOKEN=11;
+ public static final int DQUOTE=12;
+ public static final int ESC_CHAR=13;
+ public static final int FIELD=14;
+ public static final int FUZZY=15;
+ public static final int INT=16;
+ public static final int LBRACK=17;
+ public static final int LCURLY=18;
+ public static final int LPAREN=19;
+ public static final int MINUS=20;
+ public static final int MODIFIER=21;
+ public static final int NEAR=22;
+ public static final int NOT=23;
+ public static final int NUMBER=24;
+ public static final int OPERATOR=25;
+ public static final int OR=26;
+ public static final int PHRASE=27;
+ public static final int PHRASE_ANYTHING=28;
+ public static final int PLUS=29;
+ public static final int QANYTHING=30;
+ public static final int QDATE=31;
+ public static final int QMARK=32;
+ public static final int QNORMAL=33;
+ public static final int QPHRASE=34;
+ public static final int QPHRASETRUNC=35;
+ public static final int QRANGEEX=36;
+ public static final int QRANGEIN=37;
+ public static final int QTRUNCATED=38;
+ public static final int RBRACK=39;
+ public static final int RCURLY=40;
+ public static final int RPAREN=41;
+ public static final int SQUOTE=42;
+ public static final int STAR=43;
+ public static final int TERM_CHAR=44;
+ public static final int TERM_NORMAL=45;
+ public static final int TERM_START_CHAR=46;
+ public static final int TERM_TRUNCATED=47;
+ public static final int TILDE=48;
+ public static final int TMODIFIER=49;
+ public static final int TO=50;
+ public static final int VBAR=51;
+ public static final int WS=52;
+
+ // delegates
+ public UnforgivingParser[] getDelegates() {
+ return new UnforgivingParser[] {};
+ }
+
+ // delegators
+
+
+ public StandardLuceneGrammarParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public StandardLuceneGrammarParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+ }
+
+protected TreeAdaptor adaptor = new CommonTreeAdaptor();
+
+public void setTreeAdaptor(TreeAdaptor adaptor) {
+ this.adaptor = adaptor;
+}
+public TreeAdaptor getTreeAdaptor() {
+ return adaptor;
+}
+ public String[] getTokenNames() { return StandardLuceneGrammarParser.tokenNames; }
+ public String getGrammarFileName() { return "/dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g"; }
+
+
+ public static class mainQ_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "mainQ"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:100:1: mainQ : ( clauseOr )+ EOF -> ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ;
+ public final StandardLuceneGrammarParser.mainQ_return mainQ() throws RecognitionException {
+ StandardLuceneGrammarParser.mainQ_return retval = new StandardLuceneGrammarParser.mainQ_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token EOF2=null;
+ StandardLuceneGrammarParser.clauseOr_return clauseOr1 =null;
+
+
+ Object EOF2_tree=null;
+ RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
+ RewriteRuleSubtreeStream stream_clauseOr=new RewriteRuleSubtreeStream(adaptor,"rule clauseOr");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:100:7: ( ( clauseOr )+ EOF -> ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:101:2: ( clauseOr )+ EOF
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:101:2: ( clauseOr )+
+ int cnt1=0;
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( ((LA1_0 >= LBRACK && LA1_0 <= MINUS)||LA1_0==NUMBER||(LA1_0 >= PHRASE && LA1_0 <= PLUS)||LA1_0==QMARK||LA1_0==STAR||LA1_0==TERM_NORMAL||LA1_0==TERM_TRUNCATED) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:101:2: clauseOr
+ {
+ pushFollow(FOLLOW_clauseOr_in_mainQ209);
+ clauseOr1=clauseOr();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseOr.add(clauseOr1.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt1 >= 1 ) break loop1;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(1, input);
+ throw eee;
+ }
+ cnt1++;
+ } while (true);
+
+
+ EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_mainQ212); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_EOF.add(EOF2);
+
+
+ // AST REWRITE
+ // elements: clauseOr
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 101:16: -> ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:101:19: ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "DEFOP")
+ , root_1);
+
+ if ( !(stream_clauseOr.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseOr.hasNext() ) {
+ adaptor.addChild(root_1, stream_clauseOr.nextTree());
+
+ }
+ stream_clauseOr.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "mainQ"
+
+
+ public static class clauseOr_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "clauseOr"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:105:1: clauseOr : (first= clauseAnd -> $first) ( or others= clauseAnd -> ^( OPERATOR[\"OR\"] ( clauseAnd )+ ) )* ;
+ public final StandardLuceneGrammarParser.clauseOr_return clauseOr() throws RecognitionException {
+ StandardLuceneGrammarParser.clauseOr_return retval = new StandardLuceneGrammarParser.clauseOr_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.clauseAnd_return first =null;
+
+ StandardLuceneGrammarParser.clauseAnd_return others =null;
+
+ StandardLuceneGrammarParser.or_return or3 =null;
+
+
+ RewriteRuleSubtreeStream stream_clauseAnd=new RewriteRuleSubtreeStream(adaptor,"rule clauseAnd");
+ RewriteRuleSubtreeStream stream_or=new RewriteRuleSubtreeStream(adaptor,"rule or");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:106:3: ( (first= clauseAnd -> $first) ( or others= clauseAnd -> ^( OPERATOR[\"OR\"] ( clauseAnd )+ ) )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:106:5: (first= clauseAnd -> $first) ( or others= clauseAnd -> ^( OPERATOR[\"OR\"] ( clauseAnd )+ ) )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:106:5: (first= clauseAnd -> $first)
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:106:6: first= clauseAnd
+ {
+ pushFollow(FOLLOW_clauseAnd_in_clauseOr243);
+ first=clauseAnd();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseAnd.add(first.getTree());
+
+ // AST REWRITE
+ // elements: first
+ // token labels:
+ // rule labels: retval, first
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_first=new RewriteRuleSubtreeStream(adaptor,"rule first",first!=null?first.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 106:22: -> $first
+ {
+ adaptor.addChild(root_0, stream_first.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:106:33: ( or others= clauseAnd -> ^( OPERATOR[\"OR\"] ( clauseAnd )+ ) )*
+ loop2:
+ do {
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0==OR) ) {
+ alt2=1;
+ }
+
+
+ switch (alt2) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:106:34: or others= clauseAnd
+ {
+ pushFollow(FOLLOW_or_in_clauseOr252);
+ or3=or();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_or.add(or3.getTree());
+
+ pushFollow(FOLLOW_clauseAnd_in_clauseOr256);
+ others=clauseAnd();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseAnd.add(others.getTree());
+
+ // AST REWRITE
+ // elements: clauseAnd
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 106:54: -> ^( OPERATOR[\"OR\"] ( clauseAnd )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:106:57: ^( OPERATOR[\"OR\"] ( clauseAnd )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "OR")
+ , root_1);
+
+ if ( !(stream_clauseAnd.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseAnd.hasNext() ) {
+ adaptor.addChild(root_1, stream_clauseAnd.nextTree());
+
+ }
+ stream_clauseAnd.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ default :
+ break loop2;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "clauseOr"
+
+
+ public static class clauseAnd_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "clauseAnd"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:109:1: clauseAnd : (first= clauseNot -> $first) ( and others= clauseNot -> ^( OPERATOR[\"AND\"] ( clauseNot )+ ) )* ;
+ public final StandardLuceneGrammarParser.clauseAnd_return clauseAnd() throws RecognitionException {
+ StandardLuceneGrammarParser.clauseAnd_return retval = new StandardLuceneGrammarParser.clauseAnd_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.clauseNot_return first =null;
+
+ StandardLuceneGrammarParser.clauseNot_return others =null;
+
+ StandardLuceneGrammarParser.and_return and4 =null;
+
+
+ RewriteRuleSubtreeStream stream_clauseNot=new RewriteRuleSubtreeStream(adaptor,"rule clauseNot");
+ RewriteRuleSubtreeStream stream_and=new RewriteRuleSubtreeStream(adaptor,"rule and");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:110:3: ( (first= clauseNot -> $first) ( and others= clauseNot -> ^( OPERATOR[\"AND\"] ( clauseNot )+ ) )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:110:5: (first= clauseNot -> $first) ( and others= clauseNot -> ^( OPERATOR[\"AND\"] ( clauseNot )+ ) )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:110:5: (first= clauseNot -> $first)
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:110:6: first= clauseNot
+ {
+ pushFollow(FOLLOW_clauseNot_in_clauseAnd285);
+ first=clauseNot();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseNot.add(first.getTree());
+
+ // AST REWRITE
+ // elements: first
+ // token labels:
+ // rule labels: retval, first
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_first=new RewriteRuleSubtreeStream(adaptor,"rule first",first!=null?first.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 110:23: -> $first
+ {
+ adaptor.addChild(root_0, stream_first.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:110:34: ( and others= clauseNot -> ^( OPERATOR[\"AND\"] ( clauseNot )+ ) )*
+ loop3:
+ do {
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0==AND) ) {
+ alt3=1;
+ }
+
+
+ switch (alt3) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:110:35: and others= clauseNot
+ {
+ pushFollow(FOLLOW_and_in_clauseAnd295);
+ and4=and();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_and.add(and4.getTree());
+
+ pushFollow(FOLLOW_clauseNot_in_clauseAnd299);
+ others=clauseNot();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseNot.add(others.getTree());
+
+ // AST REWRITE
+ // elements: clauseNot
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 110:56: -> ^( OPERATOR[\"AND\"] ( clauseNot )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:110:59: ^( OPERATOR[\"AND\"] ( clauseNot )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "AND")
+ , root_1);
+
+ if ( !(stream_clauseNot.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseNot.hasNext() ) {
+ adaptor.addChild(root_1, stream_clauseNot.nextTree());
+
+ }
+ stream_clauseNot.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ default :
+ break loop3;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "clauseAnd"
+
+
+ public static class clauseNot_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "clauseNot"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:113:1: clauseNot : (first= clauseNear -> $first) ( not others= clauseNear -> ^( OPERATOR[\"NOT\"] ( clauseNear )+ ) )* ;
+ public final StandardLuceneGrammarParser.clauseNot_return clauseNot() throws RecognitionException {
+ StandardLuceneGrammarParser.clauseNot_return retval = new StandardLuceneGrammarParser.clauseNot_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.clauseNear_return first =null;
+
+ StandardLuceneGrammarParser.clauseNear_return others =null;
+
+ StandardLuceneGrammarParser.not_return not5 =null;
+
+
+ RewriteRuleSubtreeStream stream_not=new RewriteRuleSubtreeStream(adaptor,"rule not");
+ RewriteRuleSubtreeStream stream_clauseNear=new RewriteRuleSubtreeStream(adaptor,"rule clauseNear");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:114:3: ( (first= clauseNear -> $first) ( not others= clauseNear -> ^( OPERATOR[\"NOT\"] ( clauseNear )+ ) )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:114:5: (first= clauseNear -> $first) ( not others= clauseNear -> ^( OPERATOR[\"NOT\"] ( clauseNear )+ ) )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:114:5: (first= clauseNear -> $first)
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:114:6: first= clauseNear
+ {
+ pushFollow(FOLLOW_clauseNear_in_clauseNot330);
+ first=clauseNear();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseNear.add(first.getTree());
+
+ // AST REWRITE
+ // elements: first
+ // token labels:
+ // rule labels: retval, first
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_first=new RewriteRuleSubtreeStream(adaptor,"rule first",first!=null?first.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 114:23: -> $first
+ {
+ adaptor.addChild(root_0, stream_first.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:114:34: ( not others= clauseNear -> ^( OPERATOR[\"NOT\"] ( clauseNear )+ ) )*
+ loop4:
+ do {
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==AND) ) {
+ int LA4_1 = input.LA(2);
+
+ if ( (LA4_1==NOT) ) {
+ alt4=1;
+ }
+
+
+ }
+ else if ( (LA4_0==NOT) ) {
+ alt4=1;
+ }
+
+
+ switch (alt4) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:114:35: not others= clauseNear
+ {
+ pushFollow(FOLLOW_not_in_clauseNot339);
+ not5=not();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_not.add(not5.getTree());
+
+ pushFollow(FOLLOW_clauseNear_in_clauseNot343);
+ others=clauseNear();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseNear.add(others.getTree());
+
+ // AST REWRITE
+ // elements: clauseNear
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 114:57: -> ^( OPERATOR[\"NOT\"] ( clauseNear )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:114:60: ^( OPERATOR[\"NOT\"] ( clauseNear )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "NOT")
+ , root_1);
+
+ if ( !(stream_clauseNear.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseNear.hasNext() ) {
+ adaptor.addChild(root_1, stream_clauseNear.nextTree());
+
+ }
+ stream_clauseNear.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ default :
+ break loop4;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "clauseNot"
+
+
+ public static class clauseNear_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "clauseNear"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:117:1: clauseNear : (first= clauseBasic -> $first) ( near others= clauseBasic -> ^( near ( clauseBasic )+ ) )* ;
+ public final StandardLuceneGrammarParser.clauseNear_return clauseNear() throws RecognitionException {
+ StandardLuceneGrammarParser.clauseNear_return retval = new StandardLuceneGrammarParser.clauseNear_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.clauseBasic_return first =null;
+
+ StandardLuceneGrammarParser.clauseBasic_return others =null;
+
+ StandardLuceneGrammarParser.near_return near6 =null;
+
+
+ RewriteRuleSubtreeStream stream_clauseBasic=new RewriteRuleSubtreeStream(adaptor,"rule clauseBasic");
+ RewriteRuleSubtreeStream stream_near=new RewriteRuleSubtreeStream(adaptor,"rule near");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:118:3: ( (first= clauseBasic -> $first) ( near others= clauseBasic -> ^( near ( clauseBasic )+ ) )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:118:5: (first= clauseBasic -> $first) ( near others= clauseBasic -> ^( near ( clauseBasic )+ ) )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:118:5: (first= clauseBasic -> $first)
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:118:6: first= clauseBasic
+ {
+ pushFollow(FOLLOW_clauseBasic_in_clauseNear374);
+ first=clauseBasic();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseBasic.add(first.getTree());
+
+ // AST REWRITE
+ // elements: first
+ // token labels:
+ // rule labels: retval, first
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_first=new RewriteRuleSubtreeStream(adaptor,"rule first",first!=null?first.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 118:24: -> $first
+ {
+ adaptor.addChild(root_0, stream_first.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:118:35: ( near others= clauseBasic -> ^( near ( clauseBasic )+ ) )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0==NEAR) ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:118:36: near others= clauseBasic
+ {
+ pushFollow(FOLLOW_near_in_clauseNear383);
+ near6=near();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_near.add(near6.getTree());
+
+ pushFollow(FOLLOW_clauseBasic_in_clauseNear387);
+ others=clauseBasic();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseBasic.add(others.getTree());
+
+ // AST REWRITE
+ // elements: near, clauseBasic
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 118:60: -> ^( near ( clauseBasic )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:118:63: ^( near ( clauseBasic )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(stream_near.nextNode(), root_1);
+
+ if ( !(stream_clauseBasic.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseBasic.hasNext() ) {
+ adaptor.addChild(root_1, stream_clauseBasic.nextTree());
+
+ }
+ stream_clauseBasic.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "clauseNear"
+
+
+ public static class clauseBasic_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "clauseBasic"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:121:1: clauseBasic : ( ( modifier LPAREN ( clauseOr )+ RPAREN )=> ( modifier )? LPAREN ( clauseOr )+ RPAREN ( term_modifier )? -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) ) ) | ( LPAREN ( clauseOr )+ RPAREN term_modifier )=> ( modifier )? LPAREN ( clauseOr )+ RPAREN ( term_modifier )? -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) ) ) | ( LPAREN )=> LPAREN ( clauseOr )+ RPAREN -> ( clauseOr )+ | atom );
+ public final StandardLuceneGrammarParser.clauseBasic_return clauseBasic() throws RecognitionException {
+ StandardLuceneGrammarParser.clauseBasic_return retval = new StandardLuceneGrammarParser.clauseBasic_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token LPAREN8=null;
+ Token RPAREN10=null;
+ Token LPAREN13=null;
+ Token RPAREN15=null;
+ Token LPAREN17=null;
+ Token RPAREN19=null;
+ StandardLuceneGrammarParser.modifier_return modifier7 =null;
+
+ StandardLuceneGrammarParser.clauseOr_return clauseOr9 =null;
+
+ StandardLuceneGrammarParser.term_modifier_return term_modifier11 =null;
+
+ StandardLuceneGrammarParser.modifier_return modifier12 =null;
+
+ StandardLuceneGrammarParser.clauseOr_return clauseOr14 =null;
+
+ StandardLuceneGrammarParser.term_modifier_return term_modifier16 =null;
+
+ StandardLuceneGrammarParser.clauseOr_return clauseOr18 =null;
+
+ StandardLuceneGrammarParser.atom_return atom20 =null;
+
+
+ Object LPAREN8_tree=null;
+ Object RPAREN10_tree=null;
+ Object LPAREN13_tree=null;
+ Object RPAREN15_tree=null;
+ Object LPAREN17_tree=null;
+ Object RPAREN19_tree=null;
+ RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
+ RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
+ RewriteRuleSubtreeStream stream_modifier=new RewriteRuleSubtreeStream(adaptor,"rule modifier");
+ RewriteRuleSubtreeStream stream_term_modifier=new RewriteRuleSubtreeStream(adaptor,"rule term_modifier");
+ RewriteRuleSubtreeStream stream_clauseOr=new RewriteRuleSubtreeStream(adaptor,"rule clauseOr");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:122:2: ( ( modifier LPAREN ( clauseOr )+ RPAREN )=> ( modifier )? LPAREN ( clauseOr )+ RPAREN ( term_modifier )? -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) ) ) | ( LPAREN ( clauseOr )+ RPAREN term_modifier )=> ( modifier )? LPAREN ( clauseOr )+ RPAREN ( term_modifier )? -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) ) ) | ( LPAREN )=> LPAREN ( clauseOr )+ RPAREN -> ( clauseOr )+ | atom )
+ int alt13=4;
+ switch ( input.LA(1) ) {
+ case PLUS:
+ {
+ int LA13_1 = input.LA(2);
+
+ if ( (synpred1_StandardLuceneGrammar()) ) {
+ alt13=1;
+ }
+ else if ( (synpred2_StandardLuceneGrammar()) ) {
+ alt13=2;
+ }
+ else if ( (true) ) {
+ alt13=4;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 13, 1, input);
+
+ throw nvae;
+
+ }
+ }
+ break;
+ case MINUS:
+ {
+ int LA13_2 = input.LA(2);
+
+ if ( (synpred1_StandardLuceneGrammar()) ) {
+ alt13=1;
+ }
+ else if ( (synpred2_StandardLuceneGrammar()) ) {
+ alt13=2;
+ }
+ else if ( (true) ) {
+ alt13=4;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 13, 2, input);
+
+ throw nvae;
+
+ }
+ }
+ break;
+ case LPAREN:
+ {
+ int LA13_3 = input.LA(2);
+
+ if ( (synpred1_StandardLuceneGrammar()) ) {
+ alt13=1;
+ }
+ else if ( (synpred2_StandardLuceneGrammar()) ) {
+ alt13=2;
+ }
+ else if ( (synpred3_StandardLuceneGrammar()) ) {
+ alt13=3;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 13, 3, input);
+
+ throw nvae;
+
+ }
+ }
+ break;
+ case LBRACK:
+ case LCURLY:
+ case NUMBER:
+ case PHRASE:
+ case PHRASE_ANYTHING:
+ case QMARK:
+ case STAR:
+ case TERM_NORMAL:
+ case TERM_TRUNCATED:
+ {
+ alt13=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 13, 0, input);
+
+ throw nvae;
+
+ }
+
+ switch (alt13) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:2: ( modifier LPAREN ( clauseOr )+ RPAREN )=> ( modifier )? LPAREN ( clauseOr )+ RPAREN ( term_modifier )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:40: ( modifier )?
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==MINUS||LA6_0==PLUS) ) {
+ alt6=1;
+ }
+ switch (alt6) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:40: modifier
+ {
+ pushFollow(FOLLOW_modifier_in_clauseBasic428);
+ modifier7=modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_modifier.add(modifier7.getTree());
+
+ }
+ break;
+
+ }
+
+
+ LPAREN8=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_clauseBasic431); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN8);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:57: ( clauseOr )+
+ int cnt7=0;
+ loop7:
+ do {
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( ((LA7_0 >= LBRACK && LA7_0 <= MINUS)||LA7_0==NUMBER||(LA7_0 >= PHRASE && LA7_0 <= PLUS)||LA7_0==QMARK||LA7_0==STAR||LA7_0==TERM_NORMAL||LA7_0==TERM_TRUNCATED) ) {
+ alt7=1;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:57: clauseOr
+ {
+ pushFollow(FOLLOW_clauseOr_in_clauseBasic433);
+ clauseOr9=clauseOr();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseOr.add(clauseOr9.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt7 >= 1 ) break loop7;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(7, input);
+ throw eee;
+ }
+ cnt7++;
+ } while (true);
+
+
+ RPAREN10=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_clauseBasic436); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN10);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:74: ( term_modifier )?
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0==CARAT||LA8_0==TILDE) ) {
+ alt8=1;
+ }
+ switch (alt8) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:74: term_modifier
+ {
+ pushFollow(FOLLOW_term_modifier_in_clauseBasic438);
+ term_modifier11=term_modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_term_modifier.add(term_modifier11.getTree());
+
+ }
+ break;
+
+ }
+
+
+ // AST REWRITE
+ // elements: clauseOr, term_modifier, modifier
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 124:3: -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) ) )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:124:6: ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) ) )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(CLAUSE, "CLAUSE")
+ , root_1);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:124:15: ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) )
+ {
+ Object root_2 = (Object)adaptor.nil();
+ root_2 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(MODIFIER, "MODIFIER")
+ , root_2);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:124:26: ( modifier )?
+ if ( stream_modifier.hasNext() ) {
+ adaptor.addChild(root_2, stream_modifier.nextTree());
+
+ }
+ stream_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:124:36: ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) )
+ {
+ Object root_3 = (Object)adaptor.nil();
+ root_3 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(TMODIFIER, "TMODIFIER")
+ , root_3);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:124:48: ( term_modifier )?
+ if ( stream_term_modifier.hasNext() ) {
+ adaptor.addChild(root_3, stream_term_modifier.nextTree());
+
+ }
+ stream_term_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:124:63: ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ )
+ {
+ Object root_4 = (Object)adaptor.nil();
+ root_4 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "DEFOP")
+ , root_4);
+
+ if ( !(stream_clauseOr.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseOr.hasNext() ) {
+ adaptor.addChild(root_4, stream_clauseOr.nextTree());
+
+ }
+ stream_clauseOr.reset();
+
+ adaptor.addChild(root_3, root_4);
+ }
+
+ adaptor.addChild(root_2, root_3);
+ }
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:4: ( LPAREN ( clauseOr )+ RPAREN term_modifier )=> ( modifier )? LPAREN ( clauseOr )+ RPAREN ( term_modifier )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:46: ( modifier )?
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0==MINUS||LA9_0==PLUS) ) {
+ alt9=1;
+ }
+ switch (alt9) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:46: modifier
+ {
+ pushFollow(FOLLOW_modifier_in_clauseBasic488);
+ modifier12=modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_modifier.add(modifier12.getTree());
+
+ }
+ break;
+
+ }
+
+
+ LPAREN13=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_clauseBasic491); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN13);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:63: ( clauseOr )+
+ int cnt10=0;
+ loop10:
+ do {
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( ((LA10_0 >= LBRACK && LA10_0 <= MINUS)||LA10_0==NUMBER||(LA10_0 >= PHRASE && LA10_0 <= PLUS)||LA10_0==QMARK||LA10_0==STAR||LA10_0==TERM_NORMAL||LA10_0==TERM_TRUNCATED) ) {
+ alt10=1;
+ }
+
+
+ switch (alt10) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:63: clauseOr
+ {
+ pushFollow(FOLLOW_clauseOr_in_clauseBasic493);
+ clauseOr14=clauseOr();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseOr.add(clauseOr14.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt10 >= 1 ) break loop10;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(10, input);
+ throw eee;
+ }
+ cnt10++;
+ } while (true);
+
+
+ RPAREN15=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_clauseBasic496); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN15);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:80: ( term_modifier )?
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0==CARAT||LA11_0==TILDE) ) {
+ alt11=1;
+ }
+ switch (alt11) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:80: term_modifier
+ {
+ pushFollow(FOLLOW_term_modifier_in_clauseBasic498);
+ term_modifier16=term_modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_term_modifier.add(term_modifier16.getTree());
+
+ }
+ break;
+
+ }
+
+
+ // AST REWRITE
+ // elements: term_modifier, clauseOr, modifier
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 126:3: -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) ) )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:126:6: ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) ) )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(CLAUSE, "CLAUSE")
+ , root_1);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:126:15: ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ) )
+ {
+ Object root_2 = (Object)adaptor.nil();
+ root_2 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(MODIFIER, "MODIFIER")
+ , root_2);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:126:26: ( modifier )?
+ if ( stream_modifier.hasNext() ) {
+ adaptor.addChild(root_2, stream_modifier.nextTree());
+
+ }
+ stream_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:126:36: ^( TMODIFIER ( term_modifier )? ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) )
+ {
+ Object root_3 = (Object)adaptor.nil();
+ root_3 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(TMODIFIER, "TMODIFIER")
+ , root_3);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:126:48: ( term_modifier )?
+ if ( stream_term_modifier.hasNext() ) {
+ adaptor.addChild(root_3, stream_term_modifier.nextTree());
+
+ }
+ stream_term_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:126:63: ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ )
+ {
+ Object root_4 = (Object)adaptor.nil();
+ root_4 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "DEFOP")
+ , root_4);
+
+ if ( !(stream_clauseOr.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseOr.hasNext() ) {
+ adaptor.addChild(root_4, stream_clauseOr.nextTree());
+
+ }
+ stream_clauseOr.reset();
+
+ adaptor.addChild(root_3, root_4);
+ }
+
+ adaptor.addChild(root_2, root_3);
+ }
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 3 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:127:4: ( LPAREN )=> LPAREN ( clauseOr )+ RPAREN
+ {
+ LPAREN17=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_clauseBasic543); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN17);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:127:24: ( clauseOr )+
+ int cnt12=0;
+ loop12:
+ do {
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( ((LA12_0 >= LBRACK && LA12_0 <= MINUS)||LA12_0==NUMBER||(LA12_0 >= PHRASE && LA12_0 <= PLUS)||LA12_0==QMARK||LA12_0==STAR||LA12_0==TERM_NORMAL||LA12_0==TERM_TRUNCATED) ) {
+ alt12=1;
+ }
+
+
+ switch (alt12) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:127:24: clauseOr
+ {
+ pushFollow(FOLLOW_clauseOr_in_clauseBasic545);
+ clauseOr18=clauseOr();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseOr.add(clauseOr18.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt12 >= 1 ) break loop12;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(12, input);
+ throw eee;
+ }
+ cnt12++;
+ } while (true);
+
+
+ RPAREN19=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_clauseBasic548); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN19);
+
+
+ // AST REWRITE
+ // elements: clauseOr
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 128:3: -> ( clauseOr )+
+ {
+ if ( !(stream_clauseOr.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseOr.hasNext() ) {
+ adaptor.addChild(root_0, stream_clauseOr.nextTree());
+
+ }
+ stream_clauseOr.reset();
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 4 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:129:4: atom
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ pushFollow(FOLLOW_atom_in_clauseBasic560);
+ atom20=atom();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, atom20.getTree());
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "clauseBasic"
+
+
+ public static class atom_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "atom"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:133:1: atom : ( ( modifier )? field multi_value ( term_modifier )? -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD field multi_value ) ) ) ) | ( modifier )? ( field )? value ( term_modifier )? -> ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD ( field )? value ) ) ) | ( modifier )? ( STAR COLON )? STAR -> ^( MODIFIER ( modifier )? ^( QANYTHING STAR[\"*\"] ) ) );
+ public final StandardLuceneGrammarParser.atom_return atom() throws RecognitionException {
+ StandardLuceneGrammarParser.atom_return retval = new StandardLuceneGrammarParser.atom_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token STAR30=null;
+ Token COLON31=null;
+ Token STAR32=null;
+ StandardLuceneGrammarParser.modifier_return modifier21 =null;
+
+ StandardLuceneGrammarParser.field_return field22 =null;
+
+ StandardLuceneGrammarParser.multi_value_return multi_value23 =null;
+
+ StandardLuceneGrammarParser.term_modifier_return term_modifier24 =null;
+
+ StandardLuceneGrammarParser.modifier_return modifier25 =null;
+
+ StandardLuceneGrammarParser.field_return field26 =null;
+
+ StandardLuceneGrammarParser.value_return value27 =null;
+
+ StandardLuceneGrammarParser.term_modifier_return term_modifier28 =null;
+
+ StandardLuceneGrammarParser.modifier_return modifier29 =null;
+
+
+ Object STAR30_tree=null;
+ Object COLON31_tree=null;
+ Object STAR32_tree=null;
+ RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
+ RewriteRuleTokenStream stream_STAR=new RewriteRuleTokenStream(adaptor,"token STAR");
+ RewriteRuleSubtreeStream stream_modifier=new RewriteRuleSubtreeStream(adaptor,"rule modifier");
+ RewriteRuleSubtreeStream stream_field=new RewriteRuleSubtreeStream(adaptor,"rule field");
+ RewriteRuleSubtreeStream stream_term_modifier=new RewriteRuleSubtreeStream(adaptor,"rule term_modifier");
+ RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
+ RewriteRuleSubtreeStream stream_multi_value=new RewriteRuleSubtreeStream(adaptor,"rule multi_value");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:134:2: ( ( modifier )? field multi_value ( term_modifier )? -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD field multi_value ) ) ) ) | ( modifier )? ( field )? value ( term_modifier )? -> ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD ( field )? value ) ) ) | ( modifier )? ( STAR COLON )? STAR -> ^( MODIFIER ( modifier )? ^( QANYTHING STAR[\"*\"] ) ) )
+ int alt21=3;
+ switch ( input.LA(1) ) {
+ case PLUS:
+ {
+ switch ( input.LA(2) ) {
+ case TERM_NORMAL:
+ {
+ int LA21_3 = input.LA(3);
+
+ if ( (LA21_3==COLON) ) {
+ int LA21_6 = input.LA(4);
+
+ if ( (LA21_6==LPAREN) ) {
+ alt21=1;
+ }
+ else if ( ((LA21_6 >= LBRACK && LA21_6 <= LCURLY)||LA21_6==NUMBER||(LA21_6 >= PHRASE && LA21_6 <= PHRASE_ANYTHING)||LA21_6==QMARK||LA21_6==TERM_NORMAL||LA21_6==TERM_TRUNCATED) ) {
+ alt21=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 6, input);
+
+ throw nvae;
+
+ }
+ }
+ else if ( (LA21_3==EOF||LA21_3==AND||LA21_3==CARAT||(LA21_3 >= LBRACK && LA21_3 <= MINUS)||(LA21_3 >= NEAR && LA21_3 <= NUMBER)||(LA21_3 >= OR && LA21_3 <= PLUS)||LA21_3==QMARK||LA21_3==RPAREN||LA21_3==STAR||LA21_3==TERM_NORMAL||(LA21_3 >= TERM_TRUNCATED && LA21_3 <= TILDE)) ) {
+ alt21=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 3, input);
+
+ throw nvae;
+
+ }
+ }
+ break;
+ case LBRACK:
+ case LCURLY:
+ case NUMBER:
+ case PHRASE:
+ case PHRASE_ANYTHING:
+ case QMARK:
+ case TERM_TRUNCATED:
+ {
+ alt21=2;
+ }
+ break;
+ case STAR:
+ {
+ alt21=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 1, input);
+
+ throw nvae;
+
+ }
+
+ }
+ break;
+ case MINUS:
+ {
+ switch ( input.LA(2) ) {
+ case TERM_NORMAL:
+ {
+ int LA21_3 = input.LA(3);
+
+ if ( (LA21_3==COLON) ) {
+ int LA21_6 = input.LA(4);
+
+ if ( (LA21_6==LPAREN) ) {
+ alt21=1;
+ }
+ else if ( ((LA21_6 >= LBRACK && LA21_6 <= LCURLY)||LA21_6==NUMBER||(LA21_6 >= PHRASE && LA21_6 <= PHRASE_ANYTHING)||LA21_6==QMARK||LA21_6==TERM_NORMAL||LA21_6==TERM_TRUNCATED) ) {
+ alt21=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 6, input);
+
+ throw nvae;
+
+ }
+ }
+ else if ( (LA21_3==EOF||LA21_3==AND||LA21_3==CARAT||(LA21_3 >= LBRACK && LA21_3 <= MINUS)||(LA21_3 >= NEAR && LA21_3 <= NUMBER)||(LA21_3 >= OR && LA21_3 <= PLUS)||LA21_3==QMARK||LA21_3==RPAREN||LA21_3==STAR||LA21_3==TERM_NORMAL||(LA21_3 >= TERM_TRUNCATED && LA21_3 <= TILDE)) ) {
+ alt21=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 3, input);
+
+ throw nvae;
+
+ }
+ }
+ break;
+ case LBRACK:
+ case LCURLY:
+ case NUMBER:
+ case PHRASE:
+ case PHRASE_ANYTHING:
+ case QMARK:
+ case TERM_TRUNCATED:
+ {
+ alt21=2;
+ }
+ break;
+ case STAR:
+ {
+ alt21=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 2, input);
+
+ throw nvae;
+
+ }
+
+ }
+ break;
+ case TERM_NORMAL:
+ {
+ int LA21_3 = input.LA(2);
+
+ if ( (LA21_3==COLON) ) {
+ int LA21_6 = input.LA(3);
+
+ if ( (LA21_6==LPAREN) ) {
+ alt21=1;
+ }
+ else if ( ((LA21_6 >= LBRACK && LA21_6 <= LCURLY)||LA21_6==NUMBER||(LA21_6 >= PHRASE && LA21_6 <= PHRASE_ANYTHING)||LA21_6==QMARK||LA21_6==TERM_NORMAL||LA21_6==TERM_TRUNCATED) ) {
+ alt21=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 6, input);
+
+ throw nvae;
+
+ }
+ }
+ else if ( (LA21_3==EOF||LA21_3==AND||LA21_3==CARAT||(LA21_3 >= LBRACK && LA21_3 <= MINUS)||(LA21_3 >= NEAR && LA21_3 <= NUMBER)||(LA21_3 >= OR && LA21_3 <= PLUS)||LA21_3==QMARK||LA21_3==RPAREN||LA21_3==STAR||LA21_3==TERM_NORMAL||(LA21_3 >= TERM_TRUNCATED && LA21_3 <= TILDE)) ) {
+ alt21=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 3, input);
+
+ throw nvae;
+
+ }
+ }
+ break;
+ case LBRACK:
+ case LCURLY:
+ case NUMBER:
+ case PHRASE:
+ case PHRASE_ANYTHING:
+ case QMARK:
+ case TERM_TRUNCATED:
+ {
+ alt21=2;
+ }
+ break;
+ case STAR:
+ {
+ alt21=3;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 21, 0, input);
+
+ throw nvae;
+
+ }
+
+ switch (alt21) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:135:2: ( modifier )? field multi_value ( term_modifier )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:135:2: ( modifier )?
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0==MINUS||LA14_0==PLUS) ) {
+ alt14=1;
+ }
+ switch (alt14) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:135:2: modifier
+ {
+ pushFollow(FOLLOW_modifier_in_atom581);
+ modifier21=modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_modifier.add(modifier21.getTree());
+
+ }
+ break;
+
+ }
+
+
+ pushFollow(FOLLOW_field_in_atom584);
+ field22=field();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_field.add(field22.getTree());
+
+ pushFollow(FOLLOW_multi_value_in_atom586);
+ multi_value23=multi_value();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multi_value.add(multi_value23.getTree());
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:135:30: ( term_modifier )?
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0==CARAT||LA15_0==TILDE) ) {
+ alt15=1;
+ }
+ switch (alt15) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:135:30: term_modifier
+ {
+ pushFollow(FOLLOW_term_modifier_in_atom588);
+ term_modifier24=term_modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_term_modifier.add(term_modifier24.getTree());
+
+ }
+ break;
+
+ }
+
+
+ // AST REWRITE
+ // elements: multi_value, field, term_modifier, modifier
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 136:3: -> ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD field multi_value ) ) ) )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:136:6: ^( CLAUSE ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD field multi_value ) ) ) )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(CLAUSE, "CLAUSE")
+ , root_1);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:136:15: ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD field multi_value ) ) )
+ {
+ Object root_2 = (Object)adaptor.nil();
+ root_2 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(MODIFIER, "MODIFIER")
+ , root_2);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:136:26: ( modifier )?
+ if ( stream_modifier.hasNext() ) {
+ adaptor.addChild(root_2, stream_modifier.nextTree());
+
+ }
+ stream_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:136:36: ^( TMODIFIER ( term_modifier )? ^( FIELD field multi_value ) )
+ {
+ Object root_3 = (Object)adaptor.nil();
+ root_3 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(TMODIFIER, "TMODIFIER")
+ , root_3);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:136:48: ( term_modifier )?
+ if ( stream_term_modifier.hasNext() ) {
+ adaptor.addChild(root_3, stream_term_modifier.nextTree());
+
+ }
+ stream_term_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:136:63: ^( FIELD field multi_value )
+ {
+ Object root_4 = (Object)adaptor.nil();
+ root_4 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(FIELD, "FIELD")
+ , root_4);
+
+ adaptor.addChild(root_4, stream_field.nextTree());
+
+ adaptor.addChild(root_4, stream_multi_value.nextTree());
+
+ adaptor.addChild(root_3, root_4);
+ }
+
+ adaptor.addChild(root_2, root_3);
+ }
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:137:4: ( modifier )? ( field )? value ( term_modifier )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:137:4: ( modifier )?
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0==MINUS||LA16_0==PLUS) ) {
+ alt16=1;
+ }
+ switch (alt16) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:137:4: modifier
+ {
+ pushFollow(FOLLOW_modifier_in_atom624);
+ modifier25=modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_modifier.add(modifier25.getTree());
+
+ }
+ break;
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:137:14: ( field )?
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0==TERM_NORMAL) ) {
+ int LA17_1 = input.LA(2);
+
+ if ( (LA17_1==COLON) ) {
+ alt17=1;
+ }
+ }
+ switch (alt17) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:137:14: field
+ {
+ pushFollow(FOLLOW_field_in_atom627);
+ field26=field();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_field.add(field26.getTree());
+
+ }
+ break;
+
+ }
+
+
+ pushFollow(FOLLOW_value_in_atom630);
+ value27=value();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_value.add(value27.getTree());
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:137:27: ( term_modifier )?
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0==CARAT||LA18_0==TILDE) ) {
+ alt18=1;
+ }
+ switch (alt18) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:137:27: term_modifier
+ {
+ pushFollow(FOLLOW_term_modifier_in_atom632);
+ term_modifier28=term_modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_term_modifier.add(term_modifier28.getTree());
+
+ }
+ break;
+
+ }
+
+
+ // AST REWRITE
+ // elements: term_modifier, field, modifier, value
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 138:3: -> ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD ( field )? value ) ) )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:138:6: ^( MODIFIER ( modifier )? ^( TMODIFIER ( term_modifier )? ^( FIELD ( field )? value ) ) )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(MODIFIER, "MODIFIER")
+ , root_1);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:138:17: ( modifier )?
+ if ( stream_modifier.hasNext() ) {
+ adaptor.addChild(root_1, stream_modifier.nextTree());
+
+ }
+ stream_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:138:27: ^( TMODIFIER ( term_modifier )? ^( FIELD ( field )? value ) )
+ {
+ Object root_2 = (Object)adaptor.nil();
+ root_2 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(TMODIFIER, "TMODIFIER")
+ , root_2);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:138:39: ( term_modifier )?
+ if ( stream_term_modifier.hasNext() ) {
+ adaptor.addChild(root_2, stream_term_modifier.nextTree());
+
+ }
+ stream_term_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:138:54: ^( FIELD ( field )? value )
+ {
+ Object root_3 = (Object)adaptor.nil();
+ root_3 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(FIELD, "FIELD")
+ , root_3);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:138:62: ( field )?
+ if ( stream_field.hasNext() ) {
+ adaptor.addChild(root_3, stream_field.nextTree());
+
+ }
+ stream_field.reset();
+
+ adaptor.addChild(root_3, stream_value.nextTree());
+
+ adaptor.addChild(root_2, root_3);
+ }
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 3 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:139:4: ( modifier )? ( STAR COLON )? STAR
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:139:4: ( modifier )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0==MINUS||LA19_0==PLUS) ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:139:4: modifier
+ {
+ pushFollow(FOLLOW_modifier_in_atom666);
+ modifier29=modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_modifier.add(modifier29.getTree());
+
+ }
+ break;
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:139:14: ( STAR COLON )?
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0==STAR) ) {
+ int LA20_1 = input.LA(2);
+
+ if ( (LA20_1==COLON) ) {
+ alt20=1;
+ }
+ }
+ switch (alt20) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:139:15: STAR COLON
+ {
+ STAR30=(Token)match(input,STAR,FOLLOW_STAR_in_atom670); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_STAR.add(STAR30);
+
+
+ COLON31=(Token)match(input,COLON,FOLLOW_COLON_in_atom672); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_COLON.add(COLON31);
+
+
+ }
+ break;
+
+ }
+
+
+ STAR32=(Token)match(input,STAR,FOLLOW_STAR_in_atom676); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_STAR.add(STAR32);
+
+
+ // AST REWRITE
+ // elements: modifier, STAR
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 140:3: -> ^( MODIFIER ( modifier )? ^( QANYTHING STAR[\"*\"] ) )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:140:6: ^( MODIFIER ( modifier )? ^( QANYTHING STAR[\"*\"] ) )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(MODIFIER, "MODIFIER")
+ , root_1);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:140:17: ( modifier )?
+ if ( stream_modifier.hasNext() ) {
+ adaptor.addChild(root_1, stream_modifier.nextTree());
+
+ }
+ stream_modifier.reset();
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:140:27: ^( QANYTHING STAR[\"*\"] )
+ {
+ Object root_2 = (Object)adaptor.nil();
+ root_2 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QANYTHING, "QANYTHING")
+ , root_2);
+
+ adaptor.addChild(root_2,
+ (Object)adaptor.create(STAR, "*")
+ );
+
+ adaptor.addChild(root_1, root_2);
+ }
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "atom"
+
+
+ public static class field_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "field"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:144:1: field : TERM_NORMAL COLON -> TERM_NORMAL ;
+ public final StandardLuceneGrammarParser.field_return field() throws RecognitionException {
+ StandardLuceneGrammarParser.field_return retval = new StandardLuceneGrammarParser.field_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token TERM_NORMAL33=null;
+ Token COLON34=null;
+
+ Object TERM_NORMAL33_tree=null;
+ Object COLON34_tree=null;
+ RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
+ RewriteRuleTokenStream stream_TERM_NORMAL=new RewriteRuleTokenStream(adaptor,"token TERM_NORMAL");
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:145:2: ( TERM_NORMAL COLON -> TERM_NORMAL )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:146:2: TERM_NORMAL COLON
+ {
+ TERM_NORMAL33=(Token)match(input,TERM_NORMAL,FOLLOW_TERM_NORMAL_in_field713); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TERM_NORMAL.add(TERM_NORMAL33);
+
+
+ COLON34=(Token)match(input,COLON,FOLLOW_COLON_in_field715); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_COLON.add(COLON34);
+
+
+ // AST REWRITE
+ // elements: TERM_NORMAL
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 146:20: -> TERM_NORMAL
+ {
+ adaptor.addChild(root_0,
+ stream_TERM_NORMAL.nextNode()
+ );
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "field"
+
+
+ public static class value_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "value"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:149:1: value : ( range_term_in -> ^( QRANGEIN range_term_in ) | range_term_ex -> ^( QRANGEEX range_term_ex ) | normal -> ^( QNORMAL normal ) | truncated -> ^( QTRUNCATED truncated ) | quoted -> ^( QPHRASE quoted ) | quoted_truncated -> ^( QPHRASETRUNC quoted_truncated ) | QMARK -> ^( QTRUNCATED QMARK ) );
+ public final StandardLuceneGrammarParser.value_return value() throws RecognitionException {
+ StandardLuceneGrammarParser.value_return retval = new StandardLuceneGrammarParser.value_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token QMARK41=null;
+ StandardLuceneGrammarParser.range_term_in_return range_term_in35 =null;
+
+ StandardLuceneGrammarParser.range_term_ex_return range_term_ex36 =null;
+
+ StandardLuceneGrammarParser.normal_return normal37 =null;
+
+ StandardLuceneGrammarParser.truncated_return truncated38 =null;
+
+ StandardLuceneGrammarParser.quoted_return quoted39 =null;
+
+ StandardLuceneGrammarParser.quoted_truncated_return quoted_truncated40 =null;
+
+
+ Object QMARK41_tree=null;
+ RewriteRuleTokenStream stream_QMARK=new RewriteRuleTokenStream(adaptor,"token QMARK");
+ RewriteRuleSubtreeStream stream_range_term_ex=new RewriteRuleSubtreeStream(adaptor,"rule range_term_ex");
+ RewriteRuleSubtreeStream stream_normal=new RewriteRuleSubtreeStream(adaptor,"rule normal");
+ RewriteRuleSubtreeStream stream_quoted=new RewriteRuleSubtreeStream(adaptor,"rule quoted");
+ RewriteRuleSubtreeStream stream_quoted_truncated=new RewriteRuleSubtreeStream(adaptor,"rule quoted_truncated");
+ RewriteRuleSubtreeStream stream_truncated=new RewriteRuleSubtreeStream(adaptor,"rule truncated");
+ RewriteRuleSubtreeStream stream_range_term_in=new RewriteRuleSubtreeStream(adaptor,"rule range_term_in");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:150:2: ( range_term_in -> ^( QRANGEIN range_term_in ) | range_term_ex -> ^( QRANGEEX range_term_ex ) | normal -> ^( QNORMAL normal ) | truncated -> ^( QTRUNCATED truncated ) | quoted -> ^( QPHRASE quoted ) | quoted_truncated -> ^( QPHRASETRUNC quoted_truncated ) | QMARK -> ^( QTRUNCATED QMARK ) )
+ int alt22=7;
+ switch ( input.LA(1) ) {
+ case LBRACK:
+ {
+ alt22=1;
+ }
+ break;
+ case LCURLY:
+ {
+ alt22=2;
+ }
+ break;
+ case NUMBER:
+ case TERM_NORMAL:
+ {
+ alt22=3;
+ }
+ break;
+ case TERM_TRUNCATED:
+ {
+ alt22=4;
+ }
+ break;
+ case PHRASE:
+ {
+ alt22=5;
+ }
+ break;
+ case PHRASE_ANYTHING:
+ {
+ alt22=6;
+ }
+ break;
+ case QMARK:
+ {
+ alt22=7;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 22, 0, input);
+
+ throw nvae;
+
+ }
+
+ switch (alt22) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:151:2: range_term_in
+ {
+ pushFollow(FOLLOW_range_term_in_in_value734);
+ range_term_in35=range_term_in();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_range_term_in.add(range_term_in35.getTree());
+
+ // AST REWRITE
+ // elements: range_term_in
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 151:16: -> ^( QRANGEIN range_term_in )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:151:19: ^( QRANGEIN range_term_in )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QRANGEIN, "QRANGEIN")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_range_term_in.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:152:4: range_term_ex
+ {
+ pushFollow(FOLLOW_range_term_ex_in_value747);
+ range_term_ex36=range_term_ex();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_range_term_ex.add(range_term_ex36.getTree());
+
+ // AST REWRITE
+ // elements: range_term_ex
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 152:18: -> ^( QRANGEEX range_term_ex )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:152:21: ^( QRANGEEX range_term_ex )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QRANGEEX, "QRANGEEX")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_range_term_ex.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 3 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:153:4: normal
+ {
+ pushFollow(FOLLOW_normal_in_value761);
+ normal37=normal();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_normal.add(normal37.getTree());
+
+ // AST REWRITE
+ // elements: normal
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 153:11: -> ^( QNORMAL normal )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:153:14: ^( QNORMAL normal )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QNORMAL, "QNORMAL")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_normal.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 4 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:154:4: truncated
+ {
+ pushFollow(FOLLOW_truncated_in_value775);
+ truncated38=truncated();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_truncated.add(truncated38.getTree());
+
+ // AST REWRITE
+ // elements: truncated
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 154:14: -> ^( QTRUNCATED truncated )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:154:17: ^( QTRUNCATED truncated )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QTRUNCATED, "QTRUNCATED")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_truncated.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 5 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:155:4: quoted
+ {
+ pushFollow(FOLLOW_quoted_in_value789);
+ quoted39=quoted();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_quoted.add(quoted39.getTree());
+
+ // AST REWRITE
+ // elements: quoted
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 155:11: -> ^( QPHRASE quoted )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:155:14: ^( QPHRASE quoted )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QPHRASE, "QPHRASE")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_quoted.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 6 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:156:4: quoted_truncated
+ {
+ pushFollow(FOLLOW_quoted_truncated_in_value802);
+ quoted_truncated40=quoted_truncated();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_quoted_truncated.add(quoted_truncated40.getTree());
+
+ // AST REWRITE
+ // elements: quoted_truncated
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 156:21: -> ^( QPHRASETRUNC quoted_truncated )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:156:24: ^( QPHRASETRUNC quoted_truncated )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QPHRASETRUNC, "QPHRASETRUNC")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_quoted_truncated.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 7 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:157:4: QMARK
+ {
+ QMARK41=(Token)match(input,QMARK,FOLLOW_QMARK_in_value815); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_QMARK.add(QMARK41);
+
+
+ // AST REWRITE
+ // elements: QMARK
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 157:10: -> ^( QTRUNCATED QMARK )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:157:13: ^( QTRUNCATED QMARK )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QTRUNCATED, "QTRUNCATED")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ stream_QMARK.nextNode()
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "value"
+
+
+ public static class range_term_in_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "range_term_in"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:162:1: range_term_in : LBRACK (a= range_value -> range_value ^( QANYTHING QANYTHING[\"*\"] ) ) ( ( TO )? b= range_value -> $a ( $b)? )? RBRACK ;
+ public final StandardLuceneGrammarParser.range_term_in_return range_term_in() throws RecognitionException {
+ StandardLuceneGrammarParser.range_term_in_return retval = new StandardLuceneGrammarParser.range_term_in_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token LBRACK42=null;
+ Token TO43=null;
+ Token RBRACK44=null;
+ StandardLuceneGrammarParser.range_value_return a =null;
+
+ StandardLuceneGrammarParser.range_value_return b =null;
+
+
+ Object LBRACK42_tree=null;
+ Object TO43_tree=null;
+ Object RBRACK44_tree=null;
+ RewriteRuleTokenStream stream_RBRACK=new RewriteRuleTokenStream(adaptor,"token RBRACK");
+ RewriteRuleTokenStream stream_LBRACK=new RewriteRuleTokenStream(adaptor,"token LBRACK");
+ RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
+ RewriteRuleSubtreeStream stream_range_value=new RewriteRuleSubtreeStream(adaptor,"rule range_value");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:163:2: ( LBRACK (a= range_value -> range_value ^( QANYTHING QANYTHING[\"*\"] ) ) ( ( TO )? b= range_value -> $a ( $b)? )? RBRACK )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:164:8: LBRACK (a= range_value -> range_value ^( QANYTHING QANYTHING[\"*\"] ) ) ( ( TO )? b= range_value -> $a ( $b)? )? RBRACK
+ {
+ LBRACK42=(Token)match(input,LBRACK,FOLLOW_LBRACK_in_range_term_in847); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LBRACK.add(LBRACK42);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:165:8: (a= range_value -> range_value ^( QANYTHING QANYTHING[\"*\"] ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:165:9: a= range_value
+ {
+ pushFollow(FOLLOW_range_value_in_range_term_in859);
+ a=range_value();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_range_value.add(a.getTree());
+
+ // AST REWRITE
+ // elements: range_value
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 165:23: -> range_value ^( QANYTHING QANYTHING[\"*\"] )
+ {
+ adaptor.addChild(root_0, stream_range_value.nextTree());
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:165:38: ^( QANYTHING QANYTHING[\"*\"] )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QANYTHING, "QANYTHING")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ (Object)adaptor.create(QANYTHING, "*")
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:166:8: ( ( TO )? b= range_value -> $a ( $b)? )?
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0==DATE_TOKEN||LA24_0==NUMBER||(LA24_0 >= PHRASE && LA24_0 <= PHRASE_ANYTHING)||LA24_0==STAR||LA24_0==TERM_NORMAL||LA24_0==TERM_TRUNCATED||LA24_0==TO) ) {
+ alt24=1;
+ }
+ switch (alt24) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:166:10: ( TO )? b= range_value
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:166:10: ( TO )?
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( (LA23_0==TO) ) {
+ alt23=1;
+ }
+ switch (alt23) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:166:10: TO
+ {
+ TO43=(Token)match(input,TO,FOLLOW_TO_in_range_term_in882); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TO.add(TO43);
+
+
+ }
+ break;
+
+ }
+
+
+ pushFollow(FOLLOW_range_value_in_range_term_in887);
+ b=range_value();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_range_value.add(b.getTree());
+
+ // AST REWRITE
+ // elements: b, a
+ // token labels:
+ // rule labels: retval, b, a
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_b=new RewriteRuleSubtreeStream(adaptor,"rule b",b!=null?b.tree:null);
+ RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 166:28: -> $a ( $b)?
+ {
+ adaptor.addChild(root_0, stream_a.nextTree());
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:166:35: ( $b)?
+ if ( stream_b.hasNext() ) {
+ adaptor.addChild(root_0, stream_b.nextTree());
+
+ }
+ stream_b.reset();
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+
+
+ RBRACK44=(Token)match(input,RBRACK,FOLLOW_RBRACK_in_range_term_in908); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RBRACK.add(RBRACK44);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "range_term_in"
+
+
+ public static class range_term_ex_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "range_term_ex"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:171:1: range_term_ex : LCURLY (a= range_value -> range_value ^( QANYTHING QANYTHING[\"*\"] ) ) ( ( TO )? b= range_value -> $a ( $b)? )? RCURLY ;
+ public final StandardLuceneGrammarParser.range_term_ex_return range_term_ex() throws RecognitionException {
+ StandardLuceneGrammarParser.range_term_ex_return retval = new StandardLuceneGrammarParser.range_term_ex_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token LCURLY45=null;
+ Token TO46=null;
+ Token RCURLY47=null;
+ StandardLuceneGrammarParser.range_value_return a =null;
+
+ StandardLuceneGrammarParser.range_value_return b =null;
+
+
+ Object LCURLY45_tree=null;
+ Object TO46_tree=null;
+ Object RCURLY47_tree=null;
+ RewriteRuleTokenStream stream_LCURLY=new RewriteRuleTokenStream(adaptor,"token LCURLY");
+ RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
+ RewriteRuleTokenStream stream_RCURLY=new RewriteRuleTokenStream(adaptor,"token RCURLY");
+ RewriteRuleSubtreeStream stream_range_value=new RewriteRuleSubtreeStream(adaptor,"rule range_value");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:172:2: ( LCURLY (a= range_value -> range_value ^( QANYTHING QANYTHING[\"*\"] ) ) ( ( TO )? b= range_value -> $a ( $b)? )? RCURLY )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:173:8: LCURLY (a= range_value -> range_value ^( QANYTHING QANYTHING[\"*\"] ) ) ( ( TO )? b= range_value -> $a ( $b)? )? RCURLY
+ {
+ LCURLY45=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_range_term_ex928); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LCURLY.add(LCURLY45);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:174:8: (a= range_value -> range_value ^( QANYTHING QANYTHING[\"*\"] ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:174:10: a= range_value
+ {
+ pushFollow(FOLLOW_range_value_in_range_term_ex941);
+ a=range_value();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_range_value.add(a.getTree());
+
+ // AST REWRITE
+ // elements: range_value
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 174:24: -> range_value ^( QANYTHING QANYTHING[\"*\"] )
+ {
+ adaptor.addChild(root_0, stream_range_value.nextTree());
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:174:39: ^( QANYTHING QANYTHING[\"*\"] )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QANYTHING, "QANYTHING")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ (Object)adaptor.create(QANYTHING, "*")
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:175:8: ( ( TO )? b= range_value -> $a ( $b)? )?
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0==DATE_TOKEN||LA26_0==NUMBER||(LA26_0 >= PHRASE && LA26_0 <= PHRASE_ANYTHING)||LA26_0==STAR||LA26_0==TERM_NORMAL||LA26_0==TERM_TRUNCATED||LA26_0==TO) ) {
+ alt26=1;
+ }
+ switch (alt26) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:175:10: ( TO )? b= range_value
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:175:10: ( TO )?
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( (LA25_0==TO) ) {
+ alt25=1;
+ }
+ switch (alt25) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:175:10: TO
+ {
+ TO46=(Token)match(input,TO,FOLLOW_TO_in_range_term_ex964); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TO.add(TO46);
+
+
+ }
+ break;
+
+ }
+
+
+ pushFollow(FOLLOW_range_value_in_range_term_ex969);
+ b=range_value();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_range_value.add(b.getTree());
+
+ // AST REWRITE
+ // elements: b, a
+ // token labels:
+ // rule labels: retval, b, a
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_b=new RewriteRuleSubtreeStream(adaptor,"rule b",b!=null?b.tree:null);
+ RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"rule a",a!=null?a.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 175:28: -> $a ( $b)?
+ {
+ adaptor.addChild(root_0, stream_a.nextTree());
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:175:35: ( $b)?
+ if ( stream_b.hasNext() ) {
+ adaptor.addChild(root_0, stream_b.nextTree());
+
+ }
+ stream_b.reset();
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+
+
+ RCURLY47=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_range_term_ex990); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RCURLY.add(RCURLY47);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "range_term_ex"
+
+
+ public static class range_value_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "range_value"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:179:1: range_value : ( truncated -> ^( QTRUNCATED truncated ) | quoted -> ^( QPHRASE quoted ) | quoted_truncated -> ^( QPHRASETRUNC quoted_truncated ) | date -> ^( QNORMAL date ) | normal -> ^( QNORMAL normal ) | STAR -> ^( QANYTHING STAR ) );
+ public final StandardLuceneGrammarParser.range_value_return range_value() throws RecognitionException {
+ StandardLuceneGrammarParser.range_value_return retval = new StandardLuceneGrammarParser.range_value_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token STAR53=null;
+ StandardLuceneGrammarParser.truncated_return truncated48 =null;
+
+ StandardLuceneGrammarParser.quoted_return quoted49 =null;
+
+ StandardLuceneGrammarParser.quoted_truncated_return quoted_truncated50 =null;
+
+ StandardLuceneGrammarParser.date_return date51 =null;
+
+ StandardLuceneGrammarParser.normal_return normal52 =null;
+
+
+ Object STAR53_tree=null;
+ RewriteRuleTokenStream stream_STAR=new RewriteRuleTokenStream(adaptor,"token STAR");
+ RewriteRuleSubtreeStream stream_normal=new RewriteRuleSubtreeStream(adaptor,"rule normal");
+ RewriteRuleSubtreeStream stream_quoted=new RewriteRuleSubtreeStream(adaptor,"rule quoted");
+ RewriteRuleSubtreeStream stream_quoted_truncated=new RewriteRuleSubtreeStream(adaptor,"rule quoted_truncated");
+ RewriteRuleSubtreeStream stream_truncated=new RewriteRuleSubtreeStream(adaptor,"rule truncated");
+ RewriteRuleSubtreeStream stream_date=new RewriteRuleSubtreeStream(adaptor,"rule date");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:180:2: ( truncated -> ^( QTRUNCATED truncated ) | quoted -> ^( QPHRASE quoted ) | quoted_truncated -> ^( QPHRASETRUNC quoted_truncated ) | date -> ^( QNORMAL date ) | normal -> ^( QNORMAL normal ) | STAR -> ^( QANYTHING STAR ) )
+ int alt27=6;
+ switch ( input.LA(1) ) {
+ case TERM_TRUNCATED:
+ {
+ alt27=1;
+ }
+ break;
+ case PHRASE:
+ {
+ alt27=2;
+ }
+ break;
+ case PHRASE_ANYTHING:
+ {
+ alt27=3;
+ }
+ break;
+ case DATE_TOKEN:
+ {
+ alt27=4;
+ }
+ break;
+ case NUMBER:
+ case TERM_NORMAL:
+ {
+ alt27=5;
+ }
+ break;
+ case STAR:
+ {
+ alt27=6;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 27, 0, input);
+
+ throw nvae;
+
+ }
+
+ switch (alt27) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:181:2: truncated
+ {
+ pushFollow(FOLLOW_truncated_in_range_value1004);
+ truncated48=truncated();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_truncated.add(truncated48.getTree());
+
+ // AST REWRITE
+ // elements: truncated
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 181:12: -> ^( QTRUNCATED truncated )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:181:15: ^( QTRUNCATED truncated )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QTRUNCATED, "QTRUNCATED")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_truncated.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:182:4: quoted
+ {
+ pushFollow(FOLLOW_quoted_in_range_value1017);
+ quoted49=quoted();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_quoted.add(quoted49.getTree());
+
+ // AST REWRITE
+ // elements: quoted
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 182:11: -> ^( QPHRASE quoted )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:182:14: ^( QPHRASE quoted )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QPHRASE, "QPHRASE")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_quoted.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 3 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:183:4: quoted_truncated
+ {
+ pushFollow(FOLLOW_quoted_truncated_in_range_value1030);
+ quoted_truncated50=quoted_truncated();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_quoted_truncated.add(quoted_truncated50.getTree());
+
+ // AST REWRITE
+ // elements: quoted_truncated
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 183:21: -> ^( QPHRASETRUNC quoted_truncated )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:183:24: ^( QPHRASETRUNC quoted_truncated )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QPHRASETRUNC, "QPHRASETRUNC")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_quoted_truncated.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 4 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:184:4: date
+ {
+ pushFollow(FOLLOW_date_in_range_value1043);
+ date51=date();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_date.add(date51.getTree());
+
+ // AST REWRITE
+ // elements: date
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 184:9: -> ^( QNORMAL date )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:184:12: ^( QNORMAL date )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QNORMAL, "QNORMAL")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_date.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 5 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:185:4: normal
+ {
+ pushFollow(FOLLOW_normal_in_range_value1056);
+ normal52=normal();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_normal.add(normal52.getTree());
+
+ // AST REWRITE
+ // elements: normal
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 185:11: -> ^( QNORMAL normal )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:185:14: ^( QNORMAL normal )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QNORMAL, "QNORMAL")
+ , root_1);
+
+ adaptor.addChild(root_1, stream_normal.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 6 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:186:4: STAR
+ {
+ STAR53=(Token)match(input,STAR,FOLLOW_STAR_in_range_value1070); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_STAR.add(STAR53);
+
+
+ // AST REWRITE
+ // elements: STAR
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 186:9: -> ^( QANYTHING STAR )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:186:12: ^( QANYTHING STAR )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(QANYTHING, "QANYTHING")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ stream_STAR.nextNode()
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "range_value"
+
+
+ public static class multi_value_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "multi_value"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:189:1: multi_value : LPAREN multiClause RPAREN -> multiClause ;
+ public final StandardLuceneGrammarParser.multi_value_return multi_value() throws RecognitionException {
+ StandardLuceneGrammarParser.multi_value_return retval = new StandardLuceneGrammarParser.multi_value_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token LPAREN54=null;
+ Token RPAREN56=null;
+ StandardLuceneGrammarParser.multiClause_return multiClause55 =null;
+
+
+ Object LPAREN54_tree=null;
+ Object RPAREN56_tree=null;
+ RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
+ RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
+ RewriteRuleSubtreeStream stream_multiClause=new RewriteRuleSubtreeStream(adaptor,"rule multiClause");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:190:2: ( LPAREN multiClause RPAREN -> multiClause )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:191:2: LPAREN multiClause RPAREN
+ {
+ LPAREN54=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_multi_value1091); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN54);
+
+
+ pushFollow(FOLLOW_multiClause_in_multi_value1093);
+ multiClause55=multiClause();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiClause.add(multiClause55.getTree());
+
+ RPAREN56=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_multi_value1095); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN56);
+
+
+ // AST REWRITE
+ // elements: multiClause
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 191:28: -> multiClause
+ {
+ adaptor.addChild(root_0, stream_multiClause.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "multi_value"
+
+
+ public static class multiClause_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "multiClause"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:196:1: multiClause : ( clauseOr )+ -> ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) ;
+ public final StandardLuceneGrammarParser.multiClause_return multiClause() throws RecognitionException {
+ StandardLuceneGrammarParser.multiClause_return retval = new StandardLuceneGrammarParser.multiClause_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.clauseOr_return clauseOr57 =null;
+
+
+ RewriteRuleSubtreeStream stream_clauseOr=new RewriteRuleSubtreeStream(adaptor,"rule clauseOr");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:197:2: ( ( clauseOr )+ -> ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:202:2: ( clauseOr )+
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:202:2: ( clauseOr )+
+ int cnt28=0;
+ loop28:
+ do {
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( ((LA28_0 >= LBRACK && LA28_0 <= MINUS)||LA28_0==NUMBER||(LA28_0 >= PHRASE && LA28_0 <= PLUS)||LA28_0==QMARK||LA28_0==STAR||LA28_0==TERM_NORMAL||LA28_0==TERM_TRUNCATED) ) {
+ alt28=1;
+ }
+
+
+ switch (alt28) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:202:2: clauseOr
+ {
+ pushFollow(FOLLOW_clauseOr_in_multiClause1122);
+ clauseOr57=clauseOr();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_clauseOr.add(clauseOr57.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt28 >= 1 ) break loop28;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(28, input);
+ throw eee;
+ }
+ cnt28++;
+ } while (true);
+
+
+ // AST REWRITE
+ // elements: clauseOr
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 202:12: -> ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:202:15: ^( OPERATOR[\"DEFOP\"] ( clauseOr )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "DEFOP")
+ , root_1);
+
+ if ( !(stream_clauseOr.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_clauseOr.hasNext() ) {
+ adaptor.addChild(root_1, stream_clauseOr.nextTree());
+
+ }
+ stream_clauseOr.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "multiClause"
+
+
+ public static class multiDefault_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "multiDefault"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:215:1: multiDefault : ( multiOr )+ -> ^( OPERATOR[\"DEFOP\"] ( multiOr )+ ) ;
+ public final StandardLuceneGrammarParser.multiDefault_return multiDefault() throws RecognitionException {
+ StandardLuceneGrammarParser.multiDefault_return retval = new StandardLuceneGrammarParser.multiDefault_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.multiOr_return multiOr58 =null;
+
+
+ RewriteRuleSubtreeStream stream_multiOr=new RewriteRuleSubtreeStream(adaptor,"rule multiOr");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:216:2: ( ( multiOr )+ -> ^( OPERATOR[\"DEFOP\"] ( multiOr )+ ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:217:2: ( multiOr )+
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:217:2: ( multiOr )+
+ int cnt29=0;
+ loop29:
+ do {
+ int alt29=2;
+ int LA29_0 = input.LA(1);
+
+ if ( ((LA29_0 >= LBRACK && LA29_0 <= LCURLY)||LA29_0==MINUS||LA29_0==NUMBER||(LA29_0 >= PHRASE && LA29_0 <= PLUS)||LA29_0==QMARK||LA29_0==TERM_NORMAL||LA29_0==TERM_TRUNCATED) ) {
+ alt29=1;
+ }
+
+
+ switch (alt29) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:217:2: multiOr
+ {
+ pushFollow(FOLLOW_multiOr_in_multiDefault1166);
+ multiOr58=multiOr();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiOr.add(multiOr58.getTree());
+
+ }
+ break;
+
+ default :
+ if ( cnt29 >= 1 ) break loop29;
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ EarlyExitException eee =
+ new EarlyExitException(29, input);
+ throw eee;
+ }
+ cnt29++;
+ } while (true);
+
+
+ // AST REWRITE
+ // elements: multiOr
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 217:11: -> ^( OPERATOR[\"DEFOP\"] ( multiOr )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:217:14: ^( OPERATOR[\"DEFOP\"] ( multiOr )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "DEFOP")
+ , root_1);
+
+ if ( !(stream_multiOr.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_multiOr.hasNext() ) {
+ adaptor.addChild(root_1, stream_multiOr.nextTree());
+
+ }
+ stream_multiOr.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "multiDefault"
+
+
+ public static class multiOr_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "multiOr"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:220:1: multiOr : (first= multiAnd -> $first) ( or others= multiAnd -> ^( OPERATOR[\"OR\"] ( multiAnd )+ ) )* ;
+ public final StandardLuceneGrammarParser.multiOr_return multiOr() throws RecognitionException {
+ StandardLuceneGrammarParser.multiOr_return retval = new StandardLuceneGrammarParser.multiOr_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.multiAnd_return first =null;
+
+ StandardLuceneGrammarParser.multiAnd_return others =null;
+
+ StandardLuceneGrammarParser.or_return or59 =null;
+
+
+ RewriteRuleSubtreeStream stream_multiAnd=new RewriteRuleSubtreeStream(adaptor,"rule multiAnd");
+ RewriteRuleSubtreeStream stream_or=new RewriteRuleSubtreeStream(adaptor,"rule or");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:221:2: ( (first= multiAnd -> $first) ( or others= multiAnd -> ^( OPERATOR[\"OR\"] ( multiAnd )+ ) )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:222:2: (first= multiAnd -> $first) ( or others= multiAnd -> ^( OPERATOR[\"OR\"] ( multiAnd )+ ) )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:222:2: (first= multiAnd -> $first)
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:222:3: first= multiAnd
+ {
+ pushFollow(FOLLOW_multiAnd_in_multiOr1194);
+ first=multiAnd();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiAnd.add(first.getTree());
+
+ // AST REWRITE
+ // elements: first
+ // token labels:
+ // rule labels: retval, first
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_first=new RewriteRuleSubtreeStream(adaptor,"rule first",first!=null?first.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 222:19: -> $first
+ {
+ adaptor.addChild(root_0, stream_first.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:222:30: ( or others= multiAnd -> ^( OPERATOR[\"OR\"] ( multiAnd )+ ) )*
+ loop30:
+ do {
+ int alt30=2;
+ int LA30_0 = input.LA(1);
+
+ if ( (LA30_0==OR) ) {
+ alt30=1;
+ }
+
+
+ switch (alt30) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:222:31: or others= multiAnd
+ {
+ pushFollow(FOLLOW_or_in_multiOr1204);
+ or59=or();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_or.add(or59.getTree());
+
+ pushFollow(FOLLOW_multiAnd_in_multiOr1208);
+ others=multiAnd();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiAnd.add(others.getTree());
+
+ // AST REWRITE
+ // elements: multiAnd
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 222:49: -> ^( OPERATOR[\"OR\"] ( multiAnd )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:222:52: ^( OPERATOR[\"OR\"] ( multiAnd )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "OR")
+ , root_1);
+
+ if ( !(stream_multiAnd.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_multiAnd.hasNext() ) {
+ adaptor.addChild(root_1, stream_multiAnd.nextTree());
+
+ }
+ stream_multiAnd.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ default :
+ break loop30;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "multiOr"
+
+
+ public static class multiAnd_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "multiAnd"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:225:1: multiAnd : (first= multiNot -> $first) ( and others= multiNot -> ^( OPERATOR[\"AND\"] ( multiNot )+ ) )* ;
+ public final StandardLuceneGrammarParser.multiAnd_return multiAnd() throws RecognitionException {
+ StandardLuceneGrammarParser.multiAnd_return retval = new StandardLuceneGrammarParser.multiAnd_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.multiNot_return first =null;
+
+ StandardLuceneGrammarParser.multiNot_return others =null;
+
+ StandardLuceneGrammarParser.and_return and60 =null;
+
+
+ RewriteRuleSubtreeStream stream_multiNot=new RewriteRuleSubtreeStream(adaptor,"rule multiNot");
+ RewriteRuleSubtreeStream stream_and=new RewriteRuleSubtreeStream(adaptor,"rule and");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:226:2: ( (first= multiNot -> $first) ( and others= multiNot -> ^( OPERATOR[\"AND\"] ( multiNot )+ ) )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:227:2: (first= multiNot -> $first) ( and others= multiNot -> ^( OPERATOR[\"AND\"] ( multiNot )+ ) )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:227:2: (first= multiNot -> $first)
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:227:3: first= multiNot
+ {
+ pushFollow(FOLLOW_multiNot_in_multiAnd1239);
+ first=multiNot();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiNot.add(first.getTree());
+
+ // AST REWRITE
+ // elements: first
+ // token labels:
+ // rule labels: retval, first
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_first=new RewriteRuleSubtreeStream(adaptor,"rule first",first!=null?first.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 227:19: -> $first
+ {
+ adaptor.addChild(root_0, stream_first.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:227:30: ( and others= multiNot -> ^( OPERATOR[\"AND\"] ( multiNot )+ ) )*
+ loop31:
+ do {
+ int alt31=2;
+ int LA31_0 = input.LA(1);
+
+ if ( (LA31_0==AND) ) {
+ alt31=1;
+ }
+
+
+ switch (alt31) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:227:31: and others= multiNot
+ {
+ pushFollow(FOLLOW_and_in_multiAnd1249);
+ and60=and();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_and.add(and60.getTree());
+
+ pushFollow(FOLLOW_multiNot_in_multiAnd1253);
+ others=multiNot();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiNot.add(others.getTree());
+
+ // AST REWRITE
+ // elements: multiNot
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 227:51: -> ^( OPERATOR[\"AND\"] ( multiNot )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:227:54: ^( OPERATOR[\"AND\"] ( multiNot )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "AND")
+ , root_1);
+
+ if ( !(stream_multiNot.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_multiNot.hasNext() ) {
+ adaptor.addChild(root_1, stream_multiNot.nextTree());
+
+ }
+ stream_multiNot.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ default :
+ break loop31;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "multiAnd"
+
+
+ public static class multiNot_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "multiNot"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:230:1: multiNot : (first= multiNear -> $first) ( not others= multiNear -> ^( OPERATOR[\"NOT\"] ( multiNear )+ ) )* ;
+ public final StandardLuceneGrammarParser.multiNot_return multiNot() throws RecognitionException {
+ StandardLuceneGrammarParser.multiNot_return retval = new StandardLuceneGrammarParser.multiNot_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.multiNear_return first =null;
+
+ StandardLuceneGrammarParser.multiNear_return others =null;
+
+ StandardLuceneGrammarParser.not_return not61 =null;
+
+
+ RewriteRuleSubtreeStream stream_not=new RewriteRuleSubtreeStream(adaptor,"rule not");
+ RewriteRuleSubtreeStream stream_multiNear=new RewriteRuleSubtreeStream(adaptor,"rule multiNear");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:231:2: ( (first= multiNear -> $first) ( not others= multiNear -> ^( OPERATOR[\"NOT\"] ( multiNear )+ ) )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:232:2: (first= multiNear -> $first) ( not others= multiNear -> ^( OPERATOR[\"NOT\"] ( multiNear )+ ) )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:232:2: (first= multiNear -> $first)
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:232:3: first= multiNear
+ {
+ pushFollow(FOLLOW_multiNear_in_multiNot1284);
+ first=multiNear();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiNear.add(first.getTree());
+
+ // AST REWRITE
+ // elements: first
+ // token labels:
+ // rule labels: retval, first
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_first=new RewriteRuleSubtreeStream(adaptor,"rule first",first!=null?first.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 232:20: -> $first
+ {
+ adaptor.addChild(root_0, stream_first.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:232:31: ( not others= multiNear -> ^( OPERATOR[\"NOT\"] ( multiNear )+ ) )*
+ loop32:
+ do {
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( (LA32_0==AND) ) {
+ int LA32_1 = input.LA(2);
+
+ if ( (LA32_1==NOT) ) {
+ alt32=1;
+ }
+
+
+ }
+ else if ( (LA32_0==NOT) ) {
+ alt32=1;
+ }
+
+
+ switch (alt32) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:232:32: not others= multiNear
+ {
+ pushFollow(FOLLOW_not_in_multiNot1294);
+ not61=not();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_not.add(not61.getTree());
+
+ pushFollow(FOLLOW_multiNear_in_multiNot1298);
+ others=multiNear();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiNear.add(others.getTree());
+
+ // AST REWRITE
+ // elements: multiNear
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 232:52: -> ^( OPERATOR[\"NOT\"] ( multiNear )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:232:55: ^( OPERATOR[\"NOT\"] ( multiNear )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "NOT")
+ , root_1);
+
+ if ( !(stream_multiNear.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_multiNear.hasNext() ) {
+ adaptor.addChild(root_1, stream_multiNear.nextTree());
+
+ }
+ stream_multiNear.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ default :
+ break loop32;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "multiNot"
+
+
+ public static class multiNear_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "multiNear"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:235:1: multiNear : (first= multiBasic -> $first) ( near others= multiBasic -> ^( near ( multiBasic )+ ) )* ;
+ public final StandardLuceneGrammarParser.multiNear_return multiNear() throws RecognitionException {
+ StandardLuceneGrammarParser.multiNear_return retval = new StandardLuceneGrammarParser.multiNear_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.multiBasic_return first =null;
+
+ StandardLuceneGrammarParser.multiBasic_return others =null;
+
+ StandardLuceneGrammarParser.near_return near62 =null;
+
+
+ RewriteRuleSubtreeStream stream_near=new RewriteRuleSubtreeStream(adaptor,"rule near");
+ RewriteRuleSubtreeStream stream_multiBasic=new RewriteRuleSubtreeStream(adaptor,"rule multiBasic");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:236:2: ( (first= multiBasic -> $first) ( near others= multiBasic -> ^( near ( multiBasic )+ ) )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:237:2: (first= multiBasic -> $first) ( near others= multiBasic -> ^( near ( multiBasic )+ ) )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:237:2: (first= multiBasic -> $first)
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:237:3: first= multiBasic
+ {
+ pushFollow(FOLLOW_multiBasic_in_multiNear1328);
+ first=multiBasic();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiBasic.add(first.getTree());
+
+ // AST REWRITE
+ // elements: first
+ // token labels:
+ // rule labels: retval, first
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+ RewriteRuleSubtreeStream stream_first=new RewriteRuleSubtreeStream(adaptor,"rule first",first!=null?first.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 237:21: -> $first
+ {
+ adaptor.addChild(root_0, stream_first.nextTree());
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:237:32: ( near others= multiBasic -> ^( near ( multiBasic )+ ) )*
+ loop33:
+ do {
+ int alt33=2;
+ int LA33_0 = input.LA(1);
+
+ if ( (LA33_0==NEAR) ) {
+ alt33=1;
+ }
+
+
+ switch (alt33) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:237:33: near others= multiBasic
+ {
+ pushFollow(FOLLOW_near_in_multiNear1338);
+ near62=near();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_near.add(near62.getTree());
+
+ pushFollow(FOLLOW_multiBasic_in_multiNear1342);
+ others=multiBasic();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_multiBasic.add(others.getTree());
+
+ // AST REWRITE
+ // elements: multiBasic, near
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 237:55: -> ^( near ( multiBasic )+ )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:237:58: ^( near ( multiBasic )+ )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(stream_near.nextNode(), root_1);
+
+ if ( !(stream_multiBasic.hasNext()) ) {
+ throw new RewriteEarlyExitException();
+ }
+ while ( stream_multiBasic.hasNext() ) {
+ adaptor.addChild(root_1, stream_multiBasic.nextTree());
+
+ }
+ stream_multiBasic.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ default :
+ break loop33;
+ }
+ } while (true);
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "multiNear"
+
+
+ public static class multiBasic_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "multiBasic"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:241:1: multiBasic : mterm ;
+ public final StandardLuceneGrammarParser.multiBasic_return multiBasic() throws RecognitionException {
+ StandardLuceneGrammarParser.multiBasic_return retval = new StandardLuceneGrammarParser.multiBasic_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.mterm_return mterm63 =null;
+
+
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:242:2: ( mterm )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:243:2: mterm
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ pushFollow(FOLLOW_mterm_in_multiBasic1368);
+ mterm63=mterm();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) adaptor.addChild(root_0, mterm63.getTree());
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "multiBasic"
+
+
+ public static class mterm_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "mterm"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:246:1: mterm : ( modifier )? value -> ^( MODIFIER ( modifier )? value ) ;
+ public final StandardLuceneGrammarParser.mterm_return mterm() throws RecognitionException {
+ StandardLuceneGrammarParser.mterm_return retval = new StandardLuceneGrammarParser.mterm_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ StandardLuceneGrammarParser.modifier_return modifier64 =null;
+
+ StandardLuceneGrammarParser.value_return value65 =null;
+
+
+ RewriteRuleSubtreeStream stream_modifier=new RewriteRuleSubtreeStream(adaptor,"rule modifier");
+ RewriteRuleSubtreeStream stream_value=new RewriteRuleSubtreeStream(adaptor,"rule value");
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:247:2: ( ( modifier )? value -> ^( MODIFIER ( modifier )? value ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:248:2: ( modifier )? value
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:248:2: ( modifier )?
+ int alt34=2;
+ int LA34_0 = input.LA(1);
+
+ if ( (LA34_0==MINUS||LA34_0==PLUS) ) {
+ alt34=1;
+ }
+ switch (alt34) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:248:2: modifier
+ {
+ pushFollow(FOLLOW_modifier_in_mterm1384);
+ modifier64=modifier();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_modifier.add(modifier64.getTree());
+
+ }
+ break;
+
+ }
+
+
+ pushFollow(FOLLOW_value_in_mterm1387);
+ value65=value();
+
+ state._fsp--;
+ if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_value.add(value65.getTree());
+
+ // AST REWRITE
+ // elements: modifier, value
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 248:18: -> ^( MODIFIER ( modifier )? value )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:248:21: ^( MODIFIER ( modifier )? value )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(MODIFIER, "MODIFIER")
+ , root_1);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:248:32: ( modifier )?
+ if ( stream_modifier.hasNext() ) {
+ adaptor.addChild(root_1, stream_modifier.nextTree());
+
+ }
+ stream_modifier.reset();
+
+ adaptor.addChild(root_1, stream_value.nextTree());
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "mterm"
+
+
+ public static class normal_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "normal"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:252:1: normal : ( TERM_NORMAL | NUMBER );
+ public final StandardLuceneGrammarParser.normal_return normal() throws RecognitionException {
+ StandardLuceneGrammarParser.normal_return retval = new StandardLuceneGrammarParser.normal_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token set66=null;
+
+ Object set66_tree=null;
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:253:2: ( TERM_NORMAL | NUMBER )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ set66=(Token)input.LT(1);
+
+ if ( input.LA(1)==NUMBER||input.LA(1)==TERM_NORMAL ) {
+ input.consume();
+ if ( state.backtracking==0 ) adaptor.addChild(root_0,
+ (Object)adaptor.create(set66)
+ );
+ state.errorRecovery=false;
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ throw mse;
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "normal"
+
+
+ public static class truncated_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "truncated"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:261:1: truncated : TERM_TRUNCATED ;
+ public final StandardLuceneGrammarParser.truncated_return truncated() throws RecognitionException {
+ StandardLuceneGrammarParser.truncated_return retval = new StandardLuceneGrammarParser.truncated_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token TERM_TRUNCATED67=null;
+
+ Object TERM_TRUNCATED67_tree=null;
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:262:2: ( TERM_TRUNCATED )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:263:2: TERM_TRUNCATED
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ TERM_TRUNCATED67=(Token)match(input,TERM_TRUNCATED,FOLLOW_TERM_TRUNCATED_in_truncated1440); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ TERM_TRUNCATED67_tree =
+ (Object)adaptor.create(TERM_TRUNCATED67)
+ ;
+ adaptor.addChild(root_0, TERM_TRUNCATED67_tree);
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "truncated"
+
+
+ public static class quoted_truncated_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "quoted_truncated"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:267:1: quoted_truncated : PHRASE_ANYTHING ;
+ public final StandardLuceneGrammarParser.quoted_truncated_return quoted_truncated() throws RecognitionException {
+ StandardLuceneGrammarParser.quoted_truncated_return retval = new StandardLuceneGrammarParser.quoted_truncated_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token PHRASE_ANYTHING68=null;
+
+ Object PHRASE_ANYTHING68_tree=null;
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:268:2: ( PHRASE_ANYTHING )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:269:2: PHRASE_ANYTHING
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ PHRASE_ANYTHING68=(Token)match(input,PHRASE_ANYTHING,FOLLOW_PHRASE_ANYTHING_in_quoted_truncated1455); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ PHRASE_ANYTHING68_tree =
+ (Object)adaptor.create(PHRASE_ANYTHING68)
+ ;
+ adaptor.addChild(root_0, PHRASE_ANYTHING68_tree);
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "quoted_truncated"
+
+
+ public static class quoted_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "quoted"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:272:1: quoted : PHRASE ;
+ public final StandardLuceneGrammarParser.quoted_return quoted() throws RecognitionException {
+ StandardLuceneGrammarParser.quoted_return retval = new StandardLuceneGrammarParser.quoted_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token PHRASE69=null;
+
+ Object PHRASE69_tree=null;
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:272:8: ( PHRASE )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:273:2: PHRASE
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ PHRASE69=(Token)match(input,PHRASE,FOLLOW_PHRASE_in_quoted1467); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ PHRASE69_tree =
+ (Object)adaptor.create(PHRASE69)
+ ;
+ adaptor.addChild(root_0, PHRASE69_tree);
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "quoted"
+
+
+ public static class operator_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "operator"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:279:1: operator : ( AND -> OPERATOR[\"AND\"] | OR -> OPERATOR[\"OR\"] | NOT -> OPERATOR[\"NOT\"] | NEAR -> OPERATOR[\"NEAR\"] ) ;
+ public final StandardLuceneGrammarParser.operator_return operator() throws RecognitionException {
+ StandardLuceneGrammarParser.operator_return retval = new StandardLuceneGrammarParser.operator_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token AND70=null;
+ Token OR71=null;
+ Token NOT72=null;
+ Token NEAR73=null;
+
+ Object AND70_tree=null;
+ Object OR71_tree=null;
+ Object NOT72_tree=null;
+ Object NEAR73_tree=null;
+ RewriteRuleTokenStream stream_NEAR=new RewriteRuleTokenStream(adaptor,"token NEAR");
+ RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
+ RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
+ RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:279:9: ( ( AND -> OPERATOR[\"AND\"] | OR -> OPERATOR[\"OR\"] | NOT -> OPERATOR[\"NOT\"] | NEAR -> OPERATOR[\"NEAR\"] ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:279:11: ( AND -> OPERATOR[\"AND\"] | OR -> OPERATOR[\"OR\"] | NOT -> OPERATOR[\"NOT\"] | NEAR -> OPERATOR[\"NEAR\"] )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:279:11: ( AND -> OPERATOR[\"AND\"] | OR -> OPERATOR[\"OR\"] | NOT -> OPERATOR[\"NOT\"] | NEAR -> OPERATOR[\"NEAR\"] )
+ int alt35=4;
+ switch ( input.LA(1) ) {
+ case AND:
+ {
+ alt35=1;
+ }
+ break;
+ case OR:
+ {
+ alt35=2;
+ }
+ break;
+ case NOT:
+ {
+ alt35=3;
+ }
+ break;
+ case NEAR:
+ {
+ alt35=4;
+ }
+ break;
+ default:
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 35, 0, input);
+
+ throw nvae;
+
+ }
+
+ switch (alt35) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:280:2: AND
+ {
+ AND70=(Token)match(input,AND,FOLLOW_AND_in_operator1483); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_AND.add(AND70);
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 280:6: -> OPERATOR[\"AND\"]
+ {
+ adaptor.addChild(root_0,
+ (Object)adaptor.create(OPERATOR, "AND")
+ );
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:281:4: OR
+ {
+ OR71=(Token)match(input,OR,FOLLOW_OR_in_operator1493); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_OR.add(OR71);
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 281:7: -> OPERATOR[\"OR\"]
+ {
+ adaptor.addChild(root_0,
+ (Object)adaptor.create(OPERATOR, "OR")
+ );
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 3 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:282:4: NOT
+ {
+ NOT72=(Token)match(input,NOT,FOLLOW_NOT_in_operator1503); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_NOT.add(NOT72);
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 282:8: -> OPERATOR[\"NOT\"]
+ {
+ adaptor.addChild(root_0,
+ (Object)adaptor.create(OPERATOR, "NOT")
+ );
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 4 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:283:4: NEAR
+ {
+ NEAR73=(Token)match(input,NEAR,FOLLOW_NEAR_in_operator1513); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_NEAR.add(NEAR73);
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 283:9: -> OPERATOR[\"NEAR\"]
+ {
+ adaptor.addChild(root_0,
+ (Object)adaptor.create(OPERATOR, "NEAR")
+ );
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "operator"
+
+
+ public static class modifier_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "modifier"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:286:1: modifier : ( PLUS -> PLUS[\"+\"] | MINUS -> MINUS[\"-\"] );
+ public final StandardLuceneGrammarParser.modifier_return modifier() throws RecognitionException {
+ StandardLuceneGrammarParser.modifier_return retval = new StandardLuceneGrammarParser.modifier_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token PLUS74=null;
+ Token MINUS75=null;
+
+ Object PLUS74_tree=null;
+ Object MINUS75_tree=null;
+ RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
+ RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:286:9: ( PLUS -> PLUS[\"+\"] | MINUS -> MINUS[\"-\"] )
+ int alt36=2;
+ int LA36_0 = input.LA(1);
+
+ if ( (LA36_0==PLUS) ) {
+ alt36=1;
+ }
+ else if ( (LA36_0==MINUS) ) {
+ alt36=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 36, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt36) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:287:2: PLUS
+ {
+ PLUS74=(Token)match(input,PLUS,FOLLOW_PLUS_in_modifier1530); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_PLUS.add(PLUS74);
+
+
+ // AST REWRITE
+ // elements: PLUS
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 287:7: -> PLUS[\"+\"]
+ {
+ adaptor.addChild(root_0,
+ (Object)adaptor.create(PLUS, "+")
+ );
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:288:4: MINUS
+ {
+ MINUS75=(Token)match(input,MINUS,FOLLOW_MINUS_in_modifier1540); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_MINUS.add(MINUS75);
+
+
+ // AST REWRITE
+ // elements: MINUS
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 288:10: -> MINUS[\"-\"]
+ {
+ adaptor.addChild(root_0,
+ (Object)adaptor.create(MINUS, "-")
+ );
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "modifier"
+
+
+ public static class term_modifier_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "term_modifier"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:300:1: term_modifier : ( TILDE ( CARAT )? -> ^( BOOST ( CARAT )? ) ^( FUZZY TILDE ) | CARAT ( TILDE )? -> ^( BOOST CARAT ) ^( FUZZY ( TILDE )? ) );
+ public final StandardLuceneGrammarParser.term_modifier_return term_modifier() throws RecognitionException {
+ StandardLuceneGrammarParser.term_modifier_return retval = new StandardLuceneGrammarParser.term_modifier_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token TILDE76=null;
+ Token CARAT77=null;
+ Token CARAT78=null;
+ Token TILDE79=null;
+
+ Object TILDE76_tree=null;
+ Object CARAT77_tree=null;
+ Object CARAT78_tree=null;
+ Object TILDE79_tree=null;
+ RewriteRuleTokenStream stream_CARAT=new RewriteRuleTokenStream(adaptor,"token CARAT");
+ RewriteRuleTokenStream stream_TILDE=new RewriteRuleTokenStream(adaptor,"token TILDE");
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:300:15: ( TILDE ( CARAT )? -> ^( BOOST ( CARAT )? ) ^( FUZZY TILDE ) | CARAT ( TILDE )? -> ^( BOOST CARAT ) ^( FUZZY ( TILDE )? ) )
+ int alt39=2;
+ int LA39_0 = input.LA(1);
+
+ if ( (LA39_0==TILDE) ) {
+ alt39=1;
+ }
+ else if ( (LA39_0==CARAT) ) {
+ alt39=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 39, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt39) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:301:2: TILDE ( CARAT )?
+ {
+ TILDE76=(Token)match(input,TILDE,FOLLOW_TILDE_in_term_modifier1558); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TILDE.add(TILDE76);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:301:8: ( CARAT )?
+ int alt37=2;
+ int LA37_0 = input.LA(1);
+
+ if ( (LA37_0==CARAT) ) {
+ alt37=1;
+ }
+ switch (alt37) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:301:8: CARAT
+ {
+ CARAT77=(Token)match(input,CARAT,FOLLOW_CARAT_in_term_modifier1560); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_CARAT.add(CARAT77);
+
+
+ }
+ break;
+
+ }
+
+
+ // AST REWRITE
+ // elements: CARAT, TILDE
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 301:15: -> ^( BOOST ( CARAT )? ) ^( FUZZY TILDE )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:301:18: ^( BOOST ( CARAT )? )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(BOOST, "BOOST")
+ , root_1);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:301:26: ( CARAT )?
+ if ( stream_CARAT.hasNext() ) {
+ adaptor.addChild(root_1,
+ stream_CARAT.nextNode()
+ );
+
+ }
+ stream_CARAT.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:301:34: ^( FUZZY TILDE )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(FUZZY, "FUZZY")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ stream_TILDE.nextNode()
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:302:4: CARAT ( TILDE )?
+ {
+ CARAT78=(Token)match(input,CARAT,FOLLOW_CARAT_in_term_modifier1582); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_CARAT.add(CARAT78);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:302:10: ( TILDE )?
+ int alt38=2;
+ int LA38_0 = input.LA(1);
+
+ if ( (LA38_0==TILDE) ) {
+ alt38=1;
+ }
+ switch (alt38) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:302:10: TILDE
+ {
+ TILDE79=(Token)match(input,TILDE,FOLLOW_TILDE_in_term_modifier1584); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TILDE.add(TILDE79);
+
+
+ }
+ break;
+
+ }
+
+
+ // AST REWRITE
+ // elements: TILDE, CARAT
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 302:17: -> ^( BOOST CARAT ) ^( FUZZY ( TILDE )? )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:302:20: ^( BOOST CARAT )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(BOOST, "BOOST")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ stream_CARAT.nextNode()
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:302:35: ^( FUZZY ( TILDE )? )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(FUZZY, "FUZZY")
+ , root_1);
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:302:43: ( TILDE )?
+ if ( stream_TILDE.hasNext() ) {
+ adaptor.addChild(root_1,
+ stream_TILDE.nextNode()
+ );
+
+ }
+ stream_TILDE.reset();
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "term_modifier"
+
+
+ public static class boost_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "boost"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:322:1: boost : ( CARAT -> ^( BOOST NUMBER[\"DEF\"] ) ) ( NUMBER -> ^( BOOST NUMBER ) )? ;
+ public final StandardLuceneGrammarParser.boost_return boost() throws RecognitionException {
+ StandardLuceneGrammarParser.boost_return retval = new StandardLuceneGrammarParser.boost_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token CARAT80=null;
+ Token NUMBER81=null;
+
+ Object CARAT80_tree=null;
+ Object NUMBER81_tree=null;
+ RewriteRuleTokenStream stream_CARAT=new RewriteRuleTokenStream(adaptor,"token CARAT");
+ RewriteRuleTokenStream stream_NUMBER=new RewriteRuleTokenStream(adaptor,"token NUMBER");
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:322:7: ( ( CARAT -> ^( BOOST NUMBER[\"DEF\"] ) ) ( NUMBER -> ^( BOOST NUMBER ) )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:323:2: ( CARAT -> ^( BOOST NUMBER[\"DEF\"] ) ) ( NUMBER -> ^( BOOST NUMBER ) )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:323:2: ( CARAT -> ^( BOOST NUMBER[\"DEF\"] ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:323:3: CARAT
+ {
+ CARAT80=(Token)match(input,CARAT,FOLLOW_CARAT_in_boost1616); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_CARAT.add(CARAT80);
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 323:9: -> ^( BOOST NUMBER[\"DEF\"] )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:323:12: ^( BOOST NUMBER[\"DEF\"] )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(BOOST, "BOOST")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ (Object)adaptor.create(NUMBER, "DEF")
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:324:2: ( NUMBER -> ^( BOOST NUMBER ) )?
+ int alt40=2;
+ int LA40_0 = input.LA(1);
+
+ if ( (LA40_0==NUMBER) ) {
+ alt40=1;
+ }
+ switch (alt40) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:324:3: NUMBER
+ {
+ NUMBER81=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_boost1631); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_NUMBER.add(NUMBER81);
+
+
+ // AST REWRITE
+ // elements: NUMBER
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 324:10: -> ^( BOOST NUMBER )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:324:13: ^( BOOST NUMBER )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(BOOST, "BOOST")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ stream_NUMBER.nextNode()
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "boost"
+
+
+ public static class fuzzy_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "fuzzy"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:327:1: fuzzy : ( TILDE -> ^( FUZZY NUMBER[\"DEF\"] ) ) ( NUMBER -> ^( FUZZY NUMBER ) )? ;
+ public final StandardLuceneGrammarParser.fuzzy_return fuzzy() throws RecognitionException {
+ StandardLuceneGrammarParser.fuzzy_return retval = new StandardLuceneGrammarParser.fuzzy_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token TILDE82=null;
+ Token NUMBER83=null;
+
+ Object TILDE82_tree=null;
+ Object NUMBER83_tree=null;
+ RewriteRuleTokenStream stream_TILDE=new RewriteRuleTokenStream(adaptor,"token TILDE");
+ RewriteRuleTokenStream stream_NUMBER=new RewriteRuleTokenStream(adaptor,"token NUMBER");
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:327:7: ( ( TILDE -> ^( FUZZY NUMBER[\"DEF\"] ) ) ( NUMBER -> ^( FUZZY NUMBER ) )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:328:2: ( TILDE -> ^( FUZZY NUMBER[\"DEF\"] ) ) ( NUMBER -> ^( FUZZY NUMBER ) )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:328:2: ( TILDE -> ^( FUZZY NUMBER[\"DEF\"] ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:328:3: TILDE
+ {
+ TILDE82=(Token)match(input,TILDE,FOLLOW_TILDE_in_fuzzy1654); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_TILDE.add(TILDE82);
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 328:9: -> ^( FUZZY NUMBER[\"DEF\"] )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:328:12: ^( FUZZY NUMBER[\"DEF\"] )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(FUZZY, "FUZZY")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ (Object)adaptor.create(NUMBER, "DEF")
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:329:2: ( NUMBER -> ^( FUZZY NUMBER ) )?
+ int alt41=2;
+ int LA41_0 = input.LA(1);
+
+ if ( (LA41_0==NUMBER) ) {
+ alt41=1;
+ }
+ switch (alt41) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:329:3: NUMBER
+ {
+ NUMBER83=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_fuzzy1669); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_NUMBER.add(NUMBER83);
+
+
+ // AST REWRITE
+ // elements: NUMBER
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 329:10: -> ^( FUZZY NUMBER )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:329:13: ^( FUZZY NUMBER )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(FUZZY, "FUZZY")
+ , root_1);
+
+ adaptor.addChild(root_1,
+ stream_NUMBER.nextNode()
+ );
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "fuzzy"
+
+
+ public static class not_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "not"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:332:1: not : ( ( AND NOT )=> AND NOT | NOT );
+ public final StandardLuceneGrammarParser.not_return not() throws RecognitionException {
+ StandardLuceneGrammarParser.not_return retval = new StandardLuceneGrammarParser.not_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token AND84=null;
+ Token NOT85=null;
+ Token NOT86=null;
+
+ Object AND84_tree=null;
+ Object NOT85_tree=null;
+ Object NOT86_tree=null;
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:332:5: ( ( AND NOT )=> AND NOT | NOT )
+ int alt42=2;
+ int LA42_0 = input.LA(1);
+
+ if ( (LA42_0==AND) && (synpred4_StandardLuceneGrammar())) {
+ alt42=1;
+ }
+ else if ( (LA42_0==NOT) ) {
+ alt42=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return retval;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 42, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt42) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:333:2: ( AND NOT )=> AND NOT
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ AND84=(Token)match(input,AND,FOLLOW_AND_in_not1699); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ AND84_tree =
+ (Object)adaptor.create(AND84)
+ ;
+ adaptor.addChild(root_0, AND84_tree);
+ }
+
+ NOT85=(Token)match(input,NOT,FOLLOW_NOT_in_not1701); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ NOT85_tree =
+ (Object)adaptor.create(NOT85)
+ ;
+ adaptor.addChild(root_0, NOT85_tree);
+ }
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:334:4: NOT
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ NOT86=(Token)match(input,NOT,FOLLOW_NOT_in_not1706); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ NOT86_tree =
+ (Object)adaptor.create(NOT86)
+ ;
+ adaptor.addChild(root_0, NOT86_tree);
+ }
+
+ }
+ break;
+
+ }
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "not"
+
+
+ public static class and_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "and"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:337:1: and : AND ;
+ public final StandardLuceneGrammarParser.and_return and() throws RecognitionException {
+ StandardLuceneGrammarParser.and_return retval = new StandardLuceneGrammarParser.and_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token AND87=null;
+
+ Object AND87_tree=null;
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:337:6: ( AND )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:338:2: AND
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ AND87=(Token)match(input,AND,FOLLOW_AND_in_and1720); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ AND87_tree =
+ (Object)adaptor.create(AND87)
+ ;
+ adaptor.addChild(root_0, AND87_tree);
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "and"
+
+
+ public static class or_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "or"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:341:1: or : OR ;
+ public final StandardLuceneGrammarParser.or_return or() throws RecognitionException {
+ StandardLuceneGrammarParser.or_return retval = new StandardLuceneGrammarParser.or_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token OR88=null;
+
+ Object OR88_tree=null;
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:341:5: ( OR )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:342:2: OR
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ OR88=(Token)match(input,OR,FOLLOW_OR_in_or1734); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ OR88_tree =
+ (Object)adaptor.create(OR88)
+ ;
+ adaptor.addChild(root_0, OR88_tree);
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "or"
+
+
+ public static class near_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "near"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:345:1: near : ( NEAR -> ^( OPERATOR[\"NEAR\"] ) ) ( '/' b= NUMBER -> ^( OPERATOR[\"NEAR:\" + $b.getText()] ) )? ;
+ public final StandardLuceneGrammarParser.near_return near() throws RecognitionException {
+ StandardLuceneGrammarParser.near_return retval = new StandardLuceneGrammarParser.near_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token b=null;
+ Token NEAR89=null;
+ Token char_literal90=null;
+
+ Object b_tree=null;
+ Object NEAR89_tree=null;
+ Object char_literal90_tree=null;
+ RewriteRuleTokenStream stream_NEAR=new RewriteRuleTokenStream(adaptor,"token NEAR");
+ RewriteRuleTokenStream stream_53=new RewriteRuleTokenStream(adaptor,"token 53");
+ RewriteRuleTokenStream stream_NUMBER=new RewriteRuleTokenStream(adaptor,"token NUMBER");
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:345:6: ( ( NEAR -> ^( OPERATOR[\"NEAR\"] ) ) ( '/' b= NUMBER -> ^( OPERATOR[\"NEAR:\" + $b.getText()] ) )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:346:2: ( NEAR -> ^( OPERATOR[\"NEAR\"] ) ) ( '/' b= NUMBER -> ^( OPERATOR[\"NEAR:\" + $b.getText()] ) )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:346:2: ( NEAR -> ^( OPERATOR[\"NEAR\"] ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:346:3: NEAR
+ {
+ NEAR89=(Token)match(input,NEAR,FOLLOW_NEAR_in_near1749); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_NEAR.add(NEAR89);
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 346:8: -> ^( OPERATOR[\"NEAR\"] )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:346:11: ^( OPERATOR[\"NEAR\"] )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "NEAR")
+ , root_1);
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:347:2: ( '/' b= NUMBER -> ^( OPERATOR[\"NEAR:\" + $b.getText()] ) )?
+ int alt43=2;
+ int LA43_0 = input.LA(1);
+
+ if ( (LA43_0==53) ) {
+ alt43=1;
+ }
+ switch (alt43) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:347:3: '/' b= NUMBER
+ {
+ char_literal90=(Token)match(input,53,FOLLOW_53_in_near1762); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_53.add(char_literal90);
+
+
+ b=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_near1766); if (state.failed) return retval;
+ if ( state.backtracking==0 ) stream_NUMBER.add(b);
+
+
+ // AST REWRITE
+ // elements:
+ // token labels:
+ // rule labels: retval
+ // token list labels:
+ // rule list labels:
+ // wildcard labels:
+ if ( state.backtracking==0 ) {
+
+ retval.tree = root_0;
+ RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+ root_0 = (Object)adaptor.nil();
+ // 347:16: -> ^( OPERATOR[\"NEAR:\" + $b.getText()] )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:347:19: ^( OPERATOR[\"NEAR:\" + $b.getText()] )
+ {
+ Object root_1 = (Object)adaptor.nil();
+ root_1 = (Object)adaptor.becomeRoot(
+ (Object)adaptor.create(OPERATOR, "NEAR:" + b.getText())
+ , root_1);
+
+ adaptor.addChild(root_0, root_1);
+ }
+
+ }
+
+
+ retval.tree = root_0;
+ }
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "near"
+
+
+ public static class date_return extends ParserRuleReturnScope {
+ Object tree;
+ public Object getTree() { return tree; }
+ };
+
+
+ // $ANTLR start "date"
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:350:1: date : DATE_TOKEN ;
+ public final StandardLuceneGrammarParser.date_return date() throws RecognitionException {
+ StandardLuceneGrammarParser.date_return retval = new StandardLuceneGrammarParser.date_return();
+ retval.start = input.LT(1);
+
+
+ Object root_0 = null;
+
+ Token DATE_TOKEN91=null;
+
+ Object DATE_TOKEN91_tree=null;
+
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:350:6: ( DATE_TOKEN )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:352:2: DATE_TOKEN
+ {
+ root_0 = (Object)adaptor.nil();
+
+
+ DATE_TOKEN91=(Token)match(input,DATE_TOKEN,FOLLOW_DATE_TOKEN_in_date1790); if (state.failed) return retval;
+ if ( state.backtracking==0 ) {
+ DATE_TOKEN91_tree =
+ (Object)adaptor.create(DATE_TOKEN91)
+ ;
+ adaptor.addChild(root_0, DATE_TOKEN91_tree);
+ }
+
+ }
+
+ retval.stop = input.LT(-1);
+
+
+ if ( state.backtracking==0 ) {
+
+ retval.tree = (Object)adaptor.rulePostProcessing(root_0);
+ adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
+ }
+ }
+ catch (RecognitionException re) {
+ reportError(re);
+ recover(input,re);
+ retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
+
+ }
+
+ finally {
+ // do for sure before leaving
+ }
+ return retval;
+ }
+ // $ANTLR end "date"
+
+ // $ANTLR start synpred1_StandardLuceneGrammar
+ public final void synpred1_StandardLuceneGrammar_fragment() throws RecognitionException {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:2: ( modifier LPAREN ( clauseOr )+ RPAREN )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:3: modifier LPAREN ( clauseOr )+ RPAREN
+ {
+ pushFollow(FOLLOW_modifier_in_synpred1_StandardLuceneGrammar416);
+ modifier();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ match(input,LPAREN,FOLLOW_LPAREN_in_synpred1_StandardLuceneGrammar418); if (state.failed) return ;
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:19: ( clauseOr )+
+ int cnt44=0;
+ loop44:
+ do {
+ int alt44=2;
+ int LA44_0 = input.LA(1);
+
+ if ( ((LA44_0 >= LBRACK && LA44_0 <= MINUS)||LA44_0==NUMBER||(LA44_0 >= PHRASE && LA44_0 <= PLUS)||LA44_0==QMARK||LA44_0==STAR||LA44_0==TERM_NORMAL||LA44_0==TERM_TRUNCATED) ) {
+ alt44=1;
+ }
+
+
+ switch (alt44) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:123:19: clauseOr
+ {
+ pushFollow(FOLLOW_clauseOr_in_synpred1_StandardLuceneGrammar420);
+ clauseOr();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ if ( cnt44 >= 1 ) break loop44;
+ if (state.backtracking>0) {state.failed=true; return ;}
+ EarlyExitException eee =
+ new EarlyExitException(44, input);
+ throw eee;
+ }
+ cnt44++;
+ } while (true);
+
+
+ match(input,RPAREN,FOLLOW_RPAREN_in_synpred1_StandardLuceneGrammar423); if (state.failed) return ;
+
+ }
+
+ }
+ // $ANTLR end synpred1_StandardLuceneGrammar
+
+ // $ANTLR start synpred2_StandardLuceneGrammar
+ public final void synpred2_StandardLuceneGrammar_fragment() throws RecognitionException {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:4: ( LPAREN ( clauseOr )+ RPAREN term_modifier )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:5: LPAREN ( clauseOr )+ RPAREN term_modifier
+ {
+ match(input,LPAREN,FOLLOW_LPAREN_in_synpred2_StandardLuceneGrammar477); if (state.failed) return ;
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:12: ( clauseOr )+
+ int cnt45=0;
+ loop45:
+ do {
+ int alt45=2;
+ int LA45_0 = input.LA(1);
+
+ if ( ((LA45_0 >= LBRACK && LA45_0 <= MINUS)||LA45_0==NUMBER||(LA45_0 >= PHRASE && LA45_0 <= PLUS)||LA45_0==QMARK||LA45_0==STAR||LA45_0==TERM_NORMAL||LA45_0==TERM_TRUNCATED) ) {
+ alt45=1;
+ }
+
+
+ switch (alt45) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:125:12: clauseOr
+ {
+ pushFollow(FOLLOW_clauseOr_in_synpred2_StandardLuceneGrammar479);
+ clauseOr();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+ break;
+
+ default :
+ if ( cnt45 >= 1 ) break loop45;
+ if (state.backtracking>0) {state.failed=true; return ;}
+ EarlyExitException eee =
+ new EarlyExitException(45, input);
+ throw eee;
+ }
+ cnt45++;
+ } while (true);
+
+
+ match(input,RPAREN,FOLLOW_RPAREN_in_synpred2_StandardLuceneGrammar482); if (state.failed) return ;
+
+ pushFollow(FOLLOW_term_modifier_in_synpred2_StandardLuceneGrammar484);
+ term_modifier();
+
+ state._fsp--;
+ if (state.failed) return ;
+
+ }
+
+ }
+ // $ANTLR end synpred2_StandardLuceneGrammar
+
+ // $ANTLR start synpred3_StandardLuceneGrammar
+ public final void synpred3_StandardLuceneGrammar_fragment() throws RecognitionException {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:127:4: ( LPAREN )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:127:5: LPAREN
+ {
+ match(input,LPAREN,FOLLOW_LPAREN_in_synpred3_StandardLuceneGrammar537); if (state.failed) return ;
+
+ }
+
+ }
+ // $ANTLR end synpred3_StandardLuceneGrammar
+
+ // $ANTLR start synpred4_StandardLuceneGrammar
+ public final void synpred4_StandardLuceneGrammar_fragment() throws RecognitionException {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:333:2: ( AND NOT )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:333:3: AND NOT
+ {
+ match(input,AND,FOLLOW_AND_in_synpred4_StandardLuceneGrammar1693); if (state.failed) return ;
+
+ match(input,NOT,FOLLOW_NOT_in_synpred4_StandardLuceneGrammar1695); if (state.failed) return ;
+
+ }
+
+ }
+ // $ANTLR end synpred4_StandardLuceneGrammar
+
+ // Delegated rules
+
+ public final boolean synpred1_StandardLuceneGrammar() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred1_StandardLuceneGrammar_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred4_StandardLuceneGrammar() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred4_StandardLuceneGrammar_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred3_StandardLuceneGrammar() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred3_StandardLuceneGrammar_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+ public final boolean synpred2_StandardLuceneGrammar() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred2_StandardLuceneGrammar_fragment(); // can never throw exception
+ } catch (RecognitionException re) {
+ System.err.println("impossible: "+re);
+ }
+ boolean success = !state.failed;
+ input.rewind(start);
+ state.backtracking--;
+ state.failed=false;
+ return success;
+ }
+
+
+
+
+ public static final BitSet FOLLOW_clauseOr_in_mainQ209 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_EOF_in_mainQ212 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_clauseAnd_in_clauseOr243 = new BitSet(new long[]{0x0000000004000002L});
+ public static final BitSet FOLLOW_or_in_clauseOr252 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseAnd_in_clauseOr256 = new BitSet(new long[]{0x0000000004000002L});
+ public static final BitSet FOLLOW_clauseNot_in_clauseAnd285 = new BitSet(new long[]{0x0000000000000022L});
+ public static final BitSet FOLLOW_and_in_clauseAnd295 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseNot_in_clauseAnd299 = new BitSet(new long[]{0x0000000000000022L});
+ public static final BitSet FOLLOW_clauseNear_in_clauseNot330 = new BitSet(new long[]{0x0000000000800022L});
+ public static final BitSet FOLLOW_not_in_clauseNot339 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseNear_in_clauseNot343 = new BitSet(new long[]{0x0000000000800022L});
+ public static final BitSet FOLLOW_clauseBasic_in_clauseNear374 = new BitSet(new long[]{0x0000000000400002L});
+ public static final BitSet FOLLOW_near_in_clauseNear383 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseBasic_in_clauseNear387 = new BitSet(new long[]{0x0000000000400002L});
+ public static final BitSet FOLLOW_modifier_in_clauseBasic428 = new BitSet(new long[]{0x0000000000080000L});
+ public static final BitSet FOLLOW_LPAREN_in_clauseBasic431 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseOr_in_clauseBasic433 = new BitSet(new long[]{0x0000AA01391E0000L});
+ public static final BitSet FOLLOW_RPAREN_in_clauseBasic436 = new BitSet(new long[]{0x0001000000000102L});
+ public static final BitSet FOLLOW_term_modifier_in_clauseBasic438 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_modifier_in_clauseBasic488 = new BitSet(new long[]{0x0000000000080000L});
+ public static final BitSet FOLLOW_LPAREN_in_clauseBasic491 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseOr_in_clauseBasic493 = new BitSet(new long[]{0x0000AA01391E0000L});
+ public static final BitSet FOLLOW_RPAREN_in_clauseBasic496 = new BitSet(new long[]{0x0001000000000102L});
+ public static final BitSet FOLLOW_term_modifier_in_clauseBasic498 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LPAREN_in_clauseBasic543 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseOr_in_clauseBasic545 = new BitSet(new long[]{0x0000AA01391E0000L});
+ public static final BitSet FOLLOW_RPAREN_in_clauseBasic548 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_atom_in_clauseBasic560 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_modifier_in_atom581 = new BitSet(new long[]{0x0000200000000000L});
+ public static final BitSet FOLLOW_field_in_atom584 = new BitSet(new long[]{0x0000000000080000L});
+ public static final BitSet FOLLOW_multi_value_in_atom586 = new BitSet(new long[]{0x0001000000000102L});
+ public static final BitSet FOLLOW_term_modifier_in_atom588 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_modifier_in_atom624 = new BitSet(new long[]{0x0000A00119060000L});
+ public static final BitSet FOLLOW_field_in_atom627 = new BitSet(new long[]{0x0000A00119060000L});
+ public static final BitSet FOLLOW_value_in_atom630 = new BitSet(new long[]{0x0001000000000102L});
+ public static final BitSet FOLLOW_term_modifier_in_atom632 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_modifier_in_atom666 = new BitSet(new long[]{0x0000080000000000L});
+ public static final BitSet FOLLOW_STAR_in_atom670 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_COLON_in_atom672 = new BitSet(new long[]{0x0000080000000000L});
+ public static final BitSet FOLLOW_STAR_in_atom676 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TERM_NORMAL_in_field713 = new BitSet(new long[]{0x0000000000000400L});
+ public static final BitSet FOLLOW_COLON_in_field715 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_range_term_in_in_value734 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_range_term_ex_in_value747 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_normal_in_value761 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_truncated_in_value775 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_quoted_in_value789 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_quoted_truncated_in_value802 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_QMARK_in_value815 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LBRACK_in_range_term_in847 = new BitSet(new long[]{0x0000A80019000800L});
+ public static final BitSet FOLLOW_range_value_in_range_term_in859 = new BitSet(new long[]{0x0004A88019000800L});
+ public static final BitSet FOLLOW_TO_in_range_term_in882 = new BitSet(new long[]{0x0000A80019000800L});
+ public static final BitSet FOLLOW_range_value_in_range_term_in887 = new BitSet(new long[]{0x0000008000000000L});
+ public static final BitSet FOLLOW_RBRACK_in_range_term_in908 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LCURLY_in_range_term_ex928 = new BitSet(new long[]{0x0000A80019000800L});
+ public static final BitSet FOLLOW_range_value_in_range_term_ex941 = new BitSet(new long[]{0x0004A90019000800L});
+ public static final BitSet FOLLOW_TO_in_range_term_ex964 = new BitSet(new long[]{0x0000A80019000800L});
+ public static final BitSet FOLLOW_range_value_in_range_term_ex969 = new BitSet(new long[]{0x0000010000000000L});
+ public static final BitSet FOLLOW_RCURLY_in_range_term_ex990 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_truncated_in_range_value1004 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_quoted_in_range_value1017 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_quoted_truncated_in_range_value1030 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_date_in_range_value1043 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_normal_in_range_value1056 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_STAR_in_range_value1070 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LPAREN_in_multi_value1091 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_multiClause_in_multi_value1093 = new BitSet(new long[]{0x0000020000000000L});
+ public static final BitSet FOLLOW_RPAREN_in_multi_value1095 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_clauseOr_in_multiClause1122 = new BitSet(new long[]{0x0000A801391E0002L});
+ public static final BitSet FOLLOW_multiOr_in_multiDefault1166 = new BitSet(new long[]{0x0000A00139160002L});
+ public static final BitSet FOLLOW_multiAnd_in_multiOr1194 = new BitSet(new long[]{0x0000000004000002L});
+ public static final BitSet FOLLOW_or_in_multiOr1204 = new BitSet(new long[]{0x0000A00139160000L});
+ public static final BitSet FOLLOW_multiAnd_in_multiOr1208 = new BitSet(new long[]{0x0000000004000002L});
+ public static final BitSet FOLLOW_multiNot_in_multiAnd1239 = new BitSet(new long[]{0x0000000000000022L});
+ public static final BitSet FOLLOW_and_in_multiAnd1249 = new BitSet(new long[]{0x0000A00139160000L});
+ public static final BitSet FOLLOW_multiNot_in_multiAnd1253 = new BitSet(new long[]{0x0000000000000022L});
+ public static final BitSet FOLLOW_multiNear_in_multiNot1284 = new BitSet(new long[]{0x0000000000800022L});
+ public static final BitSet FOLLOW_not_in_multiNot1294 = new BitSet(new long[]{0x0000A00139160000L});
+ public static final BitSet FOLLOW_multiNear_in_multiNot1298 = new BitSet(new long[]{0x0000000000800022L});
+ public static final BitSet FOLLOW_multiBasic_in_multiNear1328 = new BitSet(new long[]{0x0000000000400002L});
+ public static final BitSet FOLLOW_near_in_multiNear1338 = new BitSet(new long[]{0x0000A00139160000L});
+ public static final BitSet FOLLOW_multiBasic_in_multiNear1342 = new BitSet(new long[]{0x0000000000400002L});
+ public static final BitSet FOLLOW_mterm_in_multiBasic1368 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_modifier_in_mterm1384 = new BitSet(new long[]{0x0000A00119060000L});
+ public static final BitSet FOLLOW_value_in_mterm1387 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TERM_TRUNCATED_in_truncated1440 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_PHRASE_ANYTHING_in_quoted_truncated1455 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_PHRASE_in_quoted1467 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_AND_in_operator1483 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_OR_in_operator1493 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_NOT_in_operator1503 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_NEAR_in_operator1513 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_PLUS_in_modifier1530 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_MINUS_in_modifier1540 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TILDE_in_term_modifier1558 = new BitSet(new long[]{0x0000000000000102L});
+ public static final BitSet FOLLOW_CARAT_in_term_modifier1560 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CARAT_in_term_modifier1582 = new BitSet(new long[]{0x0001000000000002L});
+ public static final BitSet FOLLOW_TILDE_in_term_modifier1584 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_CARAT_in_boost1616 = new BitSet(new long[]{0x0000000001000002L});
+ public static final BitSet FOLLOW_NUMBER_in_boost1631 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_TILDE_in_fuzzy1654 = new BitSet(new long[]{0x0000000001000002L});
+ public static final BitSet FOLLOW_NUMBER_in_fuzzy1669 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_AND_in_not1699 = new BitSet(new long[]{0x0000000000800000L});
+ public static final BitSet FOLLOW_NOT_in_not1701 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_NOT_in_not1706 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_AND_in_and1720 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_OR_in_or1734 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_NEAR_in_near1749 = new BitSet(new long[]{0x0020000000000002L});
+ public static final BitSet FOLLOW_53_in_near1762 = new BitSet(new long[]{0x0000000001000000L});
+ public static final BitSet FOLLOW_NUMBER_in_near1766 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_DATE_TOKEN_in_date1790 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_modifier_in_synpred1_StandardLuceneGrammar416 = new BitSet(new long[]{0x0000000000080000L});
+ public static final BitSet FOLLOW_LPAREN_in_synpred1_StandardLuceneGrammar418 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseOr_in_synpred1_StandardLuceneGrammar420 = new BitSet(new long[]{0x0000AA01391E0000L});
+ public static final BitSet FOLLOW_RPAREN_in_synpred1_StandardLuceneGrammar423 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LPAREN_in_synpred2_StandardLuceneGrammar477 = new BitSet(new long[]{0x0000A801391E0000L});
+ public static final BitSet FOLLOW_clauseOr_in_synpred2_StandardLuceneGrammar479 = new BitSet(new long[]{0x0000AA01391E0000L});
+ public static final BitSet FOLLOW_RPAREN_in_synpred2_StandardLuceneGrammar482 = new BitSet(new long[]{0x0001000000000100L});
+ public static final BitSet FOLLOW_term_modifier_in_synpred2_StandardLuceneGrammar484 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_LPAREN_in_synpred3_StandardLuceneGrammar537 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_AND_in_synpred4_StandardLuceneGrammar1693 = new BitSet(new long[]{0x0000000000800000L});
+ public static final BitSet FOLLOW_NOT_in_synpred4_StandardLuceneGrammar1695 = new BitSet(new long[]{0x0000000000000002L});
+
+}
\ No newline at end of file
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarLexer.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarLexer.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarLexer.java (revision 0)
@@ -0,0 +1,4216 @@
+// $ANTLR 3.4 /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g 2013-05-22 18:30:46
+
+ package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings({"all", "warnings", "unchecked"})
+public class StandardLuceneGrammarLexer extends Lexer {
+ public static final int EOF=-1;
+ public static final int T__53=53;
+ public static final int AMPER=4;
+ public static final int AND=5;
+ public static final int ATOM=6;
+ public static final int BOOST=7;
+ public static final int CARAT=8;
+ public static final int CLAUSE=9;
+ public static final int COLON=10;
+ public static final int DATE_TOKEN=11;
+ public static final int DQUOTE=12;
+ public static final int ESC_CHAR=13;
+ public static final int FIELD=14;
+ public static final int FUZZY=15;
+ public static final int INT=16;
+ public static final int LBRACK=17;
+ public static final int LCURLY=18;
+ public static final int LPAREN=19;
+ public static final int MINUS=20;
+ public static final int MODIFIER=21;
+ public static final int NEAR=22;
+ public static final int NOT=23;
+ public static final int NUMBER=24;
+ public static final int OPERATOR=25;
+ public static final int OR=26;
+ public static final int PHRASE=27;
+ public static final int PHRASE_ANYTHING=28;
+ public static final int PLUS=29;
+ public static final int QANYTHING=30;
+ public static final int QDATE=31;
+ public static final int QMARK=32;
+ public static final int QNORMAL=33;
+ public static final int QPHRASE=34;
+ public static final int QPHRASETRUNC=35;
+ public static final int QRANGEEX=36;
+ public static final int QRANGEIN=37;
+ public static final int QTRUNCATED=38;
+ public static final int RBRACK=39;
+ public static final int RCURLY=40;
+ public static final int RPAREN=41;
+ public static final int SQUOTE=42;
+ public static final int STAR=43;
+ public static final int TERM_CHAR=44;
+ public static final int TERM_NORMAL=45;
+ public static final int TERM_START_CHAR=46;
+ public static final int TERM_TRUNCATED=47;
+ public static final int TILDE=48;
+ public static final int TMODIFIER=49;
+ public static final int TO=50;
+ public static final int VBAR=51;
+ public static final int WS=52;
+
+ public void recover(RecognitionException re) {
+ // throw unchecked exception
+ throw new RuntimeException(re);
+ }
+
+
+ // delegates
+ // delegators
+ public Lexer[] getDelegates() {
+ return new Lexer[] {};
+ }
+
+ public StandardLuceneGrammarLexer() {}
+ public StandardLuceneGrammarLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public StandardLuceneGrammarLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+ }
+ public String getGrammarFileName() { return "/dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g"; }
+
+ // $ANTLR start "T__53"
+ public final void mT__53() throws RecognitionException {
+ try {
+ int _type = T__53;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:17:7: ( '/' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:17:9: '/'
+ {
+ match('/');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "T__53"
+
+ // $ANTLR start "LPAREN"
+ public final void mLPAREN() throws RecognitionException {
+ try {
+ int _type = LPAREN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:362:9: ( '(' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:362:11: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "LPAREN"
+
+ // $ANTLR start "RPAREN"
+ public final void mRPAREN() throws RecognitionException {
+ try {
+ int _type = RPAREN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:364:9: ( ')' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:364:11: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "RPAREN"
+
+ // $ANTLR start "LBRACK"
+ public final void mLBRACK() throws RecognitionException {
+ try {
+ int _type = LBRACK;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:366:9: ( '[' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:366:11: '['
+ {
+ match('[');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "LBRACK"
+
+ // $ANTLR start "RBRACK"
+ public final void mRBRACK() throws RecognitionException {
+ try {
+ int _type = RBRACK;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:368:9: ( ']' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:368:11: ']'
+ {
+ match(']');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "RBRACK"
+
+ // $ANTLR start "COLON"
+ public final void mCOLON() throws RecognitionException {
+ try {
+ int _type = COLON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:370:9: ( ':' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:370:11: ':'
+ {
+ match(':');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "COLON"
+
+ // $ANTLR start "PLUS"
+ public final void mPLUS() throws RecognitionException {
+ try {
+ int _type = PLUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:372:7: ( '+' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:372:9: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "PLUS"
+
+ // $ANTLR start "MINUS"
+ public final void mMINUS() throws RecognitionException {
+ try {
+ int _type = MINUS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:374:7: ( ( '-' | '\\!' ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( input.LA(1)=='!'||input.LA(1)=='-' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "MINUS"
+
+ // $ANTLR start "STAR"
+ public final void mSTAR() throws RecognitionException {
+ try {
+ int _type = STAR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:376:7: ( '*' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:376:9: '*'
+ {
+ match('*');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "STAR"
+
+ // $ANTLR start "QMARK"
+ public final void mQMARK() throws RecognitionException {
+ try {
+ int _type = QMARK;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:378:8: ( ( '?' )+ )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:378:10: ( '?' )+
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:378:10: ( '?' )+
+ int cnt1=0;
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0=='?') ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:378:10: '?'
+ {
+ match('?');
+
+ }
+ break;
+
+ default :
+ if ( cnt1 >= 1 ) break loop1;
+ EarlyExitException eee =
+ new EarlyExitException(1, input);
+ throw eee;
+ }
+ cnt1++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "QMARK"
+
+ // $ANTLR start "VBAR"
+ public final void mVBAR() throws RecognitionException {
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:380:16: ( '|' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:380:18: '|'
+ {
+ match('|');
+
+ }
+
+
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "VBAR"
+
+ // $ANTLR start "AMPER"
+ public final void mAMPER() throws RecognitionException {
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:382:16: ( '&' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:382:18: '&'
+ {
+ match('&');
+
+ }
+
+
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "AMPER"
+
+ // $ANTLR start "LCURLY"
+ public final void mLCURLY() throws RecognitionException {
+ try {
+ int _type = LCURLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:384:9: ( '{' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:384:11: '{'
+ {
+ match('{');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "LCURLY"
+
+ // $ANTLR start "RCURLY"
+ public final void mRCURLY() throws RecognitionException {
+ try {
+ int _type = RCURLY;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:386:9: ( '}' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:386:11: '}'
+ {
+ match('}');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "RCURLY"
+
+ // $ANTLR start "CARAT"
+ public final void mCARAT() throws RecognitionException {
+ try {
+ int _type = CARAT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:388:7: ( '^' ( ( INT )+ ( '.' ( INT )+ )? )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:388:9: '^' ( ( INT )+ ( '.' ( INT )+ )? )?
+ {
+ match('^');
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:388:13: ( ( INT )+ ( '.' ( INT )+ )? )?
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( ((LA5_0 >= '0' && LA5_0 <= '9')) ) {
+ alt5=1;
+ }
+ switch (alt5) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:388:14: ( INT )+ ( '.' ( INT )+ )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:388:14: ( INT )+
+ int cnt2=0;
+ loop2:
+ do {
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( ((LA2_0 >= '0' && LA2_0 <= '9')) ) {
+ alt2=1;
+ }
+
+
+ switch (alt2) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt2 >= 1 ) break loop2;
+ EarlyExitException eee =
+ new EarlyExitException(2, input);
+ throw eee;
+ }
+ cnt2++;
+ } while (true);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:388:19: ( '.' ( INT )+ )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0=='.') ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:388:20: '.' ( INT )+
+ {
+ match('.');
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:388:24: ( INT )+
+ int cnt3=0;
+ loop3:
+ do {
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( ((LA3_0 >= '0' && LA3_0 <= '9')) ) {
+ alt3=1;
+ }
+
+
+ switch (alt3) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt3 >= 1 ) break loop3;
+ EarlyExitException eee =
+ new EarlyExitException(3, input);
+ throw eee;
+ }
+ cnt3++;
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "CARAT"
+
+ // $ANTLR start "TILDE"
+ public final void mTILDE() throws RecognitionException {
+ try {
+ int _type = TILDE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:390:7: ( '~' ( ( INT )+ ( '.' ( INT )+ )? )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:390:9: '~' ( ( INT )+ ( '.' ( INT )+ )? )?
+ {
+ match('~');
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:390:13: ( ( INT )+ ( '.' ( INT )+ )? )?
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( ((LA9_0 >= '0' && LA9_0 <= '9')) ) {
+ alt9=1;
+ }
+ switch (alt9) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:390:14: ( INT )+ ( '.' ( INT )+ )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:390:14: ( INT )+
+ int cnt6=0;
+ loop6:
+ do {
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( ((LA6_0 >= '0' && LA6_0 <= '9')) ) {
+ alt6=1;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt6 >= 1 ) break loop6;
+ EarlyExitException eee =
+ new EarlyExitException(6, input);
+ throw eee;
+ }
+ cnt6++;
+ } while (true);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:390:19: ( '.' ( INT )+ )?
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='.') ) {
+ alt8=1;
+ }
+ switch (alt8) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:390:20: '.' ( INT )+
+ {
+ match('.');
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:390:24: ( INT )+
+ int cnt7=0;
+ loop7:
+ do {
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( ((LA7_0 >= '0' && LA7_0 <= '9')) ) {
+ alt7=1;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt7 >= 1 ) break loop7;
+ EarlyExitException eee =
+ new EarlyExitException(7, input);
+ throw eee;
+ }
+ cnt7++;
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "TILDE"
+
+ // $ANTLR start "DQUOTE"
+ public final void mDQUOTE() throws RecognitionException {
+ try {
+ int _type = DQUOTE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:393:2: ( '\\\"' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:393:4: '\\\"'
+ {
+ match('\"');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "DQUOTE"
+
+ // $ANTLR start "SQUOTE"
+ public final void mSQUOTE() throws RecognitionException {
+ try {
+ int _type = SQUOTE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:396:2: ( '\\'' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:396:4: '\\''
+ {
+ match('\'');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "SQUOTE"
+
+ // $ANTLR start "TO"
+ public final void mTO() throws RecognitionException {
+ try {
+ int _type = TO;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:401:4: ( 'TO' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:401:6: 'TO'
+ {
+ match("TO");
+
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "TO"
+
+ // $ANTLR start "AND"
+ public final void mAND() throws RecognitionException {
+ try {
+ int _type = AND;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:404:7: ( ( ( 'a' | 'A' ) ( 'n' | 'N' ) ( 'd' | 'D' ) | ( AMPER ( AMPER )? ) ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:404:9: ( ( 'a' | 'A' ) ( 'n' | 'N' ) ( 'd' | 'D' ) | ( AMPER ( AMPER )? ) )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:404:9: ( ( 'a' | 'A' ) ( 'n' | 'N' ) ( 'd' | 'D' ) | ( AMPER ( AMPER )? ) )
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( (LA11_0=='A'||LA11_0=='a') ) {
+ alt11=1;
+ }
+ else if ( (LA11_0=='&') ) {
+ alt11=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt11) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:404:10: ( 'a' | 'A' ) ( 'n' | 'N' ) ( 'd' | 'D' )
+ {
+ if ( input.LA(1)=='A'||input.LA(1)=='a' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ if ( input.LA(1)=='N'||input.LA(1)=='n' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ if ( input.LA(1)=='D'||input.LA(1)=='d' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:404:48: ( AMPER ( AMPER )? )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:404:48: ( AMPER ( AMPER )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:404:49: AMPER ( AMPER )?
+ {
+ mAMPER();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:404:55: ( AMPER )?
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0=='&') ) {
+ alt10=1;
+ }
+ switch (alt10) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( input.LA(1)=='&' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "AND"
+
+ // $ANTLR start "OR"
+ public final void mOR() throws RecognitionException {
+ try {
+ int _type = OR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:405:5: ( ( ( 'o' | 'O' ) ( 'r' | 'R' ) | ( VBAR ( VBAR )? ) ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:405:7: ( ( 'o' | 'O' ) ( 'r' | 'R' ) | ( VBAR ( VBAR )? ) )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:405:7: ( ( 'o' | 'O' ) ( 'r' | 'R' ) | ( VBAR ( VBAR )? ) )
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( (LA13_0=='O'||LA13_0=='o') ) {
+ alt13=1;
+ }
+ else if ( (LA13_0=='|') ) {
+ alt13=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 13, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt13) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:405:8: ( 'o' | 'O' ) ( 'r' | 'R' )
+ {
+ if ( input.LA(1)=='O'||input.LA(1)=='o' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ if ( input.LA(1)=='R'||input.LA(1)=='r' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:405:34: ( VBAR ( VBAR )? )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:405:34: ( VBAR ( VBAR )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:405:35: VBAR ( VBAR )?
+ {
+ mVBAR();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:405:40: ( VBAR )?
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0=='|') ) {
+ alt12=1;
+ }
+ switch (alt12) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( input.LA(1)=='|' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "OR"
+
+ // $ANTLR start "NOT"
+ public final void mNOT() throws RecognitionException {
+ try {
+ int _type = NOT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:406:7: ( ( 'n' | 'N' ) ( 'o' | 'O' ) ( 't' | 'T' ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:406:9: ( 'n' | 'N' ) ( 'o' | 'O' ) ( 't' | 'T' )
+ {
+ if ( input.LA(1)=='N'||input.LA(1)=='n' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ if ( input.LA(1)=='O'||input.LA(1)=='o' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ if ( input.LA(1)=='T'||input.LA(1)=='t' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "NOT"
+
+ // $ANTLR start "NEAR"
+ public final void mNEAR() throws RecognitionException {
+ try {
+ int _type = NEAR;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:407:7: ( ( ( 'n' | 'N' ) ( 'e' | 'E' ) ( 'a' | 'A' ) ( 'r' | 'R' ) | 'n' ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:407:9: ( ( 'n' | 'N' ) ( 'e' | 'E' ) ( 'a' | 'A' ) ( 'r' | 'R' ) | 'n' )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:407:9: ( ( 'n' | 'N' ) ( 'e' | 'E' ) ( 'a' | 'A' ) ( 'r' | 'R' ) | 'n' )
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0=='n') ) {
+ int LA14_1 = input.LA(2);
+
+ if ( (LA14_1=='E'||LA14_1=='e') ) {
+ alt14=1;
+ }
+ else {
+ alt14=2;
+ }
+ }
+ else if ( (LA14_0=='N') ) {
+ alt14=1;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 14, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt14) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:407:10: ( 'n' | 'N' ) ( 'e' | 'E' ) ( 'a' | 'A' ) ( 'r' | 'R' )
+ {
+ if ( input.LA(1)=='N'||input.LA(1)=='n' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ if ( input.LA(1)=='A'||input.LA(1)=='a' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ if ( input.LA(1)=='R'||input.LA(1)=='r' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:407:60: 'n'
+ {
+ match('n');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "NEAR"
+
+ // $ANTLR start "WS"
+ public final void mWS() throws RecognitionException {
+ try {
+ int _type = WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:410:5: ( ( ' ' | '\\t' | '\\r' | '\\n' | '\\u3000' ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:410:9: ( ' ' | '\\t' | '\\r' | '\\n' | '\\u3000' )
+ {
+ if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n')||input.LA(1)=='\r'||input.LA(1)==' '||input.LA(1)=='\u3000' ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ _channel=HIDDEN;
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "WS"
+
+ // $ANTLR start "INT"
+ public final void mINT() throws RecognitionException {
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:431:13: ( '0' .. '9' )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+
+
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "INT"
+
+ // $ANTLR start "ESC_CHAR"
+ public final void mESC_CHAR() throws RecognitionException {
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:434:18: ( '\\\\' . )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:434:21: '\\\\' .
+ {
+ match('\\');
+
+ matchAny();
+
+ }
+
+
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "ESC_CHAR"
+
+ // $ANTLR start "TERM_START_CHAR"
+ public final void mTERM_START_CHAR() throws RecognitionException {
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:438:2: ( (~ ( ' ' | '\\t' | '\\n' | '\\r' | '\\u3000' | '\\'' | '\\\"' | '(' | ')' | '[' | ']' | '{' | '}' | '+' | '-' | '!' | ':' | '~' | '^' | '?' | '*' | '\\\\' ) | ESC_CHAR ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:439:2: (~ ( ' ' | '\\t' | '\\n' | '\\r' | '\\u3000' | '\\'' | '\\\"' | '(' | ')' | '[' | ']' | '{' | '}' | '+' | '-' | '!' | ':' | '~' | '^' | '?' | '*' | '\\\\' ) | ESC_CHAR )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:439:2: (~ ( ' ' | '\\t' | '\\n' | '\\r' | '\\u3000' | '\\'' | '\\\"' | '(' | ')' | '[' | ']' | '{' | '}' | '+' | '-' | '!' | ':' | '~' | '^' | '?' | '*' | '\\\\' ) | ESC_CHAR )
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( ((LA15_0 >= '\u0000' && LA15_0 <= '\b')||(LA15_0 >= '\u000B' && LA15_0 <= '\f')||(LA15_0 >= '\u000E' && LA15_0 <= '\u001F')||(LA15_0 >= '#' && LA15_0 <= '&')||LA15_0==','||(LA15_0 >= '.' && LA15_0 <= '9')||(LA15_0 >= ';' && LA15_0 <= '>')||(LA15_0 >= '@' && LA15_0 <= 'Z')||(LA15_0 >= '_' && LA15_0 <= 'z')||LA15_0=='|'||(LA15_0 >= '\u007F' && LA15_0 <= '\u2FFF')||(LA15_0 >= '\u3001' && LA15_0 <= '\uFFFF')) ) {
+ alt15=1;
+ }
+ else if ( (LA15_0=='\\') ) {
+ alt15=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 15, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt15) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:439:3: ~ ( ' ' | '\\t' | '\\n' | '\\r' | '\\u3000' | '\\'' | '\\\"' | '(' | ')' | '[' | ']' | '{' | '}' | '+' | '-' | '!' | ':' | '~' | '^' | '?' | '*' | '\\\\' )
+ {
+ if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\b')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '\u001F')||(input.LA(1) >= '#' && input.LA(1) <= '&')||input.LA(1)==','||(input.LA(1) >= '.' && input.LA(1) <= '9')||(input.LA(1) >= ';' && input.LA(1) <= '>')||(input.LA(1) >= '@' && input.LA(1) <= 'Z')||(input.LA(1) >= '_' && input.LA(1) <= 'z')||input.LA(1)=='|'||(input.LA(1) >= '\u007F' && input.LA(1) <= '\u2FFF')||(input.LA(1) >= '\u3001' && input.LA(1) <= '\uFFFF') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:445:5: ESC_CHAR
+ {
+ mESC_CHAR();
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "TERM_START_CHAR"
+
+ // $ANTLR start "TERM_CHAR"
+ public final void mTERM_CHAR() throws RecognitionException {
+ try {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:449:2: ( ( TERM_START_CHAR | '-' | '+' ) )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:450:2: ( TERM_START_CHAR | '-' | '+' )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:450:2: ( TERM_START_CHAR | '-' | '+' )
+ int alt16=3;
+ int LA16_0 = input.LA(1);
+
+ if ( ((LA16_0 >= '\u0000' && LA16_0 <= '\b')||(LA16_0 >= '\u000B' && LA16_0 <= '\f')||(LA16_0 >= '\u000E' && LA16_0 <= '\u001F')||(LA16_0 >= '#' && LA16_0 <= '&')||LA16_0==','||(LA16_0 >= '.' && LA16_0 <= '9')||(LA16_0 >= ';' && LA16_0 <= '>')||(LA16_0 >= '@' && LA16_0 <= 'Z')||LA16_0=='\\'||(LA16_0 >= '_' && LA16_0 <= 'z')||LA16_0=='|'||(LA16_0 >= '\u007F' && LA16_0 <= '\u2FFF')||(LA16_0 >= '\u3001' && LA16_0 <= '\uFFFF')) ) {
+ alt16=1;
+ }
+ else if ( (LA16_0=='-') ) {
+ alt16=2;
+ }
+ else if ( (LA16_0=='+') ) {
+ alt16=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 16, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt16) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:450:3: TERM_START_CHAR
+ {
+ mTERM_START_CHAR();
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:450:21: '-'
+ {
+ match('-');
+
+ }
+ break;
+ case 3 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:450:27: '+'
+ {
+ match('+');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "TERM_CHAR"
+
+ // $ANTLR start "NUMBER"
+ public final void mNUMBER() throws RecognitionException {
+ try {
+ int _type = NUMBER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:455:2: ( ( INT )+ ( '.' ( INT )+ )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:456:2: ( INT )+ ( '.' ( INT )+ )?
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:456:2: ( INT )+
+ int cnt17=0;
+ loop17:
+ do {
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( ((LA17_0 >= '0' && LA17_0 <= '9')) ) {
+ alt17=1;
+ }
+
+
+ switch (alt17) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt17 >= 1 ) break loop17;
+ EarlyExitException eee =
+ new EarlyExitException(17, input);
+ throw eee;
+ }
+ cnt17++;
+ } while (true);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:456:7: ( '.' ( INT )+ )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0=='.') ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:456:8: '.' ( INT )+
+ {
+ match('.');
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:456:12: ( INT )+
+ int cnt18=0;
+ loop18:
+ do {
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( ((LA18_0 >= '0' && LA18_0 <= '9')) ) {
+ alt18=1;
+ }
+
+
+ switch (alt18) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt18 >= 1 ) break loop18;
+ EarlyExitException eee =
+ new EarlyExitException(18, input);
+ throw eee;
+ }
+ cnt18++;
+ } while (true);
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "NUMBER"
+
+ // $ANTLR start "DATE_TOKEN"
+ public final void mDATE_TOKEN() throws RecognitionException {
+ try {
+ int _type = DATE_TOKEN;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:460:2: ( INT ( INT )? ( '/' | '-' | '.' ) INT ( INT )? ( '/' | '-' | '.' ) INT INT ( INT INT )? )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:461:2: INT ( INT )? ( '/' | '-' | '.' ) INT ( INT )? ( '/' | '-' | '.' ) INT INT ( INT INT )?
+ {
+ mINT();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:461:6: ( INT )?
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( ((LA20_0 >= '0' && LA20_0 <= '9')) ) {
+ alt20=1;
+ }
+ switch (alt20) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ if ( (input.LA(1) >= '-' && input.LA(1) <= '/') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ mINT();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:461:29: ( INT )?
+ int alt21=2;
+ int LA21_0 = input.LA(1);
+
+ if ( ((LA21_0 >= '0' && LA21_0 <= '9')) ) {
+ alt21=1;
+ }
+ switch (alt21) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:
+ {
+ if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ if ( (input.LA(1) >= '-' && input.LA(1) <= '/') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ mINT();
+
+
+ mINT();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:461:56: ( INT INT )?
+ int alt22=2;
+ int LA22_0 = input.LA(1);
+
+ if ( ((LA22_0 >= '0' && LA22_0 <= '9')) ) {
+ alt22=1;
+ }
+ switch (alt22) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:461:57: INT INT
+ {
+ mINT();
+
+
+ mINT();
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "DATE_TOKEN"
+
+ // $ANTLR start "TERM_NORMAL"
+ public final void mTERM_NORMAL() throws RecognitionException {
+ try {
+ int _type = TERM_NORMAL;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:465:2: ( TERM_START_CHAR ( TERM_CHAR )* )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:466:2: TERM_START_CHAR ( TERM_CHAR )*
+ {
+ mTERM_START_CHAR();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:466:18: ( TERM_CHAR )*
+ loop23:
+ do {
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( ((LA23_0 >= '\u0000' && LA23_0 <= '\b')||(LA23_0 >= '\u000B' && LA23_0 <= '\f')||(LA23_0 >= '\u000E' && LA23_0 <= '\u001F')||(LA23_0 >= '#' && LA23_0 <= '&')||(LA23_0 >= '+' && LA23_0 <= '9')||(LA23_0 >= ';' && LA23_0 <= '>')||(LA23_0 >= '@' && LA23_0 <= 'Z')||LA23_0=='\\'||(LA23_0 >= '_' && LA23_0 <= 'z')||LA23_0=='|'||(LA23_0 >= '\u007F' && LA23_0 <= '\u2FFF')||(LA23_0 >= '\u3001' && LA23_0 <= '\uFFFF')) ) {
+ alt23=1;
+ }
+
+
+ switch (alt23) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:466:20: TERM_CHAR
+ {
+ mTERM_CHAR();
+
+
+ }
+ break;
+
+ default :
+ break loop23;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "TERM_NORMAL"
+
+ // $ANTLR start "TERM_TRUNCATED"
+ public final void mTERM_TRUNCATED() throws RecognitionException {
+ try {
+ int _type = TERM_TRUNCATED;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:470:15: ( ( STAR | QMARK ) ( ( TERM_CHAR )+ ( QMARK | STAR ) )+ ( TERM_CHAR )* | TERM_START_CHAR ( ( TERM_CHAR )* ( QMARK | STAR ) )+ ( TERM_CHAR )* | ( STAR | QMARK ) ( TERM_CHAR )+ )
+ int alt35=3;
+ alt35 = dfa35.predict(input);
+ switch (alt35) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:2: ( STAR | QMARK ) ( ( TERM_CHAR )+ ( QMARK | STAR ) )+ ( TERM_CHAR )*
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:2: ( STAR | QMARK )
+ int alt24=2;
+ int LA24_0 = input.LA(1);
+
+ if ( (LA24_0=='*') ) {
+ alt24=1;
+ }
+ else if ( (LA24_0=='?') ) {
+ alt24=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 24, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt24) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:3: STAR
+ {
+ mSTAR();
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:8: QMARK
+ {
+ mQMARK();
+
+
+ }
+ break;
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:15: ( ( TERM_CHAR )+ ( QMARK | STAR ) )+
+ int cnt27=0;
+ loop27:
+ do {
+ int alt27=2;
+ alt27 = dfa27.predict(input);
+ switch (alt27) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:16: ( TERM_CHAR )+ ( QMARK | STAR )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:16: ( TERM_CHAR )+
+ int cnt25=0;
+ loop25:
+ do {
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( ((LA25_0 >= '\u0000' && LA25_0 <= '\b')||(LA25_0 >= '\u000B' && LA25_0 <= '\f')||(LA25_0 >= '\u000E' && LA25_0 <= '\u001F')||(LA25_0 >= '#' && LA25_0 <= '&')||(LA25_0 >= '+' && LA25_0 <= '9')||(LA25_0 >= ';' && LA25_0 <= '>')||(LA25_0 >= '@' && LA25_0 <= 'Z')||LA25_0=='\\'||(LA25_0 >= '_' && LA25_0 <= 'z')||LA25_0=='|'||(LA25_0 >= '\u007F' && LA25_0 <= '\u2FFF')||(LA25_0 >= '\u3001' && LA25_0 <= '\uFFFF')) ) {
+ alt25=1;
+ }
+
+
+ switch (alt25) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:16: TERM_CHAR
+ {
+ mTERM_CHAR();
+
+
+ }
+ break;
+
+ default :
+ if ( cnt25 >= 1 ) break loop25;
+ EarlyExitException eee =
+ new EarlyExitException(25, input);
+ throw eee;
+ }
+ cnt25++;
+ } while (true);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:27: ( QMARK | STAR )
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0=='?') ) {
+ alt26=1;
+ }
+ else if ( (LA26_0=='*') ) {
+ alt26=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 26, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt26) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:28: QMARK
+ {
+ mQMARK();
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:34: STAR
+ {
+ mSTAR();
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt27 >= 1 ) break loop27;
+ EarlyExitException eee =
+ new EarlyExitException(27, input);
+ throw eee;
+ }
+ cnt27++;
+ } while (true);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:42: ( TERM_CHAR )*
+ loop28:
+ do {
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( ((LA28_0 >= '\u0000' && LA28_0 <= '\b')||(LA28_0 >= '\u000B' && LA28_0 <= '\f')||(LA28_0 >= '\u000E' && LA28_0 <= '\u001F')||(LA28_0 >= '#' && LA28_0 <= '&')||(LA28_0 >= '+' && LA28_0 <= '9')||(LA28_0 >= ';' && LA28_0 <= '>')||(LA28_0 >= '@' && LA28_0 <= 'Z')||LA28_0=='\\'||(LA28_0 >= '_' && LA28_0 <= 'z')||LA28_0=='|'||(LA28_0 >= '\u007F' && LA28_0 <= '\u2FFF')||(LA28_0 >= '\u3001' && LA28_0 <= '\uFFFF')) ) {
+ alt28=1;
+ }
+
+
+ switch (alt28) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:471:43: TERM_CHAR
+ {
+ mTERM_CHAR();
+
+
+ }
+ break;
+
+ default :
+ break loop28;
+ }
+ } while (true);
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:4: TERM_START_CHAR ( ( TERM_CHAR )* ( QMARK | STAR ) )+ ( TERM_CHAR )*
+ {
+ mTERM_START_CHAR();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:20: ( ( TERM_CHAR )* ( QMARK | STAR ) )+
+ int cnt31=0;
+ loop31:
+ do {
+ int alt31=2;
+ alt31 = dfa31.predict(input);
+ switch (alt31) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:21: ( TERM_CHAR )* ( QMARK | STAR )
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:21: ( TERM_CHAR )*
+ loop29:
+ do {
+ int alt29=2;
+ int LA29_0 = input.LA(1);
+
+ if ( ((LA29_0 >= '\u0000' && LA29_0 <= '\b')||(LA29_0 >= '\u000B' && LA29_0 <= '\f')||(LA29_0 >= '\u000E' && LA29_0 <= '\u001F')||(LA29_0 >= '#' && LA29_0 <= '&')||(LA29_0 >= '+' && LA29_0 <= '9')||(LA29_0 >= ';' && LA29_0 <= '>')||(LA29_0 >= '@' && LA29_0 <= 'Z')||LA29_0=='\\'||(LA29_0 >= '_' && LA29_0 <= 'z')||LA29_0=='|'||(LA29_0 >= '\u007F' && LA29_0 <= '\u2FFF')||(LA29_0 >= '\u3001' && LA29_0 <= '\uFFFF')) ) {
+ alt29=1;
+ }
+
+
+ switch (alt29) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:21: TERM_CHAR
+ {
+ mTERM_CHAR();
+
+
+ }
+ break;
+
+ default :
+ break loop29;
+ }
+ } while (true);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:32: ( QMARK | STAR )
+ int alt30=2;
+ int LA30_0 = input.LA(1);
+
+ if ( (LA30_0=='?') ) {
+ alt30=1;
+ }
+ else if ( (LA30_0=='*') ) {
+ alt30=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 30, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt30) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:33: QMARK
+ {
+ mQMARK();
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:39: STAR
+ {
+ mSTAR();
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt31 >= 1 ) break loop31;
+ EarlyExitException eee =
+ new EarlyExitException(31, input);
+ throw eee;
+ }
+ cnt31++;
+ } while (true);
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:47: ( TERM_CHAR )*
+ loop32:
+ do {
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( ((LA32_0 >= '\u0000' && LA32_0 <= '\b')||(LA32_0 >= '\u000B' && LA32_0 <= '\f')||(LA32_0 >= '\u000E' && LA32_0 <= '\u001F')||(LA32_0 >= '#' && LA32_0 <= '&')||(LA32_0 >= '+' && LA32_0 <= '9')||(LA32_0 >= ';' && LA32_0 <= '>')||(LA32_0 >= '@' && LA32_0 <= 'Z')||LA32_0=='\\'||(LA32_0 >= '_' && LA32_0 <= 'z')||LA32_0=='|'||(LA32_0 >= '\u007F' && LA32_0 <= '\u2FFF')||(LA32_0 >= '\u3001' && LA32_0 <= '\uFFFF')) ) {
+ alt32=1;
+ }
+
+
+ switch (alt32) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:472:48: TERM_CHAR
+ {
+ mTERM_CHAR();
+
+
+ }
+ break;
+
+ default :
+ break loop32;
+ }
+ } while (true);
+
+
+ }
+ break;
+ case 3 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:473:4: ( STAR | QMARK ) ( TERM_CHAR )+
+ {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:473:4: ( STAR | QMARK )
+ int alt33=2;
+ int LA33_0 = input.LA(1);
+
+ if ( (LA33_0=='*') ) {
+ alt33=1;
+ }
+ else if ( (LA33_0=='?') ) {
+ alt33=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 33, 0, input);
+
+ throw nvae;
+
+ }
+ switch (alt33) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:473:5: STAR
+ {
+ mSTAR();
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:473:10: QMARK
+ {
+ mQMARK();
+
+
+ }
+ break;
+
+ }
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:473:17: ( TERM_CHAR )+
+ int cnt34=0;
+ loop34:
+ do {
+ int alt34=2;
+ int LA34_0 = input.LA(1);
+
+ if ( ((LA34_0 >= '\u0000' && LA34_0 <= '\b')||(LA34_0 >= '\u000B' && LA34_0 <= '\f')||(LA34_0 >= '\u000E' && LA34_0 <= '\u001F')||(LA34_0 >= '#' && LA34_0 <= '&')||(LA34_0 >= '+' && LA34_0 <= '9')||(LA34_0 >= ';' && LA34_0 <= '>')||(LA34_0 >= '@' && LA34_0 <= 'Z')||LA34_0=='\\'||(LA34_0 >= '_' && LA34_0 <= 'z')||LA34_0=='|'||(LA34_0 >= '\u007F' && LA34_0 <= '\u2FFF')||(LA34_0 >= '\u3001' && LA34_0 <= '\uFFFF')) ) {
+ alt34=1;
+ }
+
+
+ switch (alt34) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:473:17: TERM_CHAR
+ {
+ mTERM_CHAR();
+
+
+ }
+ break;
+
+ default :
+ if ( cnt34 >= 1 ) break loop34;
+ EarlyExitException eee =
+ new EarlyExitException(34, input);
+ throw eee;
+ }
+ cnt34++;
+ } while (true);
+
+
+ }
+ break;
+
+ }
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "TERM_TRUNCATED"
+
+ // $ANTLR start "PHRASE"
+ public final void mPHRASE() throws RecognitionException {
+ try {
+ int _type = PHRASE;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:478:2: ( DQUOTE ( ESC_CHAR |~ ( '\\\"' | '\\\\' | '?' | '*' ) )+ DQUOTE )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:479:2: DQUOTE ( ESC_CHAR |~ ( '\\\"' | '\\\\' | '?' | '*' ) )+ DQUOTE
+ {
+ mDQUOTE();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:479:9: ( ESC_CHAR |~ ( '\\\"' | '\\\\' | '?' | '*' ) )+
+ int cnt36=0;
+ loop36:
+ do {
+ int alt36=3;
+ int LA36_0 = input.LA(1);
+
+ if ( (LA36_0=='\\') ) {
+ alt36=1;
+ }
+ else if ( ((LA36_0 >= '\u0000' && LA36_0 <= '!')||(LA36_0 >= '#' && LA36_0 <= ')')||(LA36_0 >= '+' && LA36_0 <= '>')||(LA36_0 >= '@' && LA36_0 <= '[')||(LA36_0 >= ']' && LA36_0 <= '\uFFFF')) ) {
+ alt36=2;
+ }
+
+
+ switch (alt36) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:479:10: ESC_CHAR
+ {
+ mESC_CHAR();
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:479:19: ~ ( '\\\"' | '\\\\' | '?' | '*' )
+ {
+ if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= ')')||(input.LA(1) >= '+' && input.LA(1) <= '>')||(input.LA(1) >= '@' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt36 >= 1 ) break loop36;
+ EarlyExitException eee =
+ new EarlyExitException(36, input);
+ throw eee;
+ }
+ cnt36++;
+ } while (true);
+
+
+ mDQUOTE();
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "PHRASE"
+
+ // $ANTLR start "PHRASE_ANYTHING"
+ public final void mPHRASE_ANYTHING() throws RecognitionException {
+ try {
+ int _type = PHRASE_ANYTHING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:482:17: ( DQUOTE ( ESC_CHAR |~ ( '\\\"' | '\\\\' ) )+ DQUOTE )
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:483:2: DQUOTE ( ESC_CHAR |~ ( '\\\"' | '\\\\' ) )+ DQUOTE
+ {
+ mDQUOTE();
+
+
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:483:9: ( ESC_CHAR |~ ( '\\\"' | '\\\\' ) )+
+ int cnt37=0;
+ loop37:
+ do {
+ int alt37=3;
+ int LA37_0 = input.LA(1);
+
+ if ( (LA37_0=='\\') ) {
+ alt37=1;
+ }
+ else if ( ((LA37_0 >= '\u0000' && LA37_0 <= '!')||(LA37_0 >= '#' && LA37_0 <= '[')||(LA37_0 >= ']' && LA37_0 <= '\uFFFF')) ) {
+ alt37=2;
+ }
+
+
+ switch (alt37) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:483:10: ESC_CHAR
+ {
+ mESC_CHAR();
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:483:19: ~ ( '\\\"' | '\\\\' )
+ {
+ if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
+ input.consume();
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt37 >= 1 ) break loop37;
+ EarlyExitException eee =
+ new EarlyExitException(37, input);
+ throw eee;
+ }
+ cnt37++;
+ } while (true);
+
+
+ mDQUOTE();
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ // do for sure before leaving
+ }
+ }
+ // $ANTLR end "PHRASE_ANYTHING"
+
+ public void mTokens() throws RecognitionException {
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:8: ( T__53 | LPAREN | RPAREN | LBRACK | RBRACK | COLON | PLUS | MINUS | STAR | QMARK | LCURLY | RCURLY | CARAT | TILDE | DQUOTE | SQUOTE | TO | AND | OR | NOT | NEAR | WS | NUMBER | DATE_TOKEN | TERM_NORMAL | TERM_TRUNCATED | PHRASE | PHRASE_ANYTHING )
+ int alt38=28;
+ alt38 = dfa38.predict(input);
+ switch (alt38) {
+ case 1 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:10: T__53
+ {
+ mT__53();
+
+
+ }
+ break;
+ case 2 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:16: LPAREN
+ {
+ mLPAREN();
+
+
+ }
+ break;
+ case 3 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:23: RPAREN
+ {
+ mRPAREN();
+
+
+ }
+ break;
+ case 4 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:30: LBRACK
+ {
+ mLBRACK();
+
+
+ }
+ break;
+ case 5 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:37: RBRACK
+ {
+ mRBRACK();
+
+
+ }
+ break;
+ case 6 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:44: COLON
+ {
+ mCOLON();
+
+
+ }
+ break;
+ case 7 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:50: PLUS
+ {
+ mPLUS();
+
+
+ }
+ break;
+ case 8 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:55: MINUS
+ {
+ mMINUS();
+
+
+ }
+ break;
+ case 9 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:61: STAR
+ {
+ mSTAR();
+
+
+ }
+ break;
+ case 10 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:66: QMARK
+ {
+ mQMARK();
+
+
+ }
+ break;
+ case 11 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:72: LCURLY
+ {
+ mLCURLY();
+
+
+ }
+ break;
+ case 12 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:79: RCURLY
+ {
+ mRCURLY();
+
+
+ }
+ break;
+ case 13 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:86: CARAT
+ {
+ mCARAT();
+
+
+ }
+ break;
+ case 14 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:92: TILDE
+ {
+ mTILDE();
+
+
+ }
+ break;
+ case 15 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:98: DQUOTE
+ {
+ mDQUOTE();
+
+
+ }
+ break;
+ case 16 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:105: SQUOTE
+ {
+ mSQUOTE();
+
+
+ }
+ break;
+ case 17 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:112: TO
+ {
+ mTO();
+
+
+ }
+ break;
+ case 18 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:115: AND
+ {
+ mAND();
+
+
+ }
+ break;
+ case 19 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:119: OR
+ {
+ mOR();
+
+
+ }
+ break;
+ case 20 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:122: NOT
+ {
+ mNOT();
+
+
+ }
+ break;
+ case 21 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:126: NEAR
+ {
+ mNEAR();
+
+
+ }
+ break;
+ case 22 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:131: WS
+ {
+ mWS();
+
+
+ }
+ break;
+ case 23 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:134: NUMBER
+ {
+ mNUMBER();
+
+
+ }
+ break;
+ case 24 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:141: DATE_TOKEN
+ {
+ mDATE_TOKEN();
+
+
+ }
+ break;
+ case 25 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:152: TERM_NORMAL
+ {
+ mTERM_NORMAL();
+
+
+ }
+ break;
+ case 26 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:164: TERM_TRUNCATED
+ {
+ mTERM_TRUNCATED();
+
+
+ }
+ break;
+ case 27 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:179: PHRASE
+ {
+ mPHRASE();
+
+
+ }
+ break;
+ case 28 :
+ // /dvt/workspace/lucene_4x/lucene/queryparser/grammars/StandardLuceneGrammar.g:1:186: PHRASE_ANYTHING
+ {
+ mPHRASE_ANYTHING();
+
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA35 dfa35 = new DFA35(this);
+ protected DFA27 dfa27 = new DFA27(this);
+ protected DFA31 dfa31 = new DFA31(this);
+ protected DFA38 dfa38 = new DFA38(this);
+ static final String DFA35_eotS =
+ "\4\uffff\1\10\1\uffff\2\10\2\uffff\1\10";
+ static final String DFA35_eofS =
+ "\13\uffff";
+ static final String DFA35_minS =
+ "\3\0\1\uffff\4\0\2\uffff\1\0";
+ static final String DFA35_maxS =
+ "\3\uffff\1\uffff\4\uffff\2\uffff\1\uffff";
+ static final String DFA35_acceptS =
+ "\3\uffff\1\2\4\uffff\1\3\1\1\1\uffff";
+ static final String DFA35_specialS =
+ "\1\7\1\5\1\1\1\uffff\1\0\1\4\1\3\1\6\2\uffff\1\2}>";
+ static final String[] DFA35_transitionS = {
+ "\11\3\2\uffff\2\3\1\uffff\22\3\3\uffff\4\3\3\uffff\1\1\1\uffff"+
+ "\1\3\1\uffff\14\3\1\uffff\4\3\1\2\33\3\1\uffff\1\3\2\uffff\34"+
+ "\3\1\uffff\1\3\2\uffff\u2f81\3\1\uffff\ucfff\3",
+ "\11\4\2\uffff\2\4\1\uffff\22\4\3\uffff\4\4\4\uffff\1\7\1\4"+
+ "\1\6\14\4\1\uffff\4\4\1\uffff\33\4\1\uffff\1\5\2\uffff\34\4"+
+ "\1\uffff\1\4\2\uffff\u2f81\4\1\uffff\ucfff\4",
+ "\11\4\2\uffff\2\4\1\uffff\22\4\3\uffff\4\4\4\uffff\1\7\1\4"+
+ "\1\6\14\4\1\uffff\4\4\1\2\33\4\1\uffff\1\5\2\uffff\34\4\1\uffff"+
+ "\1\4\2\uffff\u2f81\4\1\uffff\ucfff\4",
+ "",
+ "\11\4\2\uffff\2\4\1\uffff\22\4\3\uffff\4\4\3\uffff\1\11\1\7"+
+ "\1\4\1\6\14\4\1\uffff\4\4\1\11\33\4\1\uffff\1\5\2\uffff\34\4"+
+ "\1\uffff\1\4\2\uffff\u2f81\4\1\uffff\ucfff\4",
+ "\0\12",
+ "\11\4\2\uffff\2\4\1\uffff\22\4\3\uffff\4\4\3\uffff\1\11\1\7"+
+ "\1\4\1\6\14\4\1\uffff\4\4\1\11\33\4\1\uffff\1\5\2\uffff\34\4"+
+ "\1\uffff\1\4\2\uffff\u2f81\4\1\uffff\ucfff\4",
+ "\11\4\2\uffff\2\4\1\uffff\22\4\3\uffff\4\4\3\uffff\1\11\1\7"+
+ "\1\4\1\6\14\4\1\uffff\4\4\1\11\33\4\1\uffff\1\5\2\uffff\34\4"+
+ "\1\uffff\1\4\2\uffff\u2f81\4\1\uffff\ucfff\4",
+ "",
+ "",
+ "\11\4\2\uffff\2\4\1\uffff\22\4\3\uffff\4\4\3\uffff\1\11\1\7"+
+ "\1\4\1\6\14\4\1\uffff\4\4\1\11\33\4\1\uffff\1\5\2\uffff\34\4"+
+ "\1\uffff\1\4\2\uffff\u2f81\4\1\uffff\ucfff\4"
+ };
+
+ static final short[] DFA35_eot = DFA.unpackEncodedString(DFA35_eotS);
+ static final short[] DFA35_eof = DFA.unpackEncodedString(DFA35_eofS);
+ static final char[] DFA35_min = DFA.unpackEncodedStringToUnsignedChars(DFA35_minS);
+ static final char[] DFA35_max = DFA.unpackEncodedStringToUnsignedChars(DFA35_maxS);
+ static final short[] DFA35_accept = DFA.unpackEncodedString(DFA35_acceptS);
+ static final short[] DFA35_special = DFA.unpackEncodedString(DFA35_specialS);
+ static final short[][] DFA35_transition;
+
+ static {
+ int numStates = DFA35_transitionS.length;
+ DFA35_transition = new short[numStates][];
+ for (int i=0; i= '\u0000' && LA35_4 <= '\b')||(LA35_4 >= '\u000B' && LA35_4 <= '\f')||(LA35_4 >= '\u000E' && LA35_4 <= '\u001F')||(LA35_4 >= '#' && LA35_4 <= '&')||LA35_4==','||(LA35_4 >= '.' && LA35_4 <= '9')||(LA35_4 >= ';' && LA35_4 <= '>')||(LA35_4 >= '@' && LA35_4 <= 'Z')||(LA35_4 >= '_' && LA35_4 <= 'z')||LA35_4=='|'||(LA35_4 >= '\u007F' && LA35_4 <= '\u2FFF')||(LA35_4 >= '\u3001' && LA35_4 <= '\uFFFF')) ) {s = 4;}
+
+ else if ( (LA35_4=='\\') ) {s = 5;}
+
+ else if ( (LA35_4=='-') ) {s = 6;}
+
+ else if ( (LA35_4=='+') ) {s = 7;}
+
+ else s = 8;
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA35_2 = input.LA(1);
+
+ s = -1;
+ if ( ((LA35_2 >= '\u0000' && LA35_2 <= '\b')||(LA35_2 >= '\u000B' && LA35_2 <= '\f')||(LA35_2 >= '\u000E' && LA35_2 <= '\u001F')||(LA35_2 >= '#' && LA35_2 <= '&')||LA35_2==','||(LA35_2 >= '.' && LA35_2 <= '9')||(LA35_2 >= ';' && LA35_2 <= '>')||(LA35_2 >= '@' && LA35_2 <= 'Z')||(LA35_2 >= '_' && LA35_2 <= 'z')||LA35_2=='|'||(LA35_2 >= '\u007F' && LA35_2 <= '\u2FFF')||(LA35_2 >= '\u3001' && LA35_2 <= '\uFFFF')) ) {s = 4;}
+
+ else if ( (LA35_2=='\\') ) {s = 5;}
+
+ else if ( (LA35_2=='-') ) {s = 6;}
+
+ else if ( (LA35_2=='+') ) {s = 7;}
+
+ else if ( (LA35_2=='?') ) {s = 2;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA35_10 = input.LA(1);
+
+ s = -1;
+ if ( (LA35_10=='*'||LA35_10=='?') ) {s = 9;}
+
+ else if ( ((LA35_10 >= '\u0000' && LA35_10 <= '\b')||(LA35_10 >= '\u000B' && LA35_10 <= '\f')||(LA35_10 >= '\u000E' && LA35_10 <= '\u001F')||(LA35_10 >= '#' && LA35_10 <= '&')||LA35_10==','||(LA35_10 >= '.' && LA35_10 <= '9')||(LA35_10 >= ';' && LA35_10 <= '>')||(LA35_10 >= '@' && LA35_10 <= 'Z')||(LA35_10 >= '_' && LA35_10 <= 'z')||LA35_10=='|'||(LA35_10 >= '\u007F' && LA35_10 <= '\u2FFF')||(LA35_10 >= '\u3001' && LA35_10 <= '\uFFFF')) ) {s = 4;}
+
+ else if ( (LA35_10=='\\') ) {s = 5;}
+
+ else if ( (LA35_10=='-') ) {s = 6;}
+
+ else if ( (LA35_10=='+') ) {s = 7;}
+
+ else s = 8;
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA35_6 = input.LA(1);
+
+ s = -1;
+ if ( (LA35_6=='*'||LA35_6=='?') ) {s = 9;}
+
+ else if ( ((LA35_6 >= '\u0000' && LA35_6 <= '\b')||(LA35_6 >= '\u000B' && LA35_6 <= '\f')||(LA35_6 >= '\u000E' && LA35_6 <= '\u001F')||(LA35_6 >= '#' && LA35_6 <= '&')||LA35_6==','||(LA35_6 >= '.' && LA35_6 <= '9')||(LA35_6 >= ';' && LA35_6 <= '>')||(LA35_6 >= '@' && LA35_6 <= 'Z')||(LA35_6 >= '_' && LA35_6 <= 'z')||LA35_6=='|'||(LA35_6 >= '\u007F' && LA35_6 <= '\u2FFF')||(LA35_6 >= '\u3001' && LA35_6 <= '\uFFFF')) ) {s = 4;}
+
+ else if ( (LA35_6=='\\') ) {s = 5;}
+
+ else if ( (LA35_6=='-') ) {s = 6;}
+
+ else if ( (LA35_6=='+') ) {s = 7;}
+
+ else s = 8;
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA35_5 = input.LA(1);
+
+ s = -1;
+ if ( ((LA35_5 >= '\u0000' && LA35_5 <= '\uFFFF')) ) {s = 10;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA35_1 = input.LA(1);
+
+ s = -1;
+ if ( ((LA35_1 >= '\u0000' && LA35_1 <= '\b')||(LA35_1 >= '\u000B' && LA35_1 <= '\f')||(LA35_1 >= '\u000E' && LA35_1 <= '\u001F')||(LA35_1 >= '#' && LA35_1 <= '&')||LA35_1==','||(LA35_1 >= '.' && LA35_1 <= '9')||(LA35_1 >= ';' && LA35_1 <= '>')||(LA35_1 >= '@' && LA35_1 <= 'Z')||(LA35_1 >= '_' && LA35_1 <= 'z')||LA35_1=='|'||(LA35_1 >= '\u007F' && LA35_1 <= '\u2FFF')||(LA35_1 >= '\u3001' && LA35_1 <= '\uFFFF')) ) {s = 4;}
+
+ else if ( (LA35_1=='\\') ) {s = 5;}
+
+ else if ( (LA35_1=='-') ) {s = 6;}
+
+ else if ( (LA35_1=='+') ) {s = 7;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA35_7 = input.LA(1);
+
+ s = -1;
+ if ( (LA35_7=='*'||LA35_7=='?') ) {s = 9;}
+
+ else if ( ((LA35_7 >= '\u0000' && LA35_7 <= '\b')||(LA35_7 >= '\u000B' && LA35_7 <= '\f')||(LA35_7 >= '\u000E' && LA35_7 <= '\u001F')||(LA35_7 >= '#' && LA35_7 <= '&')||LA35_7==','||(LA35_7 >= '.' && LA35_7 <= '9')||(LA35_7 >= ';' && LA35_7 <= '>')||(LA35_7 >= '@' && LA35_7 <= 'Z')||(LA35_7 >= '_' && LA35_7 <= 'z')||LA35_7=='|'||(LA35_7 >= '\u007F' && LA35_7 <= '\u2FFF')||(LA35_7 >= '\u3001' && LA35_7 <= '\uFFFF')) ) {s = 4;}
+
+ else if ( (LA35_7=='\\') ) {s = 5;}
+
+ else if ( (LA35_7=='-') ) {s = 6;}
+
+ else if ( (LA35_7=='+') ) {s = 7;}
+
+ else s = 8;
+
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA35_0 = input.LA(1);
+
+ s = -1;
+ if ( (LA35_0=='*') ) {s = 1;}
+
+ else if ( (LA35_0=='?') ) {s = 2;}
+
+ else if ( ((LA35_0 >= '\u0000' && LA35_0 <= '\b')||(LA35_0 >= '\u000B' && LA35_0 <= '\f')||(LA35_0 >= '\u000E' && LA35_0 <= '\u001F')||(LA35_0 >= '#' && LA35_0 <= '&')||LA35_0==','||(LA35_0 >= '.' && LA35_0 <= '9')||(LA35_0 >= ';' && LA35_0 <= '>')||(LA35_0 >= '@' && LA35_0 <= 'Z')||LA35_0=='\\'||(LA35_0 >= '_' && LA35_0 <= 'z')||LA35_0=='|'||(LA35_0 >= '\u007F' && LA35_0 <= '\u2FFF')||(LA35_0 >= '\u3001' && LA35_0 <= '\uFFFF')) ) {s = 3;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 35, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+
+ }
+ static final String DFA27_eotS =
+ "\2\5\1\uffff\2\5\2\uffff\1\5";
+ static final String DFA27_eofS =
+ "\10\uffff";
+ static final String DFA27_minS =
+ "\5\0\2\uffff\1\0";
+ static final String DFA27_maxS =
+ "\5\uffff\2\uffff\1\uffff";
+ static final String DFA27_acceptS =
+ "\5\uffff\1\2\1\1\1\uffff";
+ static final String DFA27_specialS =
+ "\1\3\1\5\1\4\1\0\1\2\2\uffff\1\1}>";
+ static final String[] DFA27_transitionS = {
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\4\uffff\1\4\1\1\1"+
+ "\3\14\1\1\uffff\4\1\1\uffff\33\1\1\uffff\1\2\2\uffff\34\1\1"+
+ "\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1",
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4"+
+ "\1\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1"+
+ "\1\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1",
+ "\0\7",
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4"+
+ "\1\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1"+
+ "\1\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1",
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4"+
+ "\1\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1"+
+ "\1\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1",
+ "",
+ "",
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4"+
+ "\1\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1"+
+ "\1\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1"
+ };
+
+ static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS);
+ static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS);
+ static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS);
+ static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS);
+ static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS);
+ static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS);
+ static final short[][] DFA27_transition;
+
+ static {
+ int numStates = DFA27_transitionS.length;
+ DFA27_transition = new short[numStates][];
+ for (int i=0; i= '\u0000' && LA27_3 <= '\b')||(LA27_3 >= '\u000B' && LA27_3 <= '\f')||(LA27_3 >= '\u000E' && LA27_3 <= '\u001F')||(LA27_3 >= '#' && LA27_3 <= '&')||LA27_3==','||(LA27_3 >= '.' && LA27_3 <= '9')||(LA27_3 >= ';' && LA27_3 <= '>')||(LA27_3 >= '@' && LA27_3 <= 'Z')||(LA27_3 >= '_' && LA27_3 <= 'z')||LA27_3=='|'||(LA27_3 >= '\u007F' && LA27_3 <= '\u2FFF')||(LA27_3 >= '\u3001' && LA27_3 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA27_3=='\\') ) {s = 2;}
+
+ else if ( (LA27_3=='-') ) {s = 3;}
+
+ else if ( (LA27_3=='+') ) {s = 4;}
+
+ else if ( (LA27_3=='*'||LA27_3=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA27_7 = input.LA(1);
+
+ s = -1;
+ if ( ((LA27_7 >= '\u0000' && LA27_7 <= '\b')||(LA27_7 >= '\u000B' && LA27_7 <= '\f')||(LA27_7 >= '\u000E' && LA27_7 <= '\u001F')||(LA27_7 >= '#' && LA27_7 <= '&')||LA27_7==','||(LA27_7 >= '.' && LA27_7 <= '9')||(LA27_7 >= ';' && LA27_7 <= '>')||(LA27_7 >= '@' && LA27_7 <= 'Z')||(LA27_7 >= '_' && LA27_7 <= 'z')||LA27_7=='|'||(LA27_7 >= '\u007F' && LA27_7 <= '\u2FFF')||(LA27_7 >= '\u3001' && LA27_7 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA27_7=='\\') ) {s = 2;}
+
+ else if ( (LA27_7=='-') ) {s = 3;}
+
+ else if ( (LA27_7=='+') ) {s = 4;}
+
+ else if ( (LA27_7=='*'||LA27_7=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA27_4 = input.LA(1);
+
+ s = -1;
+ if ( ((LA27_4 >= '\u0000' && LA27_4 <= '\b')||(LA27_4 >= '\u000B' && LA27_4 <= '\f')||(LA27_4 >= '\u000E' && LA27_4 <= '\u001F')||(LA27_4 >= '#' && LA27_4 <= '&')||LA27_4==','||(LA27_4 >= '.' && LA27_4 <= '9')||(LA27_4 >= ';' && LA27_4 <= '>')||(LA27_4 >= '@' && LA27_4 <= 'Z')||(LA27_4 >= '_' && LA27_4 <= 'z')||LA27_4=='|'||(LA27_4 >= '\u007F' && LA27_4 <= '\u2FFF')||(LA27_4 >= '\u3001' && LA27_4 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA27_4=='\\') ) {s = 2;}
+
+ else if ( (LA27_4=='-') ) {s = 3;}
+
+ else if ( (LA27_4=='+') ) {s = 4;}
+
+ else if ( (LA27_4=='*'||LA27_4=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA27_0 = input.LA(1);
+
+ s = -1;
+ if ( ((LA27_0 >= '\u0000' && LA27_0 <= '\b')||(LA27_0 >= '\u000B' && LA27_0 <= '\f')||(LA27_0 >= '\u000E' && LA27_0 <= '\u001F')||(LA27_0 >= '#' && LA27_0 <= '&')||LA27_0==','||(LA27_0 >= '.' && LA27_0 <= '9')||(LA27_0 >= ';' && LA27_0 <= '>')||(LA27_0 >= '@' && LA27_0 <= 'Z')||(LA27_0 >= '_' && LA27_0 <= 'z')||LA27_0=='|'||(LA27_0 >= '\u007F' && LA27_0 <= '\u2FFF')||(LA27_0 >= '\u3001' && LA27_0 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA27_0=='\\') ) {s = 2;}
+
+ else if ( (LA27_0=='-') ) {s = 3;}
+
+ else if ( (LA27_0=='+') ) {s = 4;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA27_2 = input.LA(1);
+
+ s = -1;
+ if ( ((LA27_2 >= '\u0000' && LA27_2 <= '\uFFFF')) ) {s = 7;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA27_1 = input.LA(1);
+
+ s = -1;
+ if ( ((LA27_1 >= '\u0000' && LA27_1 <= '\b')||(LA27_1 >= '\u000B' && LA27_1 <= '\f')||(LA27_1 >= '\u000E' && LA27_1 <= '\u001F')||(LA27_1 >= '#' && LA27_1 <= '&')||LA27_1==','||(LA27_1 >= '.' && LA27_1 <= '9')||(LA27_1 >= ';' && LA27_1 <= '>')||(LA27_1 >= '@' && LA27_1 <= 'Z')||(LA27_1 >= '_' && LA27_1 <= 'z')||LA27_1=='|'||(LA27_1 >= '\u007F' && LA27_1 <= '\u2FFF')||(LA27_1 >= '\u3001' && LA27_1 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA27_1=='\\') ) {s = 2;}
+
+ else if ( (LA27_1=='-') ) {s = 3;}
+
+ else if ( (LA27_1=='+') ) {s = 4;}
+
+ else if ( (LA27_1=='*'||LA27_1=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 27, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+
+ }
+ static final String DFA31_eotS =
+ "\2\5\1\uffff\2\5\2\uffff\1\5";
+ static final String DFA31_eofS =
+ "\10\uffff";
+ static final String DFA31_minS =
+ "\5\0\2\uffff\1\0";
+ static final String DFA31_maxS =
+ "\5\uffff\2\uffff\1\uffff";
+ static final String DFA31_acceptS =
+ "\5\uffff\1\2\1\1\1\uffff";
+ static final String DFA31_specialS =
+ "\1\1\1\3\1\4\1\5\1\2\2\uffff\1\0}>";
+ static final String[] DFA31_transitionS = {
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4\1"+
+ "\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1\1"+
+ "\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1",
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4"+
+ "\1\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1"+
+ "\1\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1",
+ "\0\7",
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4"+
+ "\1\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1"+
+ "\1\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1",
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4"+
+ "\1\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1"+
+ "\1\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1",
+ "",
+ "",
+ "\11\1\2\uffff\2\1\1\uffff\22\1\3\uffff\4\1\3\uffff\1\6\1\4"+
+ "\1\1\1\3\14\1\1\uffff\4\1\1\6\33\1\1\uffff\1\2\2\uffff\34\1"+
+ "\1\uffff\1\1\2\uffff\u2f81\1\1\uffff\ucfff\1"
+ };
+
+ static final short[] DFA31_eot = DFA.unpackEncodedString(DFA31_eotS);
+ static final short[] DFA31_eof = DFA.unpackEncodedString(DFA31_eofS);
+ static final char[] DFA31_min = DFA.unpackEncodedStringToUnsignedChars(DFA31_minS);
+ static final char[] DFA31_max = DFA.unpackEncodedStringToUnsignedChars(DFA31_maxS);
+ static final short[] DFA31_accept = DFA.unpackEncodedString(DFA31_acceptS);
+ static final short[] DFA31_special = DFA.unpackEncodedString(DFA31_specialS);
+ static final short[][] DFA31_transition;
+
+ static {
+ int numStates = DFA31_transitionS.length;
+ DFA31_transition = new short[numStates][];
+ for (int i=0; i= '\u0000' && LA31_7 <= '\b')||(LA31_7 >= '\u000B' && LA31_7 <= '\f')||(LA31_7 >= '\u000E' && LA31_7 <= '\u001F')||(LA31_7 >= '#' && LA31_7 <= '&')||LA31_7==','||(LA31_7 >= '.' && LA31_7 <= '9')||(LA31_7 >= ';' && LA31_7 <= '>')||(LA31_7 >= '@' && LA31_7 <= 'Z')||(LA31_7 >= '_' && LA31_7 <= 'z')||LA31_7=='|'||(LA31_7 >= '\u007F' && LA31_7 <= '\u2FFF')||(LA31_7 >= '\u3001' && LA31_7 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA31_7=='\\') ) {s = 2;}
+
+ else if ( (LA31_7=='-') ) {s = 3;}
+
+ else if ( (LA31_7=='+') ) {s = 4;}
+
+ else if ( (LA31_7=='*'||LA31_7=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA31_0 = input.LA(1);
+
+ s = -1;
+ if ( ((LA31_0 >= '\u0000' && LA31_0 <= '\b')||(LA31_0 >= '\u000B' && LA31_0 <= '\f')||(LA31_0 >= '\u000E' && LA31_0 <= '\u001F')||(LA31_0 >= '#' && LA31_0 <= '&')||LA31_0==','||(LA31_0 >= '.' && LA31_0 <= '9')||(LA31_0 >= ';' && LA31_0 <= '>')||(LA31_0 >= '@' && LA31_0 <= 'Z')||(LA31_0 >= '_' && LA31_0 <= 'z')||LA31_0=='|'||(LA31_0 >= '\u007F' && LA31_0 <= '\u2FFF')||(LA31_0 >= '\u3001' && LA31_0 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA31_0=='\\') ) {s = 2;}
+
+ else if ( (LA31_0=='-') ) {s = 3;}
+
+ else if ( (LA31_0=='+') ) {s = 4;}
+
+ else if ( (LA31_0=='*'||LA31_0=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA31_4 = input.LA(1);
+
+ s = -1;
+ if ( ((LA31_4 >= '\u0000' && LA31_4 <= '\b')||(LA31_4 >= '\u000B' && LA31_4 <= '\f')||(LA31_4 >= '\u000E' && LA31_4 <= '\u001F')||(LA31_4 >= '#' && LA31_4 <= '&')||LA31_4==','||(LA31_4 >= '.' && LA31_4 <= '9')||(LA31_4 >= ';' && LA31_4 <= '>')||(LA31_4 >= '@' && LA31_4 <= 'Z')||(LA31_4 >= '_' && LA31_4 <= 'z')||LA31_4=='|'||(LA31_4 >= '\u007F' && LA31_4 <= '\u2FFF')||(LA31_4 >= '\u3001' && LA31_4 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA31_4=='\\') ) {s = 2;}
+
+ else if ( (LA31_4=='-') ) {s = 3;}
+
+ else if ( (LA31_4=='+') ) {s = 4;}
+
+ else if ( (LA31_4=='*'||LA31_4=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA31_1 = input.LA(1);
+
+ s = -1;
+ if ( ((LA31_1 >= '\u0000' && LA31_1 <= '\b')||(LA31_1 >= '\u000B' && LA31_1 <= '\f')||(LA31_1 >= '\u000E' && LA31_1 <= '\u001F')||(LA31_1 >= '#' && LA31_1 <= '&')||LA31_1==','||(LA31_1 >= '.' && LA31_1 <= '9')||(LA31_1 >= ';' && LA31_1 <= '>')||(LA31_1 >= '@' && LA31_1 <= 'Z')||(LA31_1 >= '_' && LA31_1 <= 'z')||LA31_1=='|'||(LA31_1 >= '\u007F' && LA31_1 <= '\u2FFF')||(LA31_1 >= '\u3001' && LA31_1 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA31_1=='\\') ) {s = 2;}
+
+ else if ( (LA31_1=='-') ) {s = 3;}
+
+ else if ( (LA31_1=='+') ) {s = 4;}
+
+ else if ( (LA31_1=='*'||LA31_1=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA31_2 = input.LA(1);
+
+ s = -1;
+ if ( ((LA31_2 >= '\u0000' && LA31_2 <= '\uFFFF')) ) {s = 7;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA31_3 = input.LA(1);
+
+ s = -1;
+ if ( ((LA31_3 >= '\u0000' && LA31_3 <= '\b')||(LA31_3 >= '\u000B' && LA31_3 <= '\f')||(LA31_3 >= '\u000E' && LA31_3 <= '\u001F')||(LA31_3 >= '#' && LA31_3 <= '&')||LA31_3==','||(LA31_3 >= '.' && LA31_3 <= '9')||(LA31_3 >= ';' && LA31_3 <= '>')||(LA31_3 >= '@' && LA31_3 <= 'Z')||(LA31_3 >= '_' && LA31_3 <= 'z')||LA31_3=='|'||(LA31_3 >= '\u007F' && LA31_3 <= '\u2FFF')||(LA31_3 >= '\u3001' && LA31_3 <= '\uFFFF')) ) {s = 1;}
+
+ else if ( (LA31_3=='\\') ) {s = 2;}
+
+ else if ( (LA31_3=='-') ) {s = 3;}
+
+ else if ( (LA31_3=='+') ) {s = 4;}
+
+ else if ( (LA31_3=='*'||LA31_3=='?') ) {s = 6;}
+
+ else s = 5;
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 31, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+
+ }
+ static final String DFA38_eotS =
+ "\1\uffff\1\34\7\uffff\1\42\1\43\4\uffff\1\44\1\uffff\2\51\1\53\1"+
+ "\51\1\56\1\62\1\51\1\uffff\1\64\1\51\2\uffff\1\51\1\uffff\2\51\7"+
+ "\uffff\1\74\1\uffff\1\51\1\uffff\1\53\1\56\1\uffff\1\56\2\51\1\uffff"+
+ "\1\51\1\uffff\1\64\4\51\3\uffff\1\53\1\104\1\51\2\64\1\51\2\uffff"+
+ "\1\62\1\64\4\51\1\64\1\51\1\116\1\uffff\1\51\1\116";
+ static final String DFA38_eofS =
+ "\121\uffff";
+ static final String DFA38_minS =
+ "\2\0\7\uffff\2\0\4\uffff\1\0\1\uffff\7\0\1\uffff\3\0\1\uffff\4\0"+
+ "\4\uffff\2\0\1\uffff\1\0\1\uffff\1\0\1\uffff\2\0\1\uffff\3\0\1\uffff"+
+ "\1\0\1\uffff\6\0\2\uffff\6\0\2\uffff\11\0\1\uffff\2\0";
+ static final String DFA38_maxS =
+ "\2\uffff\7\uffff\2\uffff\4\uffff\1\uffff\1\uffff\7\uffff\1\uffff"+
+ "\3\uffff\1\uffff\4\uffff\4\uffff\2\uffff\1\uffff\1\uffff\1\uffff"+
+ "\1\uffff\1\uffff\2\uffff\1\uffff\3\uffff\1\uffff\1\uffff\1\uffff"+
+ "\6\uffff\2\uffff\6\uffff\2\uffff\11\uffff\1\uffff\2\uffff";
+ static final String DFA38_acceptS =
+ "\2\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff\1\13\1\14\1\15\1\16"+
+ "\1\uffff\1\20\7\uffff\1\26\3\uffff\1\1\4\uffff\1\32\1\11\1\12\1"+
+ "\17\2\uffff\1\34\1\uffff\1\31\1\uffff\1\22\2\uffff\1\23\3\uffff"+
+ "\1\25\1\uffff\1\27\6\uffff\1\33\1\21\6\uffff\1\33\1\24\11\uffff"+
+ "\1\30\2\uffff";
+ static final String DFA38_specialS =
+ "\1\10\1\1\7\uffff\1\55\1\63\4\uffff\1\56\1\uffff\1\3\1\7\1\50\1"+
+ "\13\1\51\1\62\1\21\1\uffff\1\2\1\34\1\11\1\uffff\1\15\1\12\1\46"+
+ "\1\44\4\uffff\1\17\1\0\1\uffff\1\57\1\uffff\1\47\1\uffff\1\30\1"+
+ "\5\1\uffff\1\60\1\32\1\40\1\uffff\1\61\1\uffff\1\43\1\14\1\25\1"+
+ "\37\1\45\1\24\2\uffff\1\16\1\27\1\36\1\6\1\4\1\42\2\uffff\1\35\1"+
+ "\54\1\41\1\33\1\22\1\23\1\53\1\26\1\31\1\uffff\1\20\1\52}>";
+ static final String[] DFA38_transitionS = {
+ "\11\32\2\30\2\32\1\30\22\32\1\30\1\10\1\17\3\32\1\23\1\20\1"+
+ "\2\1\3\1\11\1\7\1\32\1\10\1\32\1\1\12\31\1\6\4\32\1\12\1\32"+
+ "\1\22\14\32\1\27\1\24\4\32\1\21\6\32\1\4\1\33\1\5\1\15\2\32"+
+ "\1\22\14\32\1\26\1\24\13\32\1\13\1\25\1\14\1\16\u2f81\32\1\30"+
+ "\ucfff\32",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\11\41\2\uffff\2\41\1\uffff\22\41\3\uffff\4\41\4\uffff\17\41"+
+ "\1\uffff\4\41\1\uffff\33\41\1\uffff\1\41\2\uffff\34\41\1\uffff"+
+ "\1\41\2\uffff\u2f81\41\1\uffff\ucfff\41",
+ "\11\41\2\uffff\2\41\1\uffff\22\41\3\uffff\4\41\4\uffff\17\41"+
+ "\1\uffff\4\41\1\12\33\41\1\uffff\1\41\2\uffff\34\41\1\uffff"+
+ "\1\41\2\uffff\u2f81\41\1\uffff\ucfff\41",
+ "",
+ "",
+ "",
+ "",
+ "\42\46\1\uffff\7\46\1\47\24\46\1\47\34\46\1\45\uffa3\46",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\17\35\1\50\13\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\16\35\1\52\14\35\1\uffff"+
+ "\1\36\2\uffff\17\35\1\52\14\35\1\uffff\1\35\2\uffff\u2f81\35"+
+ "\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\3\35\1\54\3\uffff"+
+ "\1\41\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1"+
+ "\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\22\35\1\55\10\35\1\uffff"+
+ "\1\36\2\uffff\23\35\1\55\10\35\1\uffff\1\35\2\uffff\u2f81\35"+
+ "\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\57\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\5\35\1\61\11\35\1\60"+
+ "\13\35\1\uffff\1\36\2\uffff\6\35\1\61\11\35\1\60\13\35\1\uffff"+
+ "\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\5\35\1\61\11\35\1\60"+
+ "\13\35\1\uffff\1\36\2\uffff\6\35\1\61\11\35\1\60\13\35\1\uffff"+
+ "\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\67\1\63\1\66\12\65\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\0\70",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\0\71",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "",
+ "",
+ "",
+ "",
+ "\0\72",
+ "\42\46\1\73\7\46\1\47\24\46\1\47\34\46\1\45\uffa3\46",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\4\35\1\75\26\35\1\uffff"+
+ "\1\36\2\uffff\5\35\1\75\26\35\1\uffff\1\35\2\uffff\u2f81\35"+
+ "\1\uffff\ucfff\35",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\24\35\1\76\6\35\1\uffff"+
+ "\1\36\2\uffff\25\35\1\76\6\35\1\uffff\1\35\2\uffff\u2f81\35"+
+ "\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\1\35\1\77\31\35\1\uffff"+
+ "\1\36\2\uffff\2\35\1\77\31\35\1\uffff\1\35\2\uffff\u2f81\35"+
+ "\1\uffff\ucfff\35",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\100\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\67\1\63\1\66\12\101\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\102\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\102\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\42\46\1\73\7\46\1\47\24\46\1\47\34\46\1\45\uffa3\46",
+ "",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\22\35\1\105\10\35\1"+
+ "\uffff\1\36\2\uffff\23\35\1\105\10\35\1\uffff\1\35\2\uffff\u2f81"+
+ "\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\110\2\107\12\106\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\1\111\1\35\12\101\1\uffff\4\35\1\41\33\35\1"+
+ "\uffff\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff"+
+ "\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\110\2\107\12\112\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\110\2\107\12\113\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\114\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\114\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\113\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\110\2\107\12\35\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\113\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\115\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\117\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\2\35\12\120\1\uffff\4\35\1\41\33\35\1\uffff"+
+ "\1\36\2\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff"+
+ "\35",
+ "\11\35\2\uffff\2\35\1\uffff\22\35\3\uffff\4\35\3\uffff\1\41"+
+ "\1\40\1\35\1\37\14\35\1\uffff\4\35\1\41\33\35\1\uffff\1\36\2"+
+ "\uffff\34\35\1\uffff\1\35\2\uffff\u2f81\35\1\uffff\ucfff\35"
+ };
+
+ static final short[] DFA38_eot = DFA.unpackEncodedString(DFA38_eotS);
+ static final short[] DFA38_eof = DFA.unpackEncodedString(DFA38_eofS);
+ static final char[] DFA38_min = DFA.unpackEncodedStringToUnsignedChars(DFA38_minS);
+ static final char[] DFA38_max = DFA.unpackEncodedStringToUnsignedChars(DFA38_maxS);
+ static final short[] DFA38_accept = DFA.unpackEncodedString(DFA38_acceptS);
+ static final short[] DFA38_special = DFA.unpackEncodedString(DFA38_specialS);
+ static final short[][] DFA38_transition;
+
+ static {
+ int numStates = DFA38_transitionS.length;
+ DFA38_transition = new short[numStates][];
+ for (int i=0; i= '\u0000' && LA38_38 <= '!')||(LA38_38 >= '#' && LA38_38 <= ')')||(LA38_38 >= '+' && LA38_38 <= '>')||(LA38_38 >= '@' && LA38_38 <= '[')||(LA38_38 >= ']' && LA38_38 <= '\uFFFF')) ) {s = 38;}
+
+ else if ( (LA38_38=='*'||LA38_38=='?') ) {s = 39;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA38_1 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_1 >= '\u0000' && LA38_1 <= '\b')||(LA38_1 >= '\u000B' && LA38_1 <= '\f')||(LA38_1 >= '\u000E' && LA38_1 <= '\u001F')||(LA38_1 >= '#' && LA38_1 <= '&')||LA38_1==','||(LA38_1 >= '.' && LA38_1 <= '9')||(LA38_1 >= ';' && LA38_1 <= '>')||(LA38_1 >= '@' && LA38_1 <= 'Z')||(LA38_1 >= '_' && LA38_1 <= 'z')||LA38_1=='|'||(LA38_1 >= '\u007F' && LA38_1 <= '\u2FFF')||(LA38_1 >= '\u3001' && LA38_1 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_1=='\\') ) {s = 30;}
+
+ else if ( (LA38_1=='-') ) {s = 31;}
+
+ else if ( (LA38_1=='+') ) {s = 32;}
+
+ else if ( (LA38_1=='*'||LA38_1=='?') ) {s = 33;}
+
+ else s = 28;
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA38_25 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_25=='.') ) {s = 51;}
+
+ else if ( ((LA38_25 >= '0' && LA38_25 <= '9')) ) {s = 53;}
+
+ else if ( (LA38_25=='/') ) {s = 54;}
+
+ else if ( (LA38_25=='-') ) {s = 55;}
+
+ else if ( ((LA38_25 >= '\u0000' && LA38_25 <= '\b')||(LA38_25 >= '\u000B' && LA38_25 <= '\f')||(LA38_25 >= '\u000E' && LA38_25 <= '\u001F')||(LA38_25 >= '#' && LA38_25 <= '&')||LA38_25==','||(LA38_25 >= ';' && LA38_25 <= '>')||(LA38_25 >= '@' && LA38_25 <= 'Z')||(LA38_25 >= '_' && LA38_25 <= 'z')||LA38_25=='|'||(LA38_25 >= '\u007F' && LA38_25 <= '\u2FFF')||(LA38_25 >= '\u3001' && LA38_25 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_25=='\\') ) {s = 30;}
+
+ else if ( (LA38_25=='+') ) {s = 32;}
+
+ else if ( (LA38_25=='*'||LA38_25=='?') ) {s = 33;}
+
+ else s = 52;
+
+ if ( s>=0 ) return s;
+ break;
+ case 3 :
+ int LA38_17 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_17=='O') ) {s = 40;}
+
+ else if ( ((LA38_17 >= '\u0000' && LA38_17 <= '\b')||(LA38_17 >= '\u000B' && LA38_17 <= '\f')||(LA38_17 >= '\u000E' && LA38_17 <= '\u001F')||(LA38_17 >= '#' && LA38_17 <= '&')||LA38_17==','||(LA38_17 >= '.' && LA38_17 <= '9')||(LA38_17 >= ';' && LA38_17 <= '>')||(LA38_17 >= '@' && LA38_17 <= 'N')||(LA38_17 >= 'P' && LA38_17 <= 'Z')||(LA38_17 >= '_' && LA38_17 <= 'z')||LA38_17=='|'||(LA38_17 >= '\u007F' && LA38_17 <= '\u2FFF')||(LA38_17 >= '\u3001' && LA38_17 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_17=='\\') ) {s = 30;}
+
+ else if ( (LA38_17=='-') ) {s = 31;}
+
+ else if ( (LA38_17=='+') ) {s = 32;}
+
+ else if ( (LA38_17=='*'||LA38_17=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 4 :
+ int LA38_65 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_65=='.') ) {s = 73;}
+
+ else if ( ((LA38_65 >= '0' && LA38_65 <= '9')) ) {s = 65;}
+
+ else if ( ((LA38_65 >= '\u0000' && LA38_65 <= '\b')||(LA38_65 >= '\u000B' && LA38_65 <= '\f')||(LA38_65 >= '\u000E' && LA38_65 <= '\u001F')||(LA38_65 >= '#' && LA38_65 <= '&')||LA38_65==','||LA38_65=='/'||(LA38_65 >= ';' && LA38_65 <= '>')||(LA38_65 >= '@' && LA38_65 <= 'Z')||(LA38_65 >= '_' && LA38_65 <= 'z')||LA38_65=='|'||(LA38_65 >= '\u007F' && LA38_65 <= '\u2FFF')||(LA38_65 >= '\u3001' && LA38_65 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_65=='\\') ) {s = 30;}
+
+ else if ( (LA38_65=='-') ) {s = 31;}
+
+ else if ( (LA38_65=='+') ) {s = 32;}
+
+ else if ( (LA38_65=='*'||LA38_65=='?') ) {s = 33;}
+
+ else s = 52;
+
+ if ( s>=0 ) return s;
+ break;
+ case 5 :
+ int LA38_45 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_45 >= '\u0000' && LA38_45 <= '\b')||(LA38_45 >= '\u000B' && LA38_45 <= '\f')||(LA38_45 >= '\u000E' && LA38_45 <= '\u001F')||(LA38_45 >= '#' && LA38_45 <= '&')||LA38_45==','||(LA38_45 >= '.' && LA38_45 <= '9')||(LA38_45 >= ';' && LA38_45 <= '>')||(LA38_45 >= '@' && LA38_45 <= 'Z')||(LA38_45 >= '_' && LA38_45 <= 'z')||LA38_45=='|'||(LA38_45 >= '\u007F' && LA38_45 <= '\u2FFF')||(LA38_45 >= '\u3001' && LA38_45 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_45=='\\') ) {s = 30;}
+
+ else if ( (LA38_45=='-') ) {s = 31;}
+
+ else if ( (LA38_45=='+') ) {s = 32;}
+
+ else if ( (LA38_45=='*'||LA38_45=='?') ) {s = 33;}
+
+ else s = 46;
+
+ if ( s>=0 ) return s;
+ break;
+ case 6 :
+ int LA38_64 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_64 >= '0' && LA38_64 <= '9')) ) {s = 70;}
+
+ else if ( ((LA38_64 >= '.' && LA38_64 <= '/')) ) {s = 71;}
+
+ else if ( (LA38_64=='-') ) {s = 72;}
+
+ else if ( ((LA38_64 >= '\u0000' && LA38_64 <= '\b')||(LA38_64 >= '\u000B' && LA38_64 <= '\f')||(LA38_64 >= '\u000E' && LA38_64 <= '\u001F')||(LA38_64 >= '#' && LA38_64 <= '&')||LA38_64==','||(LA38_64 >= ';' && LA38_64 <= '>')||(LA38_64 >= '@' && LA38_64 <= 'Z')||(LA38_64 >= '_' && LA38_64 <= 'z')||LA38_64=='|'||(LA38_64 >= '\u007F' && LA38_64 <= '\u2FFF')||(LA38_64 >= '\u3001' && LA38_64 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_64=='\\') ) {s = 30;}
+
+ else if ( (LA38_64=='+') ) {s = 32;}
+
+ else if ( (LA38_64=='*'||LA38_64=='?') ) {s = 33;}
+
+ else s = 52;
+
+ if ( s>=0 ) return s;
+ break;
+ case 7 :
+ int LA38_18 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_18=='N'||LA38_18=='n') ) {s = 42;}
+
+ else if ( ((LA38_18 >= '\u0000' && LA38_18 <= '\b')||(LA38_18 >= '\u000B' && LA38_18 <= '\f')||(LA38_18 >= '\u000E' && LA38_18 <= '\u001F')||(LA38_18 >= '#' && LA38_18 <= '&')||LA38_18==','||(LA38_18 >= '.' && LA38_18 <= '9')||(LA38_18 >= ';' && LA38_18 <= '>')||(LA38_18 >= '@' && LA38_18 <= 'M')||(LA38_18 >= 'O' && LA38_18 <= 'Z')||(LA38_18 >= '_' && LA38_18 <= 'm')||(LA38_18 >= 'o' && LA38_18 <= 'z')||LA38_18=='|'||(LA38_18 >= '\u007F' && LA38_18 <= '\u2FFF')||(LA38_18 >= '\u3001' && LA38_18 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_18=='\\') ) {s = 30;}
+
+ else if ( (LA38_18=='-') ) {s = 31;}
+
+ else if ( (LA38_18=='+') ) {s = 32;}
+
+ else if ( (LA38_18=='*'||LA38_18=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 8 :
+ int LA38_0 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_0=='/') ) {s = 1;}
+
+ else if ( (LA38_0=='(') ) {s = 2;}
+
+ else if ( (LA38_0==')') ) {s = 3;}
+
+ else if ( (LA38_0=='[') ) {s = 4;}
+
+ else if ( (LA38_0==']') ) {s = 5;}
+
+ else if ( (LA38_0==':') ) {s = 6;}
+
+ else if ( (LA38_0=='+') ) {s = 7;}
+
+ else if ( (LA38_0=='!'||LA38_0=='-') ) {s = 8;}
+
+ else if ( (LA38_0=='*') ) {s = 9;}
+
+ else if ( (LA38_0=='?') ) {s = 10;}
+
+ else if ( (LA38_0=='{') ) {s = 11;}
+
+ else if ( (LA38_0=='}') ) {s = 12;}
+
+ else if ( (LA38_0=='^') ) {s = 13;}
+
+ else if ( (LA38_0=='~') ) {s = 14;}
+
+ else if ( (LA38_0=='\"') ) {s = 15;}
+
+ else if ( (LA38_0=='\'') ) {s = 16;}
+
+ else if ( (LA38_0=='T') ) {s = 17;}
+
+ else if ( (LA38_0=='A'||LA38_0=='a') ) {s = 18;}
+
+ else if ( (LA38_0=='&') ) {s = 19;}
+
+ else if ( (LA38_0=='O'||LA38_0=='o') ) {s = 20;}
+
+ else if ( (LA38_0=='|') ) {s = 21;}
+
+ else if ( (LA38_0=='n') ) {s = 22;}
+
+ else if ( (LA38_0=='N') ) {s = 23;}
+
+ else if ( ((LA38_0 >= '\t' && LA38_0 <= '\n')||LA38_0=='\r'||LA38_0==' '||LA38_0=='\u3000') ) {s = 24;}
+
+ else if ( ((LA38_0 >= '0' && LA38_0 <= '9')) ) {s = 25;}
+
+ else if ( ((LA38_0 >= '\u0000' && LA38_0 <= '\b')||(LA38_0 >= '\u000B' && LA38_0 <= '\f')||(LA38_0 >= '\u000E' && LA38_0 <= '\u001F')||(LA38_0 >= '#' && LA38_0 <= '%')||LA38_0==','||LA38_0=='.'||(LA38_0 >= ';' && LA38_0 <= '>')||LA38_0=='@'||(LA38_0 >= 'B' && LA38_0 <= 'M')||(LA38_0 >= 'P' && LA38_0 <= 'S')||(LA38_0 >= 'U' && LA38_0 <= 'Z')||(LA38_0 >= '_' && LA38_0 <= '`')||(LA38_0 >= 'b' && LA38_0 <= 'm')||(LA38_0 >= 'p' && LA38_0 <= 'z')||(LA38_0 >= '\u007F' && LA38_0 <= '\u2FFF')||(LA38_0 >= '\u3001' && LA38_0 <= '\uFFFF')) ) {s = 26;}
+
+ else if ( (LA38_0=='\\') ) {s = 27;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 9 :
+ int LA38_27 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_27 >= '\u0000' && LA38_27 <= '\uFFFF')) ) {s = 56;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 10 :
+ int LA38_30 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_30 >= '\u0000' && LA38_30 <= '\uFFFF')) ) {s = 57;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 11 :
+ int LA38_20 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_20=='R'||LA38_20=='r') ) {s = 45;}
+
+ else if ( ((LA38_20 >= '\u0000' && LA38_20 <= '\b')||(LA38_20 >= '\u000B' && LA38_20 <= '\f')||(LA38_20 >= '\u000E' && LA38_20 <= '\u001F')||(LA38_20 >= '#' && LA38_20 <= '&')||LA38_20==','||(LA38_20 >= '.' && LA38_20 <= '9')||(LA38_20 >= ';' && LA38_20 <= '>')||(LA38_20 >= '@' && LA38_20 <= 'Q')||(LA38_20 >= 'S' && LA38_20 <= 'Z')||(LA38_20 >= '_' && LA38_20 <= 'q')||(LA38_20 >= 's' && LA38_20 <= 'z')||LA38_20=='|'||(LA38_20 >= '\u007F' && LA38_20 <= '\u2FFF')||(LA38_20 >= '\u3001' && LA38_20 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_20=='\\') ) {s = 30;}
+
+ else if ( (LA38_20=='-') ) {s = 31;}
+
+ else if ( (LA38_20=='+') ) {s = 32;}
+
+ else if ( (LA38_20=='*'||LA38_20=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 12 :
+ int LA38_54 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_54 >= '0' && LA38_54 <= '9')) ) {s = 66;}
+
+ else if ( ((LA38_54 >= '\u0000' && LA38_54 <= '\b')||(LA38_54 >= '\u000B' && LA38_54 <= '\f')||(LA38_54 >= '\u000E' && LA38_54 <= '\u001F')||(LA38_54 >= '#' && LA38_54 <= '&')||LA38_54==','||(LA38_54 >= '.' && LA38_54 <= '/')||(LA38_54 >= ';' && LA38_54 <= '>')||(LA38_54 >= '@' && LA38_54 <= 'Z')||(LA38_54 >= '_' && LA38_54 <= 'z')||LA38_54=='|'||(LA38_54 >= '\u007F' && LA38_54 <= '\u2FFF')||(LA38_54 >= '\u3001' && LA38_54 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_54=='\\') ) {s = 30;}
+
+ else if ( (LA38_54=='-') ) {s = 31;}
+
+ else if ( (LA38_54=='+') ) {s = 32;}
+
+ else if ( (LA38_54=='*'||LA38_54=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 13 :
+ int LA38_29 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_29 >= '\u0000' && LA38_29 <= '\b')||(LA38_29 >= '\u000B' && LA38_29 <= '\f')||(LA38_29 >= '\u000E' && LA38_29 <= '\u001F')||(LA38_29 >= '#' && LA38_29 <= '&')||LA38_29==','||(LA38_29 >= '.' && LA38_29 <= '9')||(LA38_29 >= ';' && LA38_29 <= '>')||(LA38_29 >= '@' && LA38_29 <= 'Z')||(LA38_29 >= '_' && LA38_29 <= 'z')||LA38_29=='|'||(LA38_29 >= '\u007F' && LA38_29 <= '\u2FFF')||(LA38_29 >= '\u3001' && LA38_29 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_29=='\\') ) {s = 30;}
+
+ else if ( (LA38_29=='-') ) {s = 31;}
+
+ else if ( (LA38_29=='+') ) {s = 32;}
+
+ else if ( (LA38_29=='*'||LA38_29=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 14 :
+ int LA38_61 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_61 >= '\u0000' && LA38_61 <= '\b')||(LA38_61 >= '\u000B' && LA38_61 <= '\f')||(LA38_61 >= '\u000E' && LA38_61 <= '\u001F')||(LA38_61 >= '#' && LA38_61 <= '&')||LA38_61==','||(LA38_61 >= '.' && LA38_61 <= '9')||(LA38_61 >= ';' && LA38_61 <= '>')||(LA38_61 >= '@' && LA38_61 <= 'Z')||(LA38_61 >= '_' && LA38_61 <= 'z')||LA38_61=='|'||(LA38_61 >= '\u007F' && LA38_61 <= '\u2FFF')||(LA38_61 >= '\u3001' && LA38_61 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_61=='\\') ) {s = 30;}
+
+ else if ( (LA38_61=='-') ) {s = 31;}
+
+ else if ( (LA38_61=='+') ) {s = 32;}
+
+ else if ( (LA38_61=='*'||LA38_61=='?') ) {s = 33;}
+
+ else s = 43;
+
+ if ( s>=0 ) return s;
+ break;
+ case 15 :
+ int LA38_37 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_37 >= '\u0000' && LA38_37 <= '\uFFFF')) ) {s = 58;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 16 :
+ int LA38_79 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_79 >= '0' && LA38_79 <= '9')) ) {s = 80;}
+
+ else if ( ((LA38_79 >= '\u0000' && LA38_79 <= '\b')||(LA38_79 >= '\u000B' && LA38_79 <= '\f')||(LA38_79 >= '\u000E' && LA38_79 <= '\u001F')||(LA38_79 >= '#' && LA38_79 <= '&')||LA38_79==','||(LA38_79 >= '.' && LA38_79 <= '/')||(LA38_79 >= ';' && LA38_79 <= '>')||(LA38_79 >= '@' && LA38_79 <= 'Z')||(LA38_79 >= '_' && LA38_79 <= 'z')||LA38_79=='|'||(LA38_79 >= '\u007F' && LA38_79 <= '\u2FFF')||(LA38_79 >= '\u3001' && LA38_79 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_79=='\\') ) {s = 30;}
+
+ else if ( (LA38_79=='-') ) {s = 31;}
+
+ else if ( (LA38_79=='+') ) {s = 32;}
+
+ else if ( (LA38_79=='*'||LA38_79=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 17 :
+ int LA38_23 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_23=='O'||LA38_23=='o') ) {s = 48;}
+
+ else if ( (LA38_23=='E'||LA38_23=='e') ) {s = 49;}
+
+ else if ( ((LA38_23 >= '\u0000' && LA38_23 <= '\b')||(LA38_23 >= '\u000B' && LA38_23 <= '\f')||(LA38_23 >= '\u000E' && LA38_23 <= '\u001F')||(LA38_23 >= '#' && LA38_23 <= '&')||LA38_23==','||(LA38_23 >= '.' && LA38_23 <= '9')||(LA38_23 >= ';' && LA38_23 <= '>')||(LA38_23 >= '@' && LA38_23 <= 'D')||(LA38_23 >= 'F' && LA38_23 <= 'N')||(LA38_23 >= 'P' && LA38_23 <= 'Z')||(LA38_23 >= '_' && LA38_23 <= 'd')||(LA38_23 >= 'f' && LA38_23 <= 'n')||(LA38_23 >= 'p' && LA38_23 <= 'z')||LA38_23=='|'||(LA38_23 >= '\u007F' && LA38_23 <= '\u2FFF')||(LA38_23 >= '\u3001' && LA38_23 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_23=='\\') ) {s = 30;}
+
+ else if ( (LA38_23=='-') ) {s = 31;}
+
+ else if ( (LA38_23=='+') ) {s = 32;}
+
+ else if ( (LA38_23=='*'||LA38_23=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 18 :
+ int LA38_73 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_73 >= '0' && LA38_73 <= '9')) ) {s = 75;}
+
+ else if ( ((LA38_73 >= '\u0000' && LA38_73 <= '\b')||(LA38_73 >= '\u000B' && LA38_73 <= '\f')||(LA38_73 >= '\u000E' && LA38_73 <= '\u001F')||(LA38_73 >= '#' && LA38_73 <= '&')||LA38_73==','||(LA38_73 >= '.' && LA38_73 <= '/')||(LA38_73 >= ';' && LA38_73 <= '>')||(LA38_73 >= '@' && LA38_73 <= 'Z')||(LA38_73 >= '_' && LA38_73 <= 'z')||LA38_73=='|'||(LA38_73 >= '\u007F' && LA38_73 <= '\u2FFF')||(LA38_73 >= '\u3001' && LA38_73 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_73=='\\') ) {s = 30;}
+
+ else if ( (LA38_73=='-') ) {s = 31;}
+
+ else if ( (LA38_73=='+') ) {s = 32;}
+
+ else if ( (LA38_73=='*'||LA38_73=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 19 :
+ int LA38_74 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_74 >= '.' && LA38_74 <= '/')) ) {s = 71;}
+
+ else if ( (LA38_74=='-') ) {s = 72;}
+
+ else if ( ((LA38_74 >= '\u0000' && LA38_74 <= '\b')||(LA38_74 >= '\u000B' && LA38_74 <= '\f')||(LA38_74 >= '\u000E' && LA38_74 <= '\u001F')||(LA38_74 >= '#' && LA38_74 <= '&')||LA38_74==','||(LA38_74 >= '0' && LA38_74 <= '9')||(LA38_74 >= ';' && LA38_74 <= '>')||(LA38_74 >= '@' && LA38_74 <= 'Z')||(LA38_74 >= '_' && LA38_74 <= 'z')||LA38_74=='|'||(LA38_74 >= '\u007F' && LA38_74 <= '\u2FFF')||(LA38_74 >= '\u3001' && LA38_74 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_74=='\\') ) {s = 30;}
+
+ else if ( (LA38_74=='+') ) {s = 32;}
+
+ else if ( (LA38_74=='*'||LA38_74=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 20 :
+ int LA38_58 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_58=='\"') ) {s = 59;}
+
+ else if ( (LA38_58=='\\') ) {s = 37;}
+
+ else if ( ((LA38_58 >= '\u0000' && LA38_58 <= '!')||(LA38_58 >= '#' && LA38_58 <= ')')||(LA38_58 >= '+' && LA38_58 <= '>')||(LA38_58 >= '@' && LA38_58 <= '[')||(LA38_58 >= ']' && LA38_58 <= '\uFFFF')) ) {s = 38;}
+
+ else if ( (LA38_58=='*'||LA38_58=='?') ) {s = 39;}
+
+ if ( s>=0 ) return s;
+ break;
+ case 21 :
+ int LA38_55 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_55 >= '0' && LA38_55 <= '9')) ) {s = 66;}
+
+ else if ( ((LA38_55 >= '\u0000' && LA38_55 <= '\b')||(LA38_55 >= '\u000B' && LA38_55 <= '\f')||(LA38_55 >= '\u000E' && LA38_55 <= '\u001F')||(LA38_55 >= '#' && LA38_55 <= '&')||LA38_55==','||(LA38_55 >= '.' && LA38_55 <= '/')||(LA38_55 >= ';' && LA38_55 <= '>')||(LA38_55 >= '@' && LA38_55 <= 'Z')||(LA38_55 >= '_' && LA38_55 <= 'z')||LA38_55=='|'||(LA38_55 >= '\u007F' && LA38_55 <= '\u2FFF')||(LA38_55 >= '\u3001' && LA38_55 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_55=='\\') ) {s = 30;}
+
+ else if ( (LA38_55=='-') ) {s = 31;}
+
+ else if ( (LA38_55=='+') ) {s = 32;}
+
+ else if ( (LA38_55=='*'||LA38_55=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 22 :
+ int LA38_76 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_76 >= '0' && LA38_76 <= '9')) ) {s = 77;}
+
+ else if ( ((LA38_76 >= '\u0000' && LA38_76 <= '\b')||(LA38_76 >= '\u000B' && LA38_76 <= '\f')||(LA38_76 >= '\u000E' && LA38_76 <= '\u001F')||(LA38_76 >= '#' && LA38_76 <= '&')||LA38_76==','||(LA38_76 >= '.' && LA38_76 <= '/')||(LA38_76 >= ';' && LA38_76 <= '>')||(LA38_76 >= '@' && LA38_76 <= 'Z')||(LA38_76 >= '_' && LA38_76 <= 'z')||LA38_76=='|'||(LA38_76 >= '\u007F' && LA38_76 <= '\u2FFF')||(LA38_76 >= '\u3001' && LA38_76 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_76=='\\') ) {s = 30;}
+
+ else if ( (LA38_76=='-') ) {s = 31;}
+
+ else if ( (LA38_76=='+') ) {s = 32;}
+
+ else if ( (LA38_76=='*'||LA38_76=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 23 :
+ int LA38_62 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_62 >= '\u0000' && LA38_62 <= '\b')||(LA38_62 >= '\u000B' && LA38_62 <= '\f')||(LA38_62 >= '\u000E' && LA38_62 <= '\u001F')||(LA38_62 >= '#' && LA38_62 <= '&')||LA38_62==','||(LA38_62 >= '.' && LA38_62 <= '9')||(LA38_62 >= ';' && LA38_62 <= '>')||(LA38_62 >= '@' && LA38_62 <= 'Z')||(LA38_62 >= '_' && LA38_62 <= 'z')||LA38_62=='|'||(LA38_62 >= '\u007F' && LA38_62 <= '\u2FFF')||(LA38_62 >= '\u3001' && LA38_62 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_62=='\\') ) {s = 30;}
+
+ else if ( (LA38_62=='-') ) {s = 31;}
+
+ else if ( (LA38_62=='+') ) {s = 32;}
+
+ else if ( (LA38_62=='*'||LA38_62=='?') ) {s = 33;}
+
+ else s = 68;
+
+ if ( s>=0 ) return s;
+ break;
+ case 24 :
+ int LA38_44 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_44 >= '\u0000' && LA38_44 <= '\b')||(LA38_44 >= '\u000B' && LA38_44 <= '\f')||(LA38_44 >= '\u000E' && LA38_44 <= '\u001F')||(LA38_44 >= '#' && LA38_44 <= '&')||LA38_44==','||(LA38_44 >= '.' && LA38_44 <= '9')||(LA38_44 >= ';' && LA38_44 <= '>')||(LA38_44 >= '@' && LA38_44 <= 'Z')||(LA38_44 >= '_' && LA38_44 <= 'z')||LA38_44=='|'||(LA38_44 >= '\u007F' && LA38_44 <= '\u2FFF')||(LA38_44 >= '\u3001' && LA38_44 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_44=='\\') ) {s = 30;}
+
+ else if ( (LA38_44=='-') ) {s = 31;}
+
+ else if ( (LA38_44=='+') ) {s = 32;}
+
+ else if ( (LA38_44=='*'||LA38_44=='?') ) {s = 33;}
+
+ else s = 43;
+
+ if ( s>=0 ) return s;
+ break;
+ case 25 :
+ int LA38_77 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_77 >= '0' && LA38_77 <= '9')) ) {s = 79;}
+
+ else if ( ((LA38_77 >= '\u0000' && LA38_77 <= '\b')||(LA38_77 >= '\u000B' && LA38_77 <= '\f')||(LA38_77 >= '\u000E' && LA38_77 <= '\u001F')||(LA38_77 >= '#' && LA38_77 <= '&')||LA38_77==','||(LA38_77 >= '.' && LA38_77 <= '/')||(LA38_77 >= ';' && LA38_77 <= '>')||(LA38_77 >= '@' && LA38_77 <= 'Z')||(LA38_77 >= '_' && LA38_77 <= 'z')||LA38_77=='|'||(LA38_77 >= '\u007F' && LA38_77 <= '\u2FFF')||(LA38_77 >= '\u3001' && LA38_77 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_77=='\\') ) {s = 30;}
+
+ else if ( (LA38_77=='-') ) {s = 31;}
+
+ else if ( (LA38_77=='+') ) {s = 32;}
+
+ else if ( (LA38_77=='*'||LA38_77=='?') ) {s = 33;}
+
+ else s = 78;
+
+ if ( s>=0 ) return s;
+ break;
+ case 26 :
+ int LA38_48 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_48=='T'||LA38_48=='t') ) {s = 62;}
+
+ else if ( ((LA38_48 >= '\u0000' && LA38_48 <= '\b')||(LA38_48 >= '\u000B' && LA38_48 <= '\f')||(LA38_48 >= '\u000E' && LA38_48 <= '\u001F')||(LA38_48 >= '#' && LA38_48 <= '&')||LA38_48==','||(LA38_48 >= '.' && LA38_48 <= '9')||(LA38_48 >= ';' && LA38_48 <= '>')||(LA38_48 >= '@' && LA38_48 <= 'S')||(LA38_48 >= 'U' && LA38_48 <= 'Z')||(LA38_48 >= '_' && LA38_48 <= 's')||(LA38_48 >= 'u' && LA38_48 <= 'z')||LA38_48=='|'||(LA38_48 >= '\u007F' && LA38_48 <= '\u2FFF')||(LA38_48 >= '\u3001' && LA38_48 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_48=='\\') ) {s = 30;}
+
+ else if ( (LA38_48=='-') ) {s = 31;}
+
+ else if ( (LA38_48=='+') ) {s = 32;}
+
+ else if ( (LA38_48=='*'||LA38_48=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 27 :
+ int LA38_72 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_72 >= '0' && LA38_72 <= '9')) ) {s = 76;}
+
+ else if ( ((LA38_72 >= '\u0000' && LA38_72 <= '\b')||(LA38_72 >= '\u000B' && LA38_72 <= '\f')||(LA38_72 >= '\u000E' && LA38_72 <= '\u001F')||(LA38_72 >= '#' && LA38_72 <= '&')||LA38_72==','||(LA38_72 >= '.' && LA38_72 <= '/')||(LA38_72 >= ';' && LA38_72 <= '>')||(LA38_72 >= '@' && LA38_72 <= 'Z')||(LA38_72 >= '_' && LA38_72 <= 'z')||LA38_72=='|'||(LA38_72 >= '\u007F' && LA38_72 <= '\u2FFF')||(LA38_72 >= '\u3001' && LA38_72 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_72=='\\') ) {s = 30;}
+
+ else if ( (LA38_72=='-') ) {s = 31;}
+
+ else if ( (LA38_72=='+') ) {s = 32;}
+
+ else if ( (LA38_72=='*'||LA38_72=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 28 :
+ int LA38_26 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_26 >= '\u0000' && LA38_26 <= '\b')||(LA38_26 >= '\u000B' && LA38_26 <= '\f')||(LA38_26 >= '\u000E' && LA38_26 <= '\u001F')||(LA38_26 >= '#' && LA38_26 <= '&')||LA38_26==','||(LA38_26 >= '.' && LA38_26 <= '9')||(LA38_26 >= ';' && LA38_26 <= '>')||(LA38_26 >= '@' && LA38_26 <= 'Z')||(LA38_26 >= '_' && LA38_26 <= 'z')||LA38_26=='|'||(LA38_26 >= '\u007F' && LA38_26 <= '\u2FFF')||(LA38_26 >= '\u3001' && LA38_26 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_26=='\\') ) {s = 30;}
+
+ else if ( (LA38_26=='-') ) {s = 31;}
+
+ else if ( (LA38_26=='+') ) {s = 32;}
+
+ else if ( (LA38_26=='*'||LA38_26=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 29 :
+ int LA38_69 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_69 >= '\u0000' && LA38_69 <= '\b')||(LA38_69 >= '\u000B' && LA38_69 <= '\f')||(LA38_69 >= '\u000E' && LA38_69 <= '\u001F')||(LA38_69 >= '#' && LA38_69 <= '&')||LA38_69==','||(LA38_69 >= '.' && LA38_69 <= '9')||(LA38_69 >= ';' && LA38_69 <= '>')||(LA38_69 >= '@' && LA38_69 <= 'Z')||(LA38_69 >= '_' && LA38_69 <= 'z')||LA38_69=='|'||(LA38_69 >= '\u007F' && LA38_69 <= '\u2FFF')||(LA38_69 >= '\u3001' && LA38_69 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_69=='\\') ) {s = 30;}
+
+ else if ( (LA38_69=='-') ) {s = 31;}
+
+ else if ( (LA38_69=='+') ) {s = 32;}
+
+ else if ( (LA38_69=='*'||LA38_69=='?') ) {s = 33;}
+
+ else s = 50;
+
+ if ( s>=0 ) return s;
+ break;
+ case 30 :
+ int LA38_63 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_63=='R'||LA38_63=='r') ) {s = 69;}
+
+ else if ( ((LA38_63 >= '\u0000' && LA38_63 <= '\b')||(LA38_63 >= '\u000B' && LA38_63 <= '\f')||(LA38_63 >= '\u000E' && LA38_63 <= '\u001F')||(LA38_63 >= '#' && LA38_63 <= '&')||LA38_63==','||(LA38_63 >= '.' && LA38_63 <= '9')||(LA38_63 >= ';' && LA38_63 <= '>')||(LA38_63 >= '@' && LA38_63 <= 'Q')||(LA38_63 >= 'S' && LA38_63 <= 'Z')||(LA38_63 >= '_' && LA38_63 <= 'q')||(LA38_63 >= 's' && LA38_63 <= 'z')||LA38_63=='|'||(LA38_63 >= '\u007F' && LA38_63 <= '\u2FFF')||(LA38_63 >= '\u3001' && LA38_63 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_63=='\\') ) {s = 30;}
+
+ else if ( (LA38_63=='-') ) {s = 31;}
+
+ else if ( (LA38_63=='+') ) {s = 32;}
+
+ else if ( (LA38_63=='*'||LA38_63=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 31 :
+ int LA38_56 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_56 >= '\u0000' && LA38_56 <= '\b')||(LA38_56 >= '\u000B' && LA38_56 <= '\f')||(LA38_56 >= '\u000E' && LA38_56 <= '\u001F')||(LA38_56 >= '#' && LA38_56 <= '&')||LA38_56==','||(LA38_56 >= '.' && LA38_56 <= '9')||(LA38_56 >= ';' && LA38_56 <= '>')||(LA38_56 >= '@' && LA38_56 <= 'Z')||(LA38_56 >= '_' && LA38_56 <= 'z')||LA38_56=='|'||(LA38_56 >= '\u007F' && LA38_56 <= '\u2FFF')||(LA38_56 >= '\u3001' && LA38_56 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_56=='\\') ) {s = 30;}
+
+ else if ( (LA38_56=='-') ) {s = 31;}
+
+ else if ( (LA38_56=='+') ) {s = 32;}
+
+ else if ( (LA38_56=='*'||LA38_56=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 32 :
+ int LA38_49 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_49=='A'||LA38_49=='a') ) {s = 63;}
+
+ else if ( ((LA38_49 >= '\u0000' && LA38_49 <= '\b')||(LA38_49 >= '\u000B' && LA38_49 <= '\f')||(LA38_49 >= '\u000E' && LA38_49 <= '\u001F')||(LA38_49 >= '#' && LA38_49 <= '&')||LA38_49==','||(LA38_49 >= '.' && LA38_49 <= '9')||(LA38_49 >= ';' && LA38_49 <= '>')||LA38_49=='@'||(LA38_49 >= 'B' && LA38_49 <= 'Z')||(LA38_49 >= '_' && LA38_49 <= '`')||(LA38_49 >= 'b' && LA38_49 <= 'z')||LA38_49=='|'||(LA38_49 >= '\u007F' && LA38_49 <= '\u2FFF')||(LA38_49 >= '\u3001' && LA38_49 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_49=='\\') ) {s = 30;}
+
+ else if ( (LA38_49=='-') ) {s = 31;}
+
+ else if ( (LA38_49=='+') ) {s = 32;}
+
+ else if ( (LA38_49=='*'||LA38_49=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 33 :
+ int LA38_71 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_71 >= '0' && LA38_71 <= '9')) ) {s = 76;}
+
+ else if ( ((LA38_71 >= '\u0000' && LA38_71 <= '\b')||(LA38_71 >= '\u000B' && LA38_71 <= '\f')||(LA38_71 >= '\u000E' && LA38_71 <= '\u001F')||(LA38_71 >= '#' && LA38_71 <= '&')||LA38_71==','||(LA38_71 >= '.' && LA38_71 <= '/')||(LA38_71 >= ';' && LA38_71 <= '>')||(LA38_71 >= '@' && LA38_71 <= 'Z')||(LA38_71 >= '_' && LA38_71 <= 'z')||LA38_71=='|'||(LA38_71 >= '\u007F' && LA38_71 <= '\u2FFF')||(LA38_71 >= '\u3001' && LA38_71 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_71=='\\') ) {s = 30;}
+
+ else if ( (LA38_71=='-') ) {s = 31;}
+
+ else if ( (LA38_71=='+') ) {s = 32;}
+
+ else if ( (LA38_71=='*'||LA38_71=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 34 :
+ int LA38_66 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_66 >= '0' && LA38_66 <= '9')) ) {s = 74;}
+
+ else if ( ((LA38_66 >= '.' && LA38_66 <= '/')) ) {s = 71;}
+
+ else if ( (LA38_66=='-') ) {s = 72;}
+
+ else if ( ((LA38_66 >= '\u0000' && LA38_66 <= '\b')||(LA38_66 >= '\u000B' && LA38_66 <= '\f')||(LA38_66 >= '\u000E' && LA38_66 <= '\u001F')||(LA38_66 >= '#' && LA38_66 <= '&')||LA38_66==','||(LA38_66 >= ';' && LA38_66 <= '>')||(LA38_66 >= '@' && LA38_66 <= 'Z')||(LA38_66 >= '_' && LA38_66 <= 'z')||LA38_66=='|'||(LA38_66 >= '\u007F' && LA38_66 <= '\u2FFF')||(LA38_66 >= '\u3001' && LA38_66 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_66=='\\') ) {s = 30;}
+
+ else if ( (LA38_66=='+') ) {s = 32;}
+
+ else if ( (LA38_66=='*'||LA38_66=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 35 :
+ int LA38_53 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_53=='.') ) {s = 51;}
+
+ else if ( ((LA38_53 >= '0' && LA38_53 <= '9')) ) {s = 65;}
+
+ else if ( (LA38_53=='/') ) {s = 54;}
+
+ else if ( (LA38_53=='-') ) {s = 55;}
+
+ else if ( ((LA38_53 >= '\u0000' && LA38_53 <= '\b')||(LA38_53 >= '\u000B' && LA38_53 <= '\f')||(LA38_53 >= '\u000E' && LA38_53 <= '\u001F')||(LA38_53 >= '#' && LA38_53 <= '&')||LA38_53==','||(LA38_53 >= ';' && LA38_53 <= '>')||(LA38_53 >= '@' && LA38_53 <= 'Z')||(LA38_53 >= '_' && LA38_53 <= 'z')||LA38_53=='|'||(LA38_53 >= '\u007F' && LA38_53 <= '\u2FFF')||(LA38_53 >= '\u3001' && LA38_53 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_53=='\\') ) {s = 30;}
+
+ else if ( (LA38_53=='+') ) {s = 32;}
+
+ else if ( (LA38_53=='*'||LA38_53=='?') ) {s = 33;}
+
+ else s = 52;
+
+ if ( s>=0 ) return s;
+ break;
+ case 36 :
+ int LA38_32 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_32 >= '\u0000' && LA38_32 <= '\b')||(LA38_32 >= '\u000B' && LA38_32 <= '\f')||(LA38_32 >= '\u000E' && LA38_32 <= '\u001F')||(LA38_32 >= '#' && LA38_32 <= '&')||LA38_32==','||(LA38_32 >= '.' && LA38_32 <= '9')||(LA38_32 >= ';' && LA38_32 <= '>')||(LA38_32 >= '@' && LA38_32 <= 'Z')||(LA38_32 >= '_' && LA38_32 <= 'z')||LA38_32=='|'||(LA38_32 >= '\u007F' && LA38_32 <= '\u2FFF')||(LA38_32 >= '\u3001' && LA38_32 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_32=='\\') ) {s = 30;}
+
+ else if ( (LA38_32=='-') ) {s = 31;}
+
+ else if ( (LA38_32=='+') ) {s = 32;}
+
+ else if ( (LA38_32=='*'||LA38_32=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 37 :
+ int LA38_57 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_57 >= '\u0000' && LA38_57 <= '\b')||(LA38_57 >= '\u000B' && LA38_57 <= '\f')||(LA38_57 >= '\u000E' && LA38_57 <= '\u001F')||(LA38_57 >= '#' && LA38_57 <= '&')||LA38_57==','||(LA38_57 >= '.' && LA38_57 <= '9')||(LA38_57 >= ';' && LA38_57 <= '>')||(LA38_57 >= '@' && LA38_57 <= 'Z')||(LA38_57 >= '_' && LA38_57 <= 'z')||LA38_57=='|'||(LA38_57 >= '\u007F' && LA38_57 <= '\u2FFF')||(LA38_57 >= '\u3001' && LA38_57 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_57=='\\') ) {s = 30;}
+
+ else if ( (LA38_57=='-') ) {s = 31;}
+
+ else if ( (LA38_57=='+') ) {s = 32;}
+
+ else if ( (LA38_57=='*'||LA38_57=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 38 :
+ int LA38_31 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_31 >= '\u0000' && LA38_31 <= '\b')||(LA38_31 >= '\u000B' && LA38_31 <= '\f')||(LA38_31 >= '\u000E' && LA38_31 <= '\u001F')||(LA38_31 >= '#' && LA38_31 <= '&')||LA38_31==','||(LA38_31 >= '.' && LA38_31 <= '9')||(LA38_31 >= ';' && LA38_31 <= '>')||(LA38_31 >= '@' && LA38_31 <= 'Z')||(LA38_31 >= '_' && LA38_31 <= 'z')||LA38_31=='|'||(LA38_31 >= '\u007F' && LA38_31 <= '\u2FFF')||(LA38_31 >= '\u3001' && LA38_31 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_31=='\\') ) {s = 30;}
+
+ else if ( (LA38_31=='-') ) {s = 31;}
+
+ else if ( (LA38_31=='+') ) {s = 32;}
+
+ else if ( (LA38_31=='*'||LA38_31=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 39 :
+ int LA38_42 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_42=='D'||LA38_42=='d') ) {s = 61;}
+
+ else if ( ((LA38_42 >= '\u0000' && LA38_42 <= '\b')||(LA38_42 >= '\u000B' && LA38_42 <= '\f')||(LA38_42 >= '\u000E' && LA38_42 <= '\u001F')||(LA38_42 >= '#' && LA38_42 <= '&')||LA38_42==','||(LA38_42 >= '.' && LA38_42 <= '9')||(LA38_42 >= ';' && LA38_42 <= '>')||(LA38_42 >= '@' && LA38_42 <= 'C')||(LA38_42 >= 'E' && LA38_42 <= 'Z')||(LA38_42 >= '_' && LA38_42 <= 'c')||(LA38_42 >= 'e' && LA38_42 <= 'z')||LA38_42=='|'||(LA38_42 >= '\u007F' && LA38_42 <= '\u2FFF')||(LA38_42 >= '\u3001' && LA38_42 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_42=='\\') ) {s = 30;}
+
+ else if ( (LA38_42=='-') ) {s = 31;}
+
+ else if ( (LA38_42=='+') ) {s = 32;}
+
+ else if ( (LA38_42=='*'||LA38_42=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 40 :
+ int LA38_19 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_19=='&') ) {s = 44;}
+
+ else if ( ((LA38_19 >= '\u0000' && LA38_19 <= '\b')||(LA38_19 >= '\u000B' && LA38_19 <= '\f')||(LA38_19 >= '\u000E' && LA38_19 <= '\u001F')||(LA38_19 >= '#' && LA38_19 <= '%')||LA38_19==','||(LA38_19 >= '.' && LA38_19 <= '9')||(LA38_19 >= ';' && LA38_19 <= '>')||(LA38_19 >= '@' && LA38_19 <= 'Z')||(LA38_19 >= '_' && LA38_19 <= 'z')||LA38_19=='|'||(LA38_19 >= '\u007F' && LA38_19 <= '\u2FFF')||(LA38_19 >= '\u3001' && LA38_19 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_19=='\\') ) {s = 30;}
+
+ else if ( (LA38_19=='-') ) {s = 31;}
+
+ else if ( (LA38_19=='+') ) {s = 32;}
+
+ else if ( (LA38_19=='*'||LA38_19=='?') ) {s = 33;}
+
+ else s = 43;
+
+ if ( s>=0 ) return s;
+ break;
+ case 41 :
+ int LA38_21 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_21=='|') ) {s = 47;}
+
+ else if ( ((LA38_21 >= '\u0000' && LA38_21 <= '\b')||(LA38_21 >= '\u000B' && LA38_21 <= '\f')||(LA38_21 >= '\u000E' && LA38_21 <= '\u001F')||(LA38_21 >= '#' && LA38_21 <= '&')||LA38_21==','||(LA38_21 >= '.' && LA38_21 <= '9')||(LA38_21 >= ';' && LA38_21 <= '>')||(LA38_21 >= '@' && LA38_21 <= 'Z')||(LA38_21 >= '_' && LA38_21 <= 'z')||(LA38_21 >= '\u007F' && LA38_21 <= '\u2FFF')||(LA38_21 >= '\u3001' && LA38_21 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_21=='\\') ) {s = 30;}
+
+ else if ( (LA38_21=='-') ) {s = 31;}
+
+ else if ( (LA38_21=='+') ) {s = 32;}
+
+ else if ( (LA38_21=='*'||LA38_21=='?') ) {s = 33;}
+
+ else s = 46;
+
+ if ( s>=0 ) return s;
+ break;
+ case 42 :
+ int LA38_80 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_80 >= '\u0000' && LA38_80 <= '\b')||(LA38_80 >= '\u000B' && LA38_80 <= '\f')||(LA38_80 >= '\u000E' && LA38_80 <= '\u001F')||(LA38_80 >= '#' && LA38_80 <= '&')||LA38_80==','||(LA38_80 >= '.' && LA38_80 <= '9')||(LA38_80 >= ';' && LA38_80 <= '>')||(LA38_80 >= '@' && LA38_80 <= 'Z')||(LA38_80 >= '_' && LA38_80 <= 'z')||LA38_80=='|'||(LA38_80 >= '\u007F' && LA38_80 <= '\u2FFF')||(LA38_80 >= '\u3001' && LA38_80 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_80=='\\') ) {s = 30;}
+
+ else if ( (LA38_80=='-') ) {s = 31;}
+
+ else if ( (LA38_80=='+') ) {s = 32;}
+
+ else if ( (LA38_80=='*'||LA38_80=='?') ) {s = 33;}
+
+ else s = 78;
+
+ if ( s>=0 ) return s;
+ break;
+ case 43 :
+ int LA38_75 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_75 >= '0' && LA38_75 <= '9')) ) {s = 75;}
+
+ else if ( ((LA38_75 >= '\u0000' && LA38_75 <= '\b')||(LA38_75 >= '\u000B' && LA38_75 <= '\f')||(LA38_75 >= '\u000E' && LA38_75 <= '\u001F')||(LA38_75 >= '#' && LA38_75 <= '&')||LA38_75==','||(LA38_75 >= '.' && LA38_75 <= '/')||(LA38_75 >= ';' && LA38_75 <= '>')||(LA38_75 >= '@' && LA38_75 <= 'Z')||(LA38_75 >= '_' && LA38_75 <= 'z')||LA38_75=='|'||(LA38_75 >= '\u007F' && LA38_75 <= '\u2FFF')||(LA38_75 >= '\u3001' && LA38_75 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_75=='\\') ) {s = 30;}
+
+ else if ( (LA38_75=='-') ) {s = 31;}
+
+ else if ( (LA38_75=='+') ) {s = 32;}
+
+ else if ( (LA38_75=='*'||LA38_75=='?') ) {s = 33;}
+
+ else s = 52;
+
+ if ( s>=0 ) return s;
+ break;
+ case 44 :
+ int LA38_70 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_70 >= '0' && LA38_70 <= '9')) ) {s = 75;}
+
+ else if ( ((LA38_70 >= '.' && LA38_70 <= '/')) ) {s = 71;}
+
+ else if ( (LA38_70=='-') ) {s = 72;}
+
+ else if ( ((LA38_70 >= '\u0000' && LA38_70 <= '\b')||(LA38_70 >= '\u000B' && LA38_70 <= '\f')||(LA38_70 >= '\u000E' && LA38_70 <= '\u001F')||(LA38_70 >= '#' && LA38_70 <= '&')||LA38_70==','||(LA38_70 >= ';' && LA38_70 <= '>')||(LA38_70 >= '@' && LA38_70 <= 'Z')||(LA38_70 >= '_' && LA38_70 <= 'z')||LA38_70=='|'||(LA38_70 >= '\u007F' && LA38_70 <= '\u2FFF')||(LA38_70 >= '\u3001' && LA38_70 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_70=='\\') ) {s = 30;}
+
+ else if ( (LA38_70=='+') ) {s = 32;}
+
+ else if ( (LA38_70=='*'||LA38_70=='?') ) {s = 33;}
+
+ else s = 52;
+
+ if ( s>=0 ) return s;
+ break;
+ case 45 :
+ int LA38_9 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_9 >= '\u0000' && LA38_9 <= '\b')||(LA38_9 >= '\u000B' && LA38_9 <= '\f')||(LA38_9 >= '\u000E' && LA38_9 <= '\u001F')||(LA38_9 >= '#' && LA38_9 <= '&')||(LA38_9 >= '+' && LA38_9 <= '9')||(LA38_9 >= ';' && LA38_9 <= '>')||(LA38_9 >= '@' && LA38_9 <= 'Z')||LA38_9=='\\'||(LA38_9 >= '_' && LA38_9 <= 'z')||LA38_9=='|'||(LA38_9 >= '\u007F' && LA38_9 <= '\u2FFF')||(LA38_9 >= '\u3001' && LA38_9 <= '\uFFFF')) ) {s = 33;}
+
+ else s = 34;
+
+ if ( s>=0 ) return s;
+ break;
+ case 46 :
+ int LA38_15 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_15=='\\') ) {s = 37;}
+
+ else if ( ((LA38_15 >= '\u0000' && LA38_15 <= '!')||(LA38_15 >= '#' && LA38_15 <= ')')||(LA38_15 >= '+' && LA38_15 <= '>')||(LA38_15 >= '@' && LA38_15 <= '[')||(LA38_15 >= ']' && LA38_15 <= '\uFFFF')) ) {s = 38;}
+
+ else if ( (LA38_15=='*'||LA38_15=='?') ) {s = 39;}
+
+ else s = 36;
+
+ if ( s>=0 ) return s;
+ break;
+ case 47 :
+ int LA38_40 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_40 >= '\u0000' && LA38_40 <= '\b')||(LA38_40 >= '\u000B' && LA38_40 <= '\f')||(LA38_40 >= '\u000E' && LA38_40 <= '\u001F')||(LA38_40 >= '#' && LA38_40 <= '&')||LA38_40==','||(LA38_40 >= '.' && LA38_40 <= '9')||(LA38_40 >= ';' && LA38_40 <= '>')||(LA38_40 >= '@' && LA38_40 <= 'Z')||(LA38_40 >= '_' && LA38_40 <= 'z')||LA38_40=='|'||(LA38_40 >= '\u007F' && LA38_40 <= '\u2FFF')||(LA38_40 >= '\u3001' && LA38_40 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_40=='\\') ) {s = 30;}
+
+ else if ( (LA38_40=='-') ) {s = 31;}
+
+ else if ( (LA38_40=='+') ) {s = 32;}
+
+ else if ( (LA38_40=='*'||LA38_40=='?') ) {s = 33;}
+
+ else s = 60;
+
+ if ( s>=0 ) return s;
+ break;
+ case 48 :
+ int LA38_47 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_47 >= '\u0000' && LA38_47 <= '\b')||(LA38_47 >= '\u000B' && LA38_47 <= '\f')||(LA38_47 >= '\u000E' && LA38_47 <= '\u001F')||(LA38_47 >= '#' && LA38_47 <= '&')||LA38_47==','||(LA38_47 >= '.' && LA38_47 <= '9')||(LA38_47 >= ';' && LA38_47 <= '>')||(LA38_47 >= '@' && LA38_47 <= 'Z')||(LA38_47 >= '_' && LA38_47 <= 'z')||LA38_47=='|'||(LA38_47 >= '\u007F' && LA38_47 <= '\u2FFF')||(LA38_47 >= '\u3001' && LA38_47 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_47=='\\') ) {s = 30;}
+
+ else if ( (LA38_47=='-') ) {s = 31;}
+
+ else if ( (LA38_47=='+') ) {s = 32;}
+
+ else if ( (LA38_47=='*'||LA38_47=='?') ) {s = 33;}
+
+ else s = 46;
+
+ if ( s>=0 ) return s;
+ break;
+ case 49 :
+ int LA38_51 = input.LA(1);
+
+ s = -1;
+ if ( ((LA38_51 >= '0' && LA38_51 <= '9')) ) {s = 64;}
+
+ else if ( ((LA38_51 >= '\u0000' && LA38_51 <= '\b')||(LA38_51 >= '\u000B' && LA38_51 <= '\f')||(LA38_51 >= '\u000E' && LA38_51 <= '\u001F')||(LA38_51 >= '#' && LA38_51 <= '&')||LA38_51==','||(LA38_51 >= '.' && LA38_51 <= '/')||(LA38_51 >= ';' && LA38_51 <= '>')||(LA38_51 >= '@' && LA38_51 <= 'Z')||(LA38_51 >= '_' && LA38_51 <= 'z')||LA38_51=='|'||(LA38_51 >= '\u007F' && LA38_51 <= '\u2FFF')||(LA38_51 >= '\u3001' && LA38_51 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_51=='\\') ) {s = 30;}
+
+ else if ( (LA38_51=='-') ) {s = 31;}
+
+ else if ( (LA38_51=='+') ) {s = 32;}
+
+ else if ( (LA38_51=='*'||LA38_51=='?') ) {s = 33;}
+
+ else s = 41;
+
+ if ( s>=0 ) return s;
+ break;
+ case 50 :
+ int LA38_22 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_22=='O'||LA38_22=='o') ) {s = 48;}
+
+ else if ( (LA38_22=='E'||LA38_22=='e') ) {s = 49;}
+
+ else if ( ((LA38_22 >= '\u0000' && LA38_22 <= '\b')||(LA38_22 >= '\u000B' && LA38_22 <= '\f')||(LA38_22 >= '\u000E' && LA38_22 <= '\u001F')||(LA38_22 >= '#' && LA38_22 <= '&')||LA38_22==','||(LA38_22 >= '.' && LA38_22 <= '9')||(LA38_22 >= ';' && LA38_22 <= '>')||(LA38_22 >= '@' && LA38_22 <= 'D')||(LA38_22 >= 'F' && LA38_22 <= 'N')||(LA38_22 >= 'P' && LA38_22 <= 'Z')||(LA38_22 >= '_' && LA38_22 <= 'd')||(LA38_22 >= 'f' && LA38_22 <= 'n')||(LA38_22 >= 'p' && LA38_22 <= 'z')||LA38_22=='|'||(LA38_22 >= '\u007F' && LA38_22 <= '\u2FFF')||(LA38_22 >= '\u3001' && LA38_22 <= '\uFFFF')) ) {s = 29;}
+
+ else if ( (LA38_22=='\\') ) {s = 30;}
+
+ else if ( (LA38_22=='-') ) {s = 31;}
+
+ else if ( (LA38_22=='+') ) {s = 32;}
+
+ else if ( (LA38_22=='*'||LA38_22=='?') ) {s = 33;}
+
+ else s = 50;
+
+ if ( s>=0 ) return s;
+ break;
+ case 51 :
+ int LA38_10 = input.LA(1);
+
+ s = -1;
+ if ( (LA38_10=='?') ) {s = 10;}
+
+ else if ( ((LA38_10 >= '\u0000' && LA38_10 <= '\b')||(LA38_10 >= '\u000B' && LA38_10 <= '\f')||(LA38_10 >= '\u000E' && LA38_10 <= '\u001F')||(LA38_10 >= '#' && LA38_10 <= '&')||(LA38_10 >= '+' && LA38_10 <= '9')||(LA38_10 >= ';' && LA38_10 <= '>')||(LA38_10 >= '@' && LA38_10 <= 'Z')||LA38_10=='\\'||(LA38_10 >= '_' && LA38_10 <= 'z')||LA38_10=='|'||(LA38_10 >= '\u007F' && LA38_10 <= '\u2FFF')||(LA38_10 >= '\u3001' && LA38_10 <= '\uFFFF')) ) {s = 33;}
+
+ else s = 35;
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 38, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+
+ }
+
+
+}
\ No newline at end of file
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryNodeProcessorPipeline.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryNodeProcessorPipeline.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/AqpStandardQueryNodeProcessorPipeline.java (revision 0)
@@ -0,0 +1,141 @@
+package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.processors.NoChildOptimizationQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorPipeline;
+import org.apache.lucene.queryparser.flexible.core.processors.RemoveDeletedQueryNodesProcessor;
+import org.apache.lucene.queryparser.flexible.standard.builders.StandardQueryTreeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.standard.parser.StandardSyntaxParser;
+import org.apache.lucene.queryparser.flexible.standard.processors.AllowLeadingWildcardProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.AnalyzerQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.BooleanSingleChildOptimizationQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.BoostQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.DefaultPhraseSlopQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.FuzzyQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.LowercaseExpandedTermsQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.MatchAllDocsQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.MultiFieldQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.MultiTermRewriteMethodProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.NumericQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.NumericRangeQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.OpenRangeQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.PhraseSlopQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.RemoveEmptyNonLeafQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.TermRangeQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.WildcardQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpBOOSTProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpCLAUSEProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpDEFOPProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpFIELDProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpFUZZYProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpFuzzyModifierProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpGroupQueryOptimizerProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpMODIFIERProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpOPERATORProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpOptimizationProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpQANYTHINGProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpQNORMALProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpQPHRASEProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpQPHRASETRUNCProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpQRANGEEXProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpQRANGEINProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpQTRUNCATEDProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpTMODIFIERProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.processors.AqpTreeRewriteProcessor;
+import org.apache.lucene.search.Query;
+
+/**
+ * This is based on the standard/processors
+ *
+ * This pipeline has all the processors needed to process a query node tree,
+ * generated by {@link StandardSyntaxParser}, already assembled.
+ *
+ * The order they are assembled affects the results.
+ *
+ * This processor pipeline was designed to work with
+ * {@link StandardQueryConfigHandler}.
+ *
+ * The result query node tree can be used to build a {@link Query} object using
+ * {@link StandardQueryTreeBuilder}.
+ *
+ * @see StandardQueryTreeBuilder
+ * @see StandardQueryConfigHandler
+ * @see StandardSyntaxParser
+ */
+public class AqpStandardQueryNodeProcessorPipeline extends
+ QueryNodeProcessorPipeline {
+
+ public AqpStandardQueryNodeProcessorPipeline(QueryConfigHandler queryConfig) {
+ super(queryConfig);
+
+ add(new AqpDEFOPProcessor());
+ add(new AqpTreeRewriteProcessor());
+
+ add(new AqpCLAUSEProcessor());
+ add(new AqpMODIFIERProcessor());
+
+ add(new AqpOPERATORProcessor());
+ add(new AqpTMODIFIERProcessor());
+ add(new AqpBOOSTProcessor());
+ add(new AqpFUZZYProcessor());
+
+ add(new AqpQRANGEINProcessor());
+ add(new AqpQRANGEEXProcessor());
+ add(new AqpQNORMALProcessor());
+ add(new AqpQPHRASEProcessor());
+ add(new AqpQPHRASETRUNCProcessor());
+ add(new AqpQTRUNCATEDProcessor());
+ add(new AqpQRANGEINProcessor());
+ add(new AqpQRANGEEXProcessor());
+ add(new AqpQANYTHINGProcessor());
+ add(new AqpFIELDProcessor());
+
+ add(new AqpFuzzyModifierProcessor());
+
+ // TODO: remove the processors which are not needed
+ // these were the standard guys before AQP ones were added
+
+ add(new WildcardQueryNodeProcessor());
+ add(new MultiFieldQueryNodeProcessor());
+ add(new FuzzyQueryNodeProcessor());
+ add(new MatchAllDocsQueryNodeProcessor());
+ add(new OpenRangeQueryNodeProcessor());
+ add(new NumericQueryNodeProcessor());
+ add(new NumericRangeQueryNodeProcessor());
+ add(new LowercaseExpandedTermsQueryNodeProcessor());
+ add(new TermRangeQueryNodeProcessor());
+ add(new AllowLeadingWildcardProcessor());
+ add(new AnalyzerQueryNodeProcessor());
+ add(new PhraseSlopQueryNodeProcessor());
+ // add(new GroupQueryNodeProcessor());
+ add(new NoChildOptimizationQueryNodeProcessor());
+ add(new RemoveDeletedQueryNodesProcessor());
+ add(new RemoveEmptyNonLeafQueryNodeProcessor());
+ add(new BooleanSingleChildOptimizationQueryNodeProcessor());
+ add(new DefaultPhraseSlopQueryNodeProcessor());
+ add(new BoostQueryNodeProcessor());
+ add(new MultiTermRewriteMethodProcessor());
+
+ add(new AqpOptimizationProcessor());
+ add(new AqpGroupQueryOptimizerProcessor());
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammar.tokens
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammar.tokens (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammar.tokens (revision 0)
@@ -0,0 +1,51 @@
+T__53=53
+AMPER=4
+AND=5
+ATOM=6
+BOOST=7
+CARAT=8
+CLAUSE=9
+COLON=10
+DATE_TOKEN=11
+DQUOTE=12
+ESC_CHAR=13
+FIELD=14
+FUZZY=15
+INT=16
+LBRACK=17
+LCURLY=18
+LPAREN=19
+MINUS=20
+MODIFIER=21
+NEAR=22
+NOT=23
+NUMBER=24
+OPERATOR=25
+OR=26
+PHRASE=27
+PHRASE_ANYTHING=28
+PLUS=29
+QANYTHING=30
+QDATE=31
+QMARK=32
+QNORMAL=33
+QPHRASE=34
+QPHRASETRUNC=35
+QRANGEEX=36
+QRANGEIN=37
+QTRUNCATED=38
+RBRACK=39
+RCURLY=40
+RPAREN=41
+SQUOTE=42
+STAR=43
+TERM_CHAR=44
+TERM_NORMAL=45
+TERM_START_CHAR=46
+TERM_TRUNCATED=47
+TILDE=48
+TMODIFIER=49
+TO=50
+VBAR=51
+WS=52
+'/'=53
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarSyntaxParser.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarSyntaxParser.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammarSyntaxParser.java (revision 0)
@@ -0,0 +1,85 @@
+
+
+package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+
+/**
+ * Automatically generated SyntaxParser wrapper built by ant
+ * from the grammar source: /dvt/workspace/lucene_4x/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/parser/StandardLuceneGrammar.g
+ *
+ * YOUR CHANGES WILL BE OVERWRITTEN BY NEXT ANT RUN!
+ */
+
+import org.antlr.runtime.ANTLRStringStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.TokenStream;
+import org.apache.lucene.queryparser.flexible.messages.Message;
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpCommonTree;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpCommonTreeAdaptor;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeParseException;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+
+import org.apache.lucene.queryparser.flexible.aqp.AqpSyntaxParser;
+import org.apache.lucene.queryparser.flexible.aqp.AqpSyntaxParserAbstract;
+import org.apache.lucene.queryparser.flexible.aqp.parser.StandardLuceneGrammarLexer;
+import org.apache.lucene.queryparser.flexible.aqp.parser.StandardLuceneGrammarParser;
+
+
+public class StandardLuceneGrammarSyntaxParser extends AqpSyntaxParserAbstract {
+ public AqpSyntaxParser initializeGrammar(String grammarName)
+ throws QueryNodeParseException {
+ return this;
+ }
+
+ public TokenStream getTokenStream(CharSequence input) {
+ ANTLRStringStream in = new ANTLRStringStream(input.toString());
+ StandardLuceneGrammarLexer lexer = new StandardLuceneGrammarLexer(in);
+ CommonTokenStream tokens = new CommonTokenStream(lexer);
+ return tokens;
+ }
+
+ public QueryNode parseTokenStream(TokenStream tokens, CharSequence query,
+ CharSequence field) throws QueryNodeParseException {
+ StandardLuceneGrammarParser parser = new StandardLuceneGrammarParser(tokens);
+ StandardLuceneGrammarParser.mainQ_return returnValue;
+
+ AqpCommonTreeAdaptor adaptor = new AqpCommonTreeAdaptor(parser.getTokenNames());
+ parser.setTreeAdaptor(adaptor);
+
+ AqpCommonTree astTree;
+
+ try {
+ returnValue = parser.mainQ();
+ // this prevents parser from recovering, however it can also interfere
+ // with custom error handling (if present inside the grammar)
+ if (parser.getNumberOfSyntaxErrors() > 0) {
+ throw new Exception("The parser reported a syntax error, antlrqueryparser hates errors!");
+ }
+ astTree = (AqpCommonTree) returnValue.getTree();
+ return astTree.toQueryNodeTree();
+ } catch (RecognitionException e) {
+ throw new QueryNodeParseException(new MessageImpl(query + " " + parser.getErrorMessage(e, parser.getTokenNames())));
+ } catch (Exception e) {
+ Message message = new MessageImpl(
+ QueryParserMessages.INVALID_SYNTAX_CANNOT_PARSE, query,
+ e.getMessage());
+ QueryNodeParseException ee = new QueryNodeParseException(e);
+ ee.setQuery(query);
+ ee.setNonLocalizedMessage(message);
+ throw ee;
+ } catch (Error e) {
+ Message message = new MessageImpl(
+ QueryParserMessages.INVALID_SYNTAX_CANNOT_PARSE, query,
+ e.getMessage());
+ QueryNodeParseException ee = new QueryNodeParseException(e);
+ ee.setQuery(query);
+ ee.setNonLocalizedMessage(message);
+ throw ee;
+ }
+ }
+}
+
+
\ No newline at end of file
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpDebuggingQueryNodeProcessorPipeline.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpDebuggingQueryNodeProcessorPipeline.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpDebuggingQueryNodeProcessorPipeline.java (revision 0)
@@ -0,0 +1,118 @@
+package org.apache.lucene.queryparser.flexible.aqp.util;
+
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.parser.EscapeQuerySyntax;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorPipeline;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+
+/**
+ * This class is used for debugging purposes (eg. from unittests
+ * or when the query parser was invoked with debuqQuery=true)
+ *
+ * The debugging output shows the stage of the AST tree after
+ * each processing stage completed. Including the changes in
+ * the internal 'map'.
+ *
+ */
+public class AqpDebuggingQueryNodeProcessorPipeline extends
+ QueryNodeProcessorPipeline {
+
+ EscapeQuerySyntax escaper = new EscapeQuerySyntaxImpl();
+ private Class originalProcessorClass;
+
+ public AqpDebuggingQueryNodeProcessorPipeline(QueryConfigHandler queryConfig,
+ Class originalClass) {
+ super(queryConfig);
+ originalProcessorClass = originalClass;
+ }
+
+ public QueryNode process(QueryNode queryTree) throws QueryNodeException {
+ String oldVal = null;
+ String newVal = null;
+ String oldMap = null;
+ String newMap = null;
+
+ oldVal = queryTree.toString();
+ oldMap = harvestTagMap(queryTree);
+ newMap = oldMap;
+
+ int i = 1;
+ System.out.println(" 0. starting");
+ System.out.println("--------------------------------------------");
+ System.out.println(oldVal);
+
+ Iterator it = this.iterator();
+
+ QueryNodeProcessor processor;
+ while (it.hasNext()) {
+ processor = it.next();
+
+ System.out.println(" " + i + ". step "
+ + processor.getClass().toString());
+ queryTree = processor.process(queryTree);
+ newVal = queryTree.toString();
+ newMap = harvestTagMap(queryTree);
+ System.out.println(" Tree changed: "
+ + (newVal.equals(oldVal) ? "NO" : "YES"));
+
+ if (!newMap.equals(oldMap)) {
+ System.out.println(" Tags changed: YES");
+ System.out.println(" -----------------");
+ System.out.println(newMap);
+ System.out.println(" -----------------");
+ }
+
+ System.out.println("--------------------------------------------");
+
+ System.out.println(newVal.equals(oldVal) ? "" : newVal);
+
+ oldVal = newVal;
+ oldMap = newMap;
+ i += 1;
+ }
+
+ System.out.println("");
+ System.out.println("final result:");
+ System.out.println("--------------------------------------------");
+ System.out.println(queryTree.toString());
+ return queryTree;
+
+ }
+
+ private String harvestTagMap(QueryNode queryTree) {
+ StringBuffer output = new StringBuffer();
+ harvestTagMapDesc(queryTree, output, 0);
+ return output.toString().trim();
+ }
+
+ private void harvestTagMapDesc(QueryNode queryTree, StringBuffer output,
+ int level) {
+ if (queryTree.getTagMap().size() > 0) {
+ for (int i = 0; i < level; i++) {
+ output.append("");
+ }
+ output.append(queryTree.toQueryString(escaper));
+ output.append(" : ");
+ // output.append(queryTree.getClass().getSimpleName());
+ // output.append(" : ");
+ output.append(queryTree.getTagMap());
+ output.append("\n");
+ }
+ List children = queryTree.getChildren();
+ if (children != null) {
+ for (QueryNode child : queryTree.getChildren()) {
+ harvestTagMapDesc(child, output, level + 1);
+ }
+ }
+ }
+
+ public Class getOriginalProcessorClass() {
+ return originalProcessorClass;
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpUtils.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpUtils.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpUtils.java (revision 0)
@@ -0,0 +1,57 @@
+package org.apache.lucene.queryparser.flexible.aqp.util;
+
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+public class AqpUtils {
+
+ public enum Modifier {
+ PLUS, MINUS, UNKNOWN;
+ }
+
+ public static String getFirstChildInputString(QueryNode node) {
+ return getFirstChildInputString((AqpANTLRNode) node);
+ }
+
+ public static String getFirstChildInputString(AqpANTLRNode node) {
+ if (node != null && node.getChildren() != null) {
+ return ((AqpANTLRNode) node.getChildren().get(0)).getTokenInput();
+ }
+ return null;
+ }
+
+ public static Float getFirstChildInputFloat(AqpANTLRNode node) {
+ if (node != null && node.getChildren() != null) {
+ return Float.valueOf(((AqpANTLRNode) node.getChildren().get(0))
+ .getTokenInput());
+ }
+ return null;
+ }
+
+ public static Modifier getFirstChildInputModifier(AqpANTLRNode node) {
+ if (node != null && node.getChildren() != null) {
+ String val = ((AqpANTLRNode) node.getChildren().get(0)).getTokenName();
+ if (val.equals("PLUS")) {
+ return Modifier.PLUS;
+ } else if (val.equals("MINUS")) {
+ return Modifier.MINUS;
+ } else {
+ return Modifier.UNKNOWN;
+ }
+ }
+ return null;
+ }
+
+ public static void applyFieldToAllChildren(String field, QueryNode node) {
+
+ if (node instanceof FieldQueryNode) {
+ ((FieldQueryNode) node).setField(field);
+ }
+ if (node.getChildren() != null) {
+ for (QueryNode child : node.getChildren()) {
+ applyFieldToAllChildren(field, child);
+ }
+ }
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpQueryParserUtil.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpQueryParserUtil.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpQueryParserUtil.java (revision 0)
@@ -0,0 +1,199 @@
+package org.apache.lucene.queryparser.flexible.aqp.util;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.queryparser.flexible.aqp.AqpQueryParser;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.Query;
+
+/**
+ * This class defines utility methods to (help) parse query strings into
+ * {@link Query} objects.
+ */
+final public class AqpQueryParserUtil {
+
+ /**
+ * Parses a query which searches on the fields specified.
+ *
+ * If x fields are specified, this effectively constructs:
+ *
+ *
+ * <code>
+ * (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx)
+ * </code>
+ *
+ *
+ * @param queries
+ * Queries strings to parse
+ * @param fields
+ * Fields to search on
+ * @param analyzer
+ * Analyzer to use
+ * @throws IllegalArgumentException
+ * if the length of the queries array differs from the length of the
+ * fields array
+ */
+ public static Query parse(AqpQueryParser qp, String[] queries, String[] fields)
+ throws QueryNodeException {
+ if (queries.length != fields.length)
+ throw new IllegalArgumentException("queries.length != fields.length");
+ BooleanQuery bQuery = new BooleanQuery();
+
+ for (int i = 0; i < fields.length; i++) {
+ Query q = qp.parse(queries[i], fields[i]);
+
+ if (q != null && // q never null, just being defensive
+ (!(q instanceof BooleanQuery) || ((BooleanQuery) q).getClauses().length > 0)) {
+ bQuery.add(q, BooleanClause.Occur.SHOULD);
+ }
+ }
+ return bQuery;
+ }
+
+ /**
+ * Parses a query, searching on the fields specified. Use this if you need to
+ * specify certain fields as required, and others as prohibited.
+ *
+ *
+ *
+ * Usage:
+ * <code>
+ * String[] fields = {"filename", "contents", "description"};
+ * BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+ * BooleanClause.Occur.MUST,
+ * BooleanClause.Occur.MUST_NOT};
+ * MultiFieldQueryParser.parse("query", fields, flags, analyzer);
+ * </code>
+ *
+ *
+ * The code above would construct a query:
+ *
+ *
+ * <code>
+ * (filename:query) +(contents:query) -(description:query)
+ * </code>
+ *
+ *
+ * @param query
+ * Query string to parse
+ * @param fields
+ * Fields to search on
+ * @param flags
+ * Flags describing the fields
+ * @param analyzer
+ * Analyzer to use
+ * @throws IllegalArgumentException
+ * if the length of the fields array differs from the length of the
+ * flags array
+ */
+ public static Query parse(AqpQueryParser qp, String query, String[] fields,
+ BooleanClause.Occur[] flags, Analyzer analyzer) throws QueryNodeException {
+ if (fields.length != flags.length)
+ throw new IllegalArgumentException("fields.length != flags.length");
+ BooleanQuery bQuery = new BooleanQuery();
+
+ for (int i = 0; i < fields.length; i++) {
+ Query q = qp.parse(query, fields[i]);
+
+ if (q != null && // q never null, just being defensive
+ (!(q instanceof BooleanQuery) || ((BooleanQuery) q).getClauses().length > 0)) {
+ bQuery.add(q, flags[i]);
+ }
+ }
+ return bQuery;
+ }
+
+ /**
+ * Parses a query, searching on the fields specified. Use this if you need to
+ * specify certain fields as required, and others as prohibited.
+ *
+ *
+ *
+ * Usage:
+ * <code>
+ * String[] query = {"query1", "query2", "query3"};
+ * String[] fields = {"filename", "contents", "description"};
+ * BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+ * BooleanClause.Occur.MUST,
+ * BooleanClause.Occur.MUST_NOT};
+ * MultiFieldQueryParser.parse(query, fields, flags, analyzer);
+ * </code>
+ *
+ *
+ * The code above would construct a query:
+ *
+ *
+ * <code>
+ * (filename:query1) +(contents:query2) -(description:query3)
+ * </code>
+ *
+ *
+ * @param queries
+ * Queries string to parse
+ * @param fields
+ * Fields to search on
+ * @param flags
+ * Flags describing the fields
+ * @param analyzer
+ * Analyzer to use
+ * @throws IllegalArgumentException
+ * if the length of the queries, fields, and flags array differ
+ */
+ public static Query parse(AqpQueryParser qp, String[] queries,
+ String[] fields, BooleanClause.Occur[] flags, Analyzer analyzer)
+ throws QueryNodeException {
+ if (!(queries.length == fields.length && queries.length == flags.length))
+ throw new IllegalArgumentException(
+ "queries, fields, and flags array have have different length");
+ BooleanQuery bQuery = new BooleanQuery();
+
+ for (int i = 0; i < fields.length; i++) {
+ Query q = qp.parse(queries[i], fields[i]);
+
+ if (q != null && // q never null, just being defensive
+ (!(q instanceof BooleanQuery) || ((BooleanQuery) q).getClauses().length > 0)) {
+ bQuery.add(q, flags[i]);
+ }
+ }
+ return bQuery;
+ }
+
+ /**
+ * Returns a String where those characters that TextParser expects to be
+ * escaped are escaped by a preceding \.
+ */
+ public static String escape(String s) {
+ StringBuilder sb = new StringBuilder();
+ 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();
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpCommonTreeAdaptor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpCommonTreeAdaptor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpCommonTreeAdaptor.java (revision 0)
@@ -0,0 +1,46 @@
+package org.apache.lucene.queryparser.flexible.aqp.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.antlr.runtime.Token;
+import org.antlr.runtime.tree.CommonTreeAdaptor;
+
+
+public class AqpCommonTreeAdaptor extends CommonTreeAdaptor {
+
+ private Map typeToNameMap;
+
+ public AqpCommonTreeAdaptor(String[] tokenNames) {
+ typeToNameMap = computeTypeToNameMap(tokenNames);
+ }
+
+ public Object create(Token payload) {
+ AqpCommonTree tree = new AqpCommonTree(payload);
+ tree.setTypeToNameMap(this.typeToNameMap);
+ return tree;
+ }
+
+ public Token getToken(Object t) {
+ if (t instanceof AqpCommonTree) {
+ return ((AqpCommonTree) t).getToken();
+ }
+ return null; // no idea what to do
+ }
+
+ /*
+ * translate token types into meaningful names it will be used later on
+ */
+ public Map computeTypeToNameMap(String[] tokenNames) {
+ Map m = new HashMap();
+ if (tokenNames == null) {
+ return m;
+ }
+ for (int ttype = Token.MIN_TOKEN_TYPE; ttype < tokenNames.length; ttype++) {
+ String name = tokenNames[ttype];
+ m.put(new Integer(ttype), name);
+ }
+ return m;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpCommonTree.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpCommonTree.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/util/AqpCommonTree.java (revision 0)
@@ -0,0 +1,126 @@
+package org.apache.lucene.queryparser.flexible.aqp.util;
+
+import java.util.Map;
+
+import org.antlr.runtime.CharStream;
+import org.antlr.runtime.CommonToken;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.Token;
+import org.antlr.runtime.tree.CommonErrorNode;
+import org.antlr.runtime.tree.CommonTree;
+import org.antlr.runtime.tree.Tree;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+
+/**
+ * A wrapper for the objects produced by ANTLR. These
+ * will be consumed by the aqp parser.
+ *
+ */
+public class AqpCommonTree extends CommonTree {
+
+ protected Map typeToNameMap;
+
+ public AqpCommonTree() {
+ super();
+ }
+
+ public AqpCommonTree(CommonTree node) {
+ super(node);
+ }
+
+ public AqpCommonTree(AqpCommonTree node) {
+ super(node);
+ }
+
+ public AqpCommonTree(Token t) {
+ this.token = t;
+ }
+
+ public Tree dupNode() {
+ AqpCommonTree r = new AqpCommonTree(this);
+ r.setTypeToNameMap(this.typeToNameMap);
+ return r;
+ }
+
+ /** Return the whole tree converted to QueryNode tree */
+ public QueryNode toQueryNodeTree() throws RecognitionException {
+ if (children == null || children.size() == 0) {
+ return this.toQueryNode();
+ }
+
+ QueryNode buf = toQueryNode();
+ for (int i = 0; children != null && i < children.size(); i++) {
+ Object child = children.get(i);
+ if (child instanceof CommonErrorNode) {
+ throw ((CommonErrorNode) child).trappedException;
+ }
+ AqpCommonTree t = (AqpCommonTree) child;
+ buf.add(t.toQueryNodeTree());
+ }
+ return buf;
+ }
+
+ public QueryNode toQueryNode() {
+ return (QueryNode) new AqpANTLRNode(this);
+ }
+
+ public String getTokenLabel() {
+ if (isNil()) {
+ return "nil";
+ }
+ if (getType() == Token.INVALID_TOKEN_TYPE) {
+ return "";
+ }
+ if (token == null) {
+ return null;
+ }
+ return token.getText();
+ }
+
+ public String getTokenInput() {
+ CharStream is = token.getInputStream();
+ if (is == null) {
+ return null;
+ }
+ int n = is.size();
+ if (getStartIndex() < n && getStopIndex() < n) {
+ return is.substring(getStartIndex(), getStopIndex());
+ } else {
+ return "";
+ }
+ }
+
+ public int getTokenType() {
+ return token.getType();
+ }
+
+ public String getTypeLabel() {
+ int t = getTokenType();
+ return typeToNameMap.get(t);
+ }
+
+ public int getStartIndex() {
+ return ((CommonToken) token).getStartIndex();
+ // return startIndex;
+ }
+
+ public int getStopIndex() {
+ // return stopIndex;
+ return ((CommonToken) token).getStopIndex();
+ }
+
+ public void setStartIndex(int start) {
+ ((CommonToken) token).setStartIndex(start);
+ }
+
+ public void setStopIndex(int end) {
+ ((CommonToken) token).setStopIndex(end);
+ }
+
+ public void setTypeToNameMap(Map typeMap) {
+ typeToNameMap = typeMap;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMODIFIERProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMODIFIERProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMODIFIERProcessor.java (revision 0)
@@ -0,0 +1,92 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode.Modifier;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Creates a {@link ModifierQueryNode} from the MODIFIER node last child
+ *
+ * If MODIFIER node contains only one child, we return that child and do
+ * nothing.
+ *
+ * If BOOST node contains two children, we take the first and check its input,
+ * eg.
+ *
+ *
+ * MODIFIER
+ * / \
+ * + rest
+ *
+ *
+ * We create a new node ModifierQueryNode(rest, Modifier) and return that node.
+ *
+ * This processor should run before {@link AqpOPERATORProcessor} to ensure that
+ * local modifiers have precedence over the boolean operations. For example:
+ *
+ *
+ * title:(+a -b c)
+ *
+ *
+ * Should produce (when OR is a default operator):
+ *
+ *
+ * +title:a -title:b title:c
+ *
+ *
+ * and when AND is the default operator:
+ *
+ *
+ * +title:a -title:b +title:c
+ *
+ *
+ * @see Modifier
+ * @see AqpBooleanQueryNode
+ */
+public class AqpMODIFIERProcessor extends AqpQProcessor {
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("MODIFIER")) {
+ return true;
+ }
+ return false;
+ }
+
+ public AqpANTLRNode getModifierNode(QueryNode node) {
+ return ((AqpANTLRNode) node.getChildren().get(0));
+ }
+
+ public QueryNode getValueNode(QueryNode node) {
+ return node.getChildren().get(node.getChildren().size() - 1);
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+
+ if (node.getChildren().size() == 1) {
+ return node.getChildren().get(0);
+ }
+
+ AqpANTLRNode modifierNode = getModifierNode(node);
+ String modifier = modifierNode.getTokenName();
+
+ QueryNode childNode = getValueNode(node);
+
+ if (modifier.equals("PLUS")) {
+ return new ModifierQueryNode(childNode,
+ ModifierQueryNode.Modifier.MOD_REQ);
+ } else if (modifier.equals("MINUS")) {
+ return new ModifierQueryNode(childNode,
+ ModifierQueryNode.Modifier.MOD_NOT);
+ } else {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "Unknown modifier: " + modifier + "\n" + node.toString()));
+ }
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQProcessor.java (revision 0)
@@ -0,0 +1,188 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.antlr.runtime.CharStream;
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.standard.parser.ParseException;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedback;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardQueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpCommonTree;
+
+/**
+ * A generic class that is used by other query processors, eg.
+ * {@link AqpQNORMALProcessor}
+ *
+ *
+ *
+ */
+public class AqpQProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ public String defaultField = null;
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpANTLRNode) {
+ AqpANTLRNode n = (AqpANTLRNode) node;
+ if (nodeIsWanted(n)) {
+ return createQNode(n);
+ }
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ throw new UnsupportedOperationException();
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ throw new UnsupportedOperationException();
+ }
+
+ public String getDefaultFieldName() throws QueryNodeException {
+ QueryConfigHandler queryConfig = getQueryConfigHandler();
+
+ String defaultField = null;
+ if (queryConfig != null) {
+
+ if (queryConfig
+ .has(AqpStandardQueryConfigHandler.ConfigurationKeys.DEFAULT_FIELD)) {
+ defaultField = queryConfig
+ .get(AqpStandardQueryConfigHandler.ConfigurationKeys.DEFAULT_FIELD);
+ }
+ return defaultField;
+ }
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "Configuration error: DEFAULT_FIELD is missing"));
+ }
+
+ public AqpFeedback getFeedbackAttr() throws QueryNodeException {
+ QueryConfigHandler config = getQueryConfigHandler();
+ if (config.has(AqpStandardQueryConfigHandler.ConfigurationKeys.FEEDBACK)) {
+ return config
+ .get(AqpStandardQueryConfigHandler.ConfigurationKeys.FEEDBACK);
+ } else {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.NODE_ACTION_NOT_SUPPORTED,
+ "Configuration error, missing AqpFeedback.class in the config!"));
+ }
+ }
+
+ public QueryNode getTerminalNode(QueryNode node) {
+ while (!node.isLeaf()) {
+ return getTerminalNode(node.getChildren().get(
+ node.getChildren().size() - 1));
+ }
+ return node;
+ }
+
+ public static OriginalInput getOriginalInput(AqpANTLRNode node)
+ throws ParseException {
+
+ CharStream inputStream = getInputStream(node);
+ if (inputStream == null) {
+ throw new ParseException(new MessageImpl(
+ "The supplied tree doesn't have input stream"));
+ }
+ int[] startIndex = new int[] { inputStream.size() };
+ getTheLowestIndex(startIndex, node);
+ if (startIndex[0] == -1) {
+ throw new ParseException(new MessageImpl(
+ "We cannot find where the input starts"));
+ }
+ int[] lastIndex = new int[] { startIndex[0] };
+ getTheHighestIndex(lastIndex, node);
+ if (lastIndex[0] < startIndex[0]) {
+ throw new ParseException(new MessageImpl(
+ "We cannot find where the input ends"));
+ }
+ // if (lastIndex[0]+1 < inputStream.size()) {
+ // lastIndex[0] += 1;
+ // }
+ return new OriginalInput(
+ inputStream.substring(startIndex[0], lastIndex[0]), startIndex[0],
+ lastIndex[0]);
+ }
+
+ public static CharStream getInputStream(QueryNode node) {
+ if (node.isLeaf()) {
+ if (node instanceof AqpANTLRNode) {
+ if (((AqpANTLRNode) node).getTree().getToken().getInputStream() != null) {
+ return ((AqpANTLRNode) node).getTree().getToken().getInputStream();
+ }
+ }
+ } else {
+ for (QueryNode child : node.getChildren()) {
+ CharStream r = getInputStream(child);
+ if (r != null) {
+ return r;
+ }
+ }
+ }
+ return null;
+ }
+
+ private static void getTheHighestIndex(int[] i, QueryNode node) {
+ if (!node.isLeaf()) {
+ for (QueryNode n : node.getChildren()) {
+ getTheHighestIndex(i, n);
+ }
+ }
+ if (node instanceof AqpANTLRNode) {
+ int si = ((AqpANTLRNode) node).getInputTokenEnd();
+ if (i[0] < si) {
+ i[0] = si;
+ }
+ }
+ }
+
+ private static void getTheLowestIndex(int[] i, QueryNode node) {
+ if (!node.isLeaf()) {
+ for (QueryNode n : node.getChildren()) {
+ getTheLowestIndex(i, n);
+ }
+ }
+ if (node instanceof AqpANTLRNode) {
+ int si = ((AqpANTLRNode) node).getInputTokenStart();
+ if (si > -1 && si < i[0]) {
+ i[0] = si;
+ }
+ }
+ }
+
+ public static class OriginalInput {
+ public String value;
+ public int start;
+ public int end;
+
+ public OriginalInput(String value, int startIndex, int endIndex) {
+ this.value = value;
+ this.start = startIndex;
+ this.end = endIndex;
+ }
+
+ public String toString() {
+ return String.format("%s [%d:%d]", this.value, this.start, this.end);
+ }
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpATOMProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpATOMProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpATOMProcessor.java (revision 0)
@@ -0,0 +1,50 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+public class AqpATOMProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("ATOM")) {
+
+ AqpANTLRNode atomNode = (AqpANTLRNode) node;
+
+ List children = node.getChildren();
+ QueryNode modifierNode = children.get(0); // MODIFIER
+ node = children.get(1); // NUCLEUS
+
+ if (modifierNode.getChildren() != null) {
+ String modifier = ((AqpANTLRNode) modifierNode.getChildren().get(0))
+ .getTokenName();
+ node = new ModifierQueryNode(node,
+ modifier.equals("PLUS") ? ModifierQueryNode.Modifier.MOD_REQ
+ : ModifierQueryNode.Modifier.MOD_NOT);
+ }
+ return node;
+ }
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpTreeRewriteProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpTreeRewriteProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpTreeRewriteProcessor.java (revision 0)
@@ -0,0 +1,76 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/*
+ * Processor which massages the AST tree before other processors work
+ * with it.
+ * - replaces chain of OPERATORs with the lowest ie. (AND (AND (AND..)))
+ * becomes (AND ...); this happens only if the OPERATOR has one
+ * single child of type: OPERATOR, ATOM, CLAUSE
+ *
+ * Useful mostly for the DEFOP operator as our ANTLR grammars
+ * usually group same clauses under one operator
+ *
+ * -
+ */
+public class AqpTreeRewriteProcessor extends QueryNodeProcessorImpl {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+
+ if (node instanceof AqpANTLRNode && node.getChildren() != null) {
+ List children = node.getChildren();
+ AqpANTLRNode n = (AqpANTLRNode) node;
+ AqpANTLRNode child;
+
+ // turn (AND (AND (CLAUSE...))) into (AND (CLAUSE...))
+ // also (AND (ATOM ....)) into (ATOM...)
+ if (n.getTokenName().equals("OPERATOR") && children.size() == 1) {
+ child = (AqpANTLRNode) children.get(0);
+ if (child.getTokenName().equals("OPERATOR")
+ || child.getTokenName().equals("ATOM")
+ || child.getTokenName().equals("CLAUSE")) {
+ return child;
+ }
+ }
+
+ /*
+ * if (node.getParent()==null && children.size() > 1) { // it is a root
+ * mode String last = ((AqpANTLRNode)children.get(0)).getTokenLabel();
+ * boolean rewriteSafe = true; // check all children nodes are of the same
+ * type for (int i=1;i childrenList =
+ * firstChild.getChildren();
+ *
+ * for (int i=1;i setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQANYTHINGProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQANYTHINGProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQANYTHINGProcessor.java (revision 0)
@@ -0,0 +1,26 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.MatchAllDocsQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Converts QANYTHING node into @{link {@link MatchAllDocsQueryNode}. The field
+ * value is the @{link DefaultFieldAttribute} specified in the configuration.
+ *
+ */
+public class AqpQANYTHINGProcessor extends AqpQProcessor {
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("QANYTHING")) {
+ return true;
+ }
+ return false;
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ return new MatchAllDocsQueryNode();
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQPHRASEProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQPHRASEProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQPHRASEProcessor.java (revision 0)
@@ -0,0 +1,46 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QuotedFieldQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Converts QPHRASE node into @{link {@link QuotedFieldQueryNode}. The field
+ * value is the @{link DefaultFieldAttribute} specified in the configuration.
+ *
+ *
+ *
+ * If the user specified a field, it will be set by the @{link
+ * AqpFIELDProcessor} Therefore the {@link AqpQPHRASEProcessor} should run
+ * before it.
+ *
+ *
+ * @see QueryConfigHandler
+ * @see DefaultFieldAttribute
+ *
+ */
+public class AqpQPHRASEProcessor extends AqpQProcessor {
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("QPHRASE")) {
+ return true;
+ }
+ return false;
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ String field = getDefaultFieldName();
+
+ AqpANTLRNode subChild = (AqpANTLRNode) node.getChildren().get(0);
+
+ return new QuotedFieldQueryNode(field,
+ EscapeQuerySyntaxImpl.discardEscapeChar(subChild.getTokenInput()
+ .substring(1, subChild.getTokenInput().length() - 1)),
+ subChild.getTokenStart() + 1, subChild.getTokenEnd() - 1);
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQRANGEINProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQRANGEINProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQRANGEINProcessor.java (revision 0)
@@ -0,0 +1,101 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.TermRangeQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Converts QRANGEIN node into @{link {@link ParametricQueryNode}. The field
+ * value is the @{link DefaultFieldAttribute} specified in the configuration.
+ *
+ * Because QRANGE nodes have this shape:
+ *
+ *
+ * QRANGE
+ * / \
+ * QNORMAL QPHRASE
+ * / \
+ * some "phrase"
+ *
+ *
+ * It is important to queue {@AqpQRANGEEProcessor} and
+ * {@AqpQRANGEINProcessor} before processors that
+ * transform QNORMAL, QPHRASE and other Q nodes
+ *
+ * If the user specified a field, it will be set by the @{link
+ * AqpFIELDProcessor} Therefore this processor should queue before @{link
+ * AqpFIELDProcessor}.
+ *
+ *
+ * @see QueryConfigHandler
+ * @see DefaultFieldAttribute
+ * @see AqpQRANGEEXProcessor
+ * @see AqpQueryNodeProcessorPipeline
+ *
+ */
+public class AqpQRANGEINProcessor extends AqpQProcessor {
+
+ protected boolean lowerInclusive = true;
+ protected boolean upperInclusive = true;
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("QRANGEIN")) {
+ return true;
+ }
+ return false;
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ String field = getDefaultFieldName();
+
+ AqpANTLRNode lowerNode = (AqpANTLRNode) node.getChildren().get(0);
+ AqpANTLRNode upperNode = (AqpANTLRNode) node.getChildren().get(1);
+
+ NodeData lower = getTokenInput(lowerNode);
+ NodeData upper = getTokenInput(upperNode);
+
+ FieldQueryNode lowerBound = new FieldQueryNode(field,
+ EscapeQuerySyntaxImpl.discardEscapeChar(lower.value), lower.start,
+ lower.end);
+ FieldQueryNode upperBound = new FieldQueryNode(field,
+ EscapeQuerySyntaxImpl.discardEscapeChar(upper.value), upper.start,
+ upper.end);
+
+ return new TermRangeQueryNode(lowerBound, upperBound, lowerInclusive,
+ upperInclusive);
+
+ }
+
+ public NodeData getTokenInput(AqpANTLRNode node) {
+ String label = node.getTokenLabel();
+ AqpANTLRNode subNode = (AqpANTLRNode) node.getChildren().get(0);
+
+ if (label.equals("QANYTHING")) {
+ return new NodeData("*", subNode.getTokenStart(), subNode.getTokenEnd());
+ } else if (label.contains("PHRASE")) {
+ return new NodeData(subNode.getTokenInput().substring(1,
+ subNode.getTokenInput().length() - 1), subNode.getTokenStart() + 1,
+ subNode.getTokenEnd() - 1);
+ } else {
+ return new NodeData(subNode.getTokenInput(), subNode.getTokenStart(),
+ subNode.getTokenEnd());
+ }
+ }
+
+ class NodeData {
+ public String value;
+ public int start;
+ public int end;
+
+ NodeData(String value, int start, int end) {
+ this.value = value;
+ this.start = start;
+ this.end = end;
+ }
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFuzzyModifierProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFuzzyModifierProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFuzzyModifierProcessor.java (revision 0)
@@ -0,0 +1,108 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.FuzzyQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QuotedFieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.SlopQueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.standard.nodes.WildcardQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.builders.AqpSlowFuzzyQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.aqp.config.AqpFeedback;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpFuzzyModifierNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.SlowFuzzyQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardQueryConfigHandler;
+
+/**
+ * Rewrites the query node which is below the {@link AqpFuzzyModifierNode}
+ *
+ * The actions are:
+ *
+ *
+ * {@link FieldQueryNode}
+ * - query is turned into {@link FuzzyQueryNode} or {@link SlowFuzzyQueryNode}
+ * depending the configuration of {@link AqpStandardQueryConfigHandler}.ConfigurationKeys.ALLOW_SLOW_FUZZY
+ * - invalid syntax is raised if not 0.0 > fuzzy < 1.0
+ *
+ * {@link WildcardQueryNode}, {@link QuotedFieldQueryNode}
+ * - becomes {@link SlopQueryNode}
+ *
+ *
+ * {@link QuotedFieldQueryNode}
+ * - wrapped with {@link SlopQueryNode}
+ *
+ *
+ */
+public class AqpFuzzyModifierProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpFuzzyModifierNode) {
+ QueryNode child = ((AqpFuzzyModifierNode) node).getChild();
+ Float fuzzy = ((AqpFuzzyModifierNode) node).getFuzzyValue();
+
+ QueryConfigHandler config = getQueryConfigHandler();
+
+ if (child instanceof QuotedFieldQueryNode
+ || child instanceof WildcardQueryNode) {
+
+ if (fuzzy.intValue() < fuzzy) {
+
+ if (config
+ .has(AqpStandardQueryConfigHandler.ConfigurationKeys.FEEDBACK)) {
+ AqpFeedback feedback = config
+ .get(AqpStandardQueryConfigHandler.ConfigurationKeys.FEEDBACK);
+ feedback.sendEvent(feedback.createEvent(AqpFeedback.TYPE.WARN,
+ this.getClass(), node,
+ "For phrases and wildcard queries the float attribute " + fuzzy
+ + " is automatically converted to: " + fuzzy.intValue()));
+ }
+ }
+ return new SlopQueryNode(child, fuzzy.intValue());
+ } else if (child instanceof FieldQueryNode) {
+
+ FieldQueryNode fn = (FieldQueryNode) child;
+
+ if (config
+ .has(AqpStandardQueryConfigHandler.ConfigurationKeys.ALLOW_SLOW_FUZZY) != false
+ && config
+ .get(AqpStandardQueryConfigHandler.ConfigurationKeys.ALLOW_SLOW_FUZZY) == true) {
+ if (fuzzy > 0.0f && fuzzy <= 1.0f) {
+ return new SlowFuzzyQueryNode(fn.getFieldAsString(),
+ fn.getTextAsString(), fuzzy, fn.getBegin(), fn.getEnd());
+ }
+ }
+
+ return new FuzzyQueryNode(fn.getFieldAsString(), fn.getTextAsString(),
+ fuzzy, fn.getBegin(), fn.getEnd());
+
+ } else {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.INVALID_SYNTAX, node.toString()
+ + "\nUse of ~ is not allowed here"));
+ }
+
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQProcessorPost.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQProcessorPost.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQProcessorPost.java (revision 0)
@@ -0,0 +1,42 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * The class that is used for ANTLR query nodes, it is the same as
+ * {@link AqpQPHRASEProcessor}, the only difference is that it works in
+ * postProcessor phase (instead of pre-process phase)
+ *
+ *
+ */
+
+public class AqpQProcessorPost extends AqpQProcessor {
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpANTLRNode) {
+ AqpANTLRNode n = (AqpANTLRNode) node;
+ if (nodeIsWanted(n)) {
+ return createQNode(n);
+ }
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ throw new UnsupportedOperationException();
+ }
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQNORMALProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQNORMALProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQNORMALProcessor.java (revision 0)
@@ -0,0 +1,46 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Converts QNORMAL node into @{link {@link FieldQueryNode}. The field value is
+ * the @{link DefaultFieldAttribute} specified in the configuration.
+ *
+ *
+ *
+ * If the user specified a field, it will be set by the @{link
+ * AqpFIELDProcessor} Therefore the {@link AqpQNORMALProcessor} should run
+ * before it.
+ *
+ *
+ * @see QueryConfigHandler
+ * @see DefaultFieldAttribute
+ *
+ */
+public class AqpQNORMALProcessor extends AqpQProcessor {
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("QNORMAL")) {
+ return true;
+ }
+ return false;
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ String field = getDefaultFieldName();
+
+ AqpANTLRNode subChild = (AqpANTLRNode) node.getChildren().get(0);
+
+ return new FieldQueryNode(field,
+ EscapeQuerySyntaxImpl.discardEscapeChar(subChild.getTokenInput()),
+ subChild.getTokenStart(), subChild.getTokenEnd());
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQTRUNCATEDProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQTRUNCATEDProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQTRUNCATEDProcessor.java (revision 0)
@@ -0,0 +1,55 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.WildcardQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Converts QTRUNCATED node into @{link {@link WildcardQueryNode}. The field
+ * value used is the @{link DefaultFieldAttribute} specified in the
+ * configuration.
+ *
+ *
+ *
+ * If the user specified a field, it will be set by the @{link
+ * AqpFIELDProcessor} Therefore the {@link AqpQTRUNCATEDProcessor} should run
+ * before it.
+ *
+ *
+ * @see QueryConfigHandler
+ * @see DefaultFieldAttribute
+ *
+ */
+public class AqpQTRUNCATEDProcessor extends AqpQProcessor {
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("QTRUNCATED")) {
+ return true;
+ }
+ return false;
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ String field = getDefaultFieldName();
+
+ AqpANTLRNode subChild = (AqpANTLRNode) node.getChildren().get(0);
+ String input = subChild.getTokenInput();
+
+ if (input.contains("*?") || input.contains("?*")) {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.INVALID_SYNTAX,
+ "It is not allowed to put * next to ?" + input));
+ }
+
+ return new WildcardQueryNode(field,
+ EscapeQuerySyntaxImpl.discardEscapeChar(input),
+ subChild.getTokenStart(), subChild.getTokenEnd());
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQRANGEEXProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQRANGEEXProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQRANGEEXProcessor.java (revision 0)
@@ -0,0 +1,49 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Converts QRANGEEX node into @{link {@link ParametricQueryNode}. The field
+ * value is the @{link DefaultFieldAttribute} specified in the configuration.
+ *
+ * Because QRANGE nodes have this shape:
+ *
+ *
+ * QRANGE
+ * / \
+ * QNORMAL QPHRASE
+ * / \
+ * some "phrase"
+ *
+ *
+ * It is important to queue {@AqpQRANGEEProcessor} and
+ * {@AqpQRANGEINProcessor} before processors that
+ * transform QNORMAL, QPHRASE and other Q nodes
+ *
+ * If the user specified a field, it will be set by the @{link
+ * AqpFIELDProcessor} Therefore this processor should queue before @{link
+ * AqpFIELDProcessor}.
+ *
+ *
+ * @see QueryConfigHandler
+ * @see DefaultFieldAttribute
+ * @see AqpQRANGEINProcessor
+ * @see AqpQueryNodeProcessorPipeline
+ *
+ */
+public class AqpQRANGEEXProcessor extends AqpQRANGEINProcessor {
+
+ public AqpQRANGEEXProcessor() {
+ lowerInclusive = false;
+ upperInclusive = false;
+ }
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("QRANGEEX")) {
+ return true;
+ }
+ return false;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpCLAUSEProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpCLAUSEProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpCLAUSEProcessor.java (revision 0)
@@ -0,0 +1,43 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.GroupQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Converts CLAUSE node into @{link {@link GroupQueryNode}
+ *
+ *
+ */
+public class AqpCLAUSEProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("CLAUSE")) {
+
+ return new GroupQueryNode(node.getChildren().get(0));
+ // return new BooleanQueryNode(node.getChildren());
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpNUCLEUSProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpNUCLEUSProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpNUCLEUSProcessor.java (revision 0)
@@ -0,0 +1,56 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpUtils;
+
+public class AqpNUCLEUSProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("NUCLEUS")) {
+ List children = node.getChildren();
+ AqpANTLRNode fieldNode = (AqpANTLRNode) children.remove(0);
+ String field = getFieldValue(fieldNode);
+ QueryNode valueNode = children.get(0);
+ if (field != null) {
+ AqpUtils.applyFieldToAllChildren(EscapeQuerySyntaxImpl.discardEscapeChar(field)
+ .toString(), valueNode);
+ }
+ return valueNode;
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+ private String getFieldValue(AqpANTLRNode fieldNode)
+ throws QueryNodeException {
+
+ if (fieldNode != null && fieldNode.getChildren() != null) {
+ return ((AqpANTLRNode) fieldNode.getChildren().get(0)).getTokenInput();
+ }
+ return null;
+
+ }
+
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQPHRASETRUNCProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQPHRASETRUNCProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQPHRASETRUNCProcessor.java (revision 0)
@@ -0,0 +1,47 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.WildcardQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Converts QPHRASETRUNC node into @{link {@link WildcardQueryNode}. The field
+ * value used is the @{link DefaultFieldAttribute} specified in the
+ * configuration.
+ *
+ *
+ *
+ * If the user specified a field, it will be set by the @{link
+ * AqpFIELDProcessor} Therefore the {@link AqpQTRUNCATEDProcessor} should run
+ * before it.
+ *
+ *
+ * @see QueryConfigHandler
+ * @see DefaultFieldAttribute
+ *
+ */
+public class AqpQPHRASETRUNCProcessor extends AqpQProcessor {
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("QPHRASETRUNC")) {
+ return true;
+ }
+ return false;
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ String field = getDefaultFieldName();
+
+ AqpANTLRNode subChild = (AqpANTLRNode) node.getChildren().get(0);
+
+ return new WildcardQueryNode(field,
+ EscapeQuerySyntaxImpl.discardEscapeChar(subChild.getTokenInput()
+ .substring(1, subChild.getTokenInput().length() - 1)),
+ subChild.getTokenStart() + 1, subChild.getTokenEnd() - 1);
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpAnalyzerQueryNodeProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpAnalyzerQueryNodeProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpAnalyzerQueryNodeProcessor.java (revision 0)
@@ -0,0 +1,402 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.CachingTokenFilter;
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
+import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
+import org.apache.lucene.analysis.tokenattributes.TypeAttribute;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.FuzzyQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.GroupQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.NoTokenFoundQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QuotedFieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.RangeQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.TextableQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.TokenizedPhraseQueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler.ConfigurationKeys;
+import org.apache.lucene.queryparser.flexible.standard.nodes.MultiPhraseQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.RegexpQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.StandardBooleanQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.WildcardQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.processors.AnalyzerQueryNodeProcessor;
+
+/**
+ * This is an improved version of the {@link AnalyzerQueryNodeProcessor} it is
+ * better because it keeps track of the position offset which is absolutely
+ * indispensable for proper parsing of expanded queries. And also we save the
+ * type attribute name with the node
+ *
+ * TODO: send a patch and make them accept it
+ *
+ * This processor verifies if {@link ConfigurationKeys#ANALYZER} is defined in
+ * the {@link QueryConfigHandler}. If it is and the analyzer is not
+ * null, it looks for every {@link FieldQueryNode} that is not
+ * {@link WildcardQueryNode}, {@link FuzzyQueryNode} or {@link RangeQueryNode}
+ * contained in the query node tree, then it applies the analyzer to that
+ * {@link FieldQueryNode} object.
+ *
+ * If the analyzer return only one term, the returned term is set to the
+ * {@link FieldQueryNode} and it's returned.
+ *
+ * If the analyzer return more than one term, a {@link TokenizedPhraseQueryNode}
+ * or {@link MultiPhraseQueryNode} is created, whether there is one or more
+ * terms at the same position, and it's returned.
+ *
+ * If no term is returned by the analyzer a {@link NoTokenFoundQueryNode} object
+ * is returned.
+ *
+ * @see ConfigurationKeys#ANALYZER
+ * @see Analyzer
+ * @see TokenStream
+ */
+
+public class AqpAnalyzerQueryNodeProcessor extends QueryNodeProcessorImpl {
+
+ public String TYPE_ATTRIBUTE = "token_type_attribute";
+ private Analyzer analyzer;
+
+ private boolean positionIncrementsEnabled;
+
+ public AqpAnalyzerQueryNodeProcessor() {
+ // empty constructor
+ }
+
+ @Override
+ public QueryNode process(QueryNode queryTree) throws QueryNodeException {
+ Analyzer analyzer = getQueryConfigHandler().get(ConfigurationKeys.ANALYZER);
+
+ if (analyzer != null) {
+ this.analyzer = analyzer;
+ this.positionIncrementsEnabled = false;
+ Boolean positionIncrementsEnabled = getQueryConfigHandler().get(
+ ConfigurationKeys.ENABLE_POSITION_INCREMENTS);
+
+ if (positionIncrementsEnabled != null) {
+ this.positionIncrementsEnabled = positionIncrementsEnabled;
+ }
+
+ if (this.analyzer != null) {
+ return super.process(queryTree);
+ }
+
+ }
+
+ return queryTree;
+
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+
+ if (node instanceof TextableQueryNode
+ && !(node instanceof WildcardQueryNode)
+ && !(node instanceof FuzzyQueryNode)
+ && !(node instanceof RegexpQueryNode)
+ && !(node.getParent() instanceof RangeQueryNode)) {
+
+ FieldQueryNode fieldNode = ((FieldQueryNode) node);
+ int queryStart = Math.max(fieldNode.getBegin(), 0); // could be -1
+ String text = fieldNode.getTextAsString();
+ String field = fieldNode.getFieldAsString();
+
+ TokenStream source;
+ try {
+ source = this.analyzer.tokenStream(field, new StringReader(text));
+ source.reset();
+ } catch (IOException e1) {
+ throw new RuntimeException(e1);
+ }
+ CachingTokenFilter buffer = new CachingTokenFilter(source);
+
+ PositionIncrementAttribute posIncrAtt = null;
+ int numTokens = 0;
+ int positionCount = 0;
+ boolean severalTokensAtSamePosition = false;
+
+ if (buffer.hasAttribute(PositionIncrementAttribute.class)) {
+ posIncrAtt = buffer.getAttribute(PositionIncrementAttribute.class);
+ }
+
+ TypeAttribute typeAtt = null;
+ if (buffer.hasAttribute(TypeAttribute.class)) {
+ typeAtt = buffer.getAttribute(TypeAttribute.class);
+ }
+
+ try {
+
+ while (buffer.incrementToken()) {
+ numTokens++;
+ int positionIncrement = (posIncrAtt != null) ? posIncrAtt
+ .getPositionIncrement() : 1;
+ if (positionIncrement != 0) {
+ positionCount += positionIncrement;
+
+ } else {
+ severalTokensAtSamePosition = true;
+ }
+
+ }
+
+ } catch (IOException e) {
+ // ignore
+ }
+
+ try {
+ // rewind the buffer stream
+ buffer.reset();
+
+ // close original stream - all tokens buffered
+ source.close();
+ } catch (IOException e) {
+ // ignore
+ }
+
+ if (!buffer.hasAttribute(CharTermAttribute.class)) {
+ return new NoTokenFoundQueryNode();
+ }
+
+ CharTermAttribute termAtt = buffer.getAttribute(CharTermAttribute.class);
+
+ int offsetStart = -1;
+ int offsetEnd = -1;
+ OffsetAttribute offsetAtt;
+ if (buffer.hasAttribute(OffsetAttribute.class)) {
+ offsetAtt = buffer.getAttribute(OffsetAttribute.class);
+ } else {
+ offsetAtt = null;
+ }
+
+ if (numTokens == 0) {
+ return new NoTokenFoundQueryNode();
+
+ } else if (numTokens == 1) {
+ String term = null;
+ try {
+ boolean hasNext;
+ hasNext = buffer.incrementToken();
+ assert hasNext == true;
+ term = termAtt.toString();
+
+ } catch (IOException e) {
+ // safe to ignore, because we know the number of tokens
+ }
+
+ fieldNode.setText(term);
+ if (offsetAtt != null) {
+ fieldNode.setBegin(queryStart + offsetAtt.startOffset());
+ fieldNode.setEnd(queryStart + offsetAtt.endOffset());
+ }
+ if (typeAtt != null)
+ fieldNode.setTag(TYPE_ATTRIBUTE, typeAtt.type());
+ return fieldNode;
+
+ } else if (severalTokensAtSamePosition
+ || !(node instanceof QuotedFieldQueryNode)) {
+ if (positionCount == 1 || !(node instanceof QuotedFieldQueryNode)) {
+ // no phrase query:
+ LinkedList children = new LinkedList();
+
+ for (int i = 0; i < numTokens; i++) {
+ String term = null;
+ offsetStart = offsetEnd = -1;
+ try {
+ boolean hasNext = buffer.incrementToken();
+ assert hasNext == true;
+ term = termAtt.toString();
+ if (offsetAtt != null) {
+ offsetStart = queryStart + offsetAtt.startOffset();
+ offsetEnd = queryStart + offsetAtt.endOffset();
+ }
+
+ } catch (IOException e) {
+ // safe to ignore, because we know the number of tokens
+ }
+
+ FieldQueryNode fq = new FieldQueryNode(field, term, offsetStart,
+ offsetEnd);
+ if (typeAtt != null)
+ fq.setTag(TYPE_ATTRIBUTE, typeAtt.type());
+ children.add(fq);
+
+ }
+ return new GroupQueryNode(new StandardBooleanQueryNode(children,
+ positionCount == 1));
+ } else {
+ // phrase query:
+ MultiPhraseQueryNode mpq = new MultiPhraseQueryNode();
+
+ List multiTerms = new ArrayList();
+ int position = -1;
+ int i = 0;
+ int termGroupCount = 0;
+
+ for (; i < numTokens; i++) {
+ String term = null;
+ offsetStart = offsetEnd = -1;
+ int positionIncrement = 1;
+ String tokenType = null;
+ try {
+ boolean hasNext = buffer.incrementToken();
+ assert hasNext == true;
+ term = termAtt.toString();
+ if (posIncrAtt != null) {
+ positionIncrement = posIncrAtt.getPositionIncrement();
+ }
+ if (offsetAtt != null) {
+ offsetStart = queryStart + offsetAtt.startOffset();
+ offsetEnd = queryStart + offsetAtt.endOffset();
+ }
+ if (typeAtt != null)
+ tokenType = typeAtt.type();
+ } catch (IOException e) {
+ // safe to ignore, because we know the number of tokens
+ }
+
+ if (positionIncrement > 0 && multiTerms.size() > 0) {
+
+ for (FieldQueryNode termNode : multiTerms) {
+
+ if (this.positionIncrementsEnabled) {
+ termNode.setPositionIncrement(position);
+ } else {
+ termNode.setPositionIncrement(termGroupCount);
+ }
+
+ mpq.add(termNode);
+
+ }
+
+ // Only increment once for each "group" of
+ // terms that were in the same position:
+ termGroupCount++;
+
+ multiTerms.clear();
+
+ }
+
+ position += positionIncrement;
+ FieldQueryNode fq = new FieldQueryNode(field, term, offsetStart,
+ offsetEnd);
+ fq.setTag(TYPE_ATTRIBUTE, tokenType);
+ multiTerms.add(fq);
+
+ }
+
+ for (FieldQueryNode termNode : multiTerms) {
+
+ if (this.positionIncrementsEnabled) {
+ termNode.setPositionIncrement(position);
+
+ } else {
+ termNode.setPositionIncrement(termGroupCount);
+ }
+
+ mpq.add(termNode);
+
+ }
+
+ return mpq;
+
+ }
+
+ } else {
+
+ TokenizedPhraseQueryNode pq = new TokenizedPhraseQueryNode();
+
+ int position = -1;
+
+ for (int i = 0; i < numTokens; i++) {
+ String term = null;
+ int positionIncrement = 1;
+ offsetStart = offsetEnd = -1;
+
+ try {
+ boolean hasNext = buffer.incrementToken();
+ assert hasNext == true;
+ term = termAtt.toString();
+
+ if (posIncrAtt != null) {
+ positionIncrement = posIncrAtt.getPositionIncrement();
+ }
+
+ if (offsetAtt != null) {
+ offsetStart = queryStart + offsetAtt.startOffset();
+ offsetEnd = queryStart + offsetAtt.endOffset();
+ }
+
+ } catch (IOException e) {
+ // safe to ignore, because we know the number of tokens
+ }
+
+ FieldQueryNode newFieldNode = new FieldQueryNode(field, term,
+ offsetStart, offsetEnd);
+ if (typeAtt != null)
+ newFieldNode.setTag(TYPE_ATTRIBUTE, typeAtt.type());
+
+ if (this.positionIncrementsEnabled) {
+ position += positionIncrement;
+ newFieldNode.setPositionIncrement(position);
+
+ } else {
+ newFieldNode.setPositionIncrement(i);
+ }
+
+ pq.add(newFieldNode);
+
+ }
+
+ return pq;
+
+ }
+
+ }
+
+ return node;
+
+ }
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+
+ return node;
+
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+
+ return children;
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMULTITERMProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMULTITERMProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMULTITERMProcessor.java (revision 0)
@@ -0,0 +1,82 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.BoostQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.OrQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.core.util.UnescapedCharSequence;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpUtils;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpUtils.Modifier;
+
+public class AqpMULTITERMProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("MULTITERM")) {
+ AqpANTLRNode mNode = (AqpANTLRNode) node;
+ AqpANTLRNode modifierNode = (AqpANTLRNode) mNode.getChild("MODIFIER");
+ AqpANTLRNode fieldNode = (AqpANTLRNode) mNode.getChild("FIELD");
+ AqpANTLRNode multiNode = (AqpANTLRNode) mNode.getChild("MULTIATOM");
+ AqpANTLRNode tModifierNode = (AqpANTLRNode) mNode.getChild("TMODIFIER");
+
+ String field = AqpUtils.getFirstChildInputString(fieldNode);
+ Modifier modifier = AqpUtils.getFirstChildInputModifier(modifierNode);
+
+ if (field != null) {
+ AqpUtils.applyFieldToAllChildren(EscapeQuerySyntaxImpl
+ .discardEscapeChar(field).toString(), multiNode);
+ }
+
+ node = new OrQueryNode(multiNode.getChildren());
+
+ if (tModifierNode != null) {
+ AqpANTLRNode boostNode = tModifierNode.getChild("BOOST");
+ Float boost = AqpUtils.getFirstChildInputFloat(boostNode);
+ if (boost != null) {
+ node = new BoostQueryNode(node, boost);
+ }
+ }
+
+ if (modifier != null) {
+ node = new ModifierQueryNode(node,
+ modifier == Modifier.PLUS ? ModifierQueryNode.Modifier.MOD_REQ
+ : ModifierQueryNode.Modifier.MOD_NOT);
+ }
+
+ return node;
+
+ }
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+ private String getFieldValue(AqpANTLRNode fieldNode)
+ throws QueryNodeException {
+
+ if (fieldNode != null && fieldNode.getChildren() != null) {
+ return ((AqpANTLRNode) fieldNode.getChildren().get(0)).getTokenInput();
+ }
+ return null;
+
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpTMODIFIERProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpTMODIFIERProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpTMODIFIERProcessor.java (revision 0)
@@ -0,0 +1,98 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * TMODIFIER node contains FUZZY, BOOST, FIELD nodes. This processor changes the
+ * tree from this shape:
+ *
+ *
+ * TMODIFIER
+ * / | \
+ * BOOST FUZZY FIELD
+ * / \
+ * ^1 ...
+ *
+ *
+ * To this shape:
+ *
+ *
+ * BOOST
+ * / \
+ * ^1 FUZZY
+ * |
+ * FIELD
+ * \
+ * ...
+ *
+ *
+ * After the processor ran, the TMODIFIER node is removed and we return the
+ * FUZZY node
+ *
+ * If TMODIFIER contains only single child, we return that child (thus remove
+ * the TMODIFIER node from the tree).
+ *
+ * @see AqpFUZZYProcessor
+ * @see AqpBOOSTProcessor
+ * @see AqpFIELDProcessor
+ */
+public class AqpTMODIFIERProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("TMODIFIER")) {
+
+ List children = node.getChildren();
+
+ if (children.size() == 1) {
+ return children.get(0);
+ }
+
+ QueryNode masterChild = null;
+ QueryNode currentChild;
+ List currentChildren;
+
+ for (int i = 0; i < children.size(); i++) {
+ currentChild = children.get(i);
+ if (currentChild.isLeaf()) {
+ continue;
+ }
+ if (masterChild == null) {
+ masterChild = currentChild;
+ node = masterChild;
+ continue;
+ }
+ currentChildren = masterChild.getChildren();
+ currentChildren.add(currentChild);
+ // masterChild.set(currentChildren);
+ masterChild = children.get(i);
+ }
+
+ return node;
+
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFIELDProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFIELDProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFIELDProcessor.java (revision 0)
@@ -0,0 +1,65 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldableNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.standard.parser.EscapeQuerySyntaxImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpUtils;
+
+/**
+ * This processor applies the user-submitted value to all {@link FieldableNode}
+ * nodes which are below it. The FIELD node itself will be discarded.
+ * If the FIELD has only one child, the child will be returned
+ *
+ * @see FieldableNode
+ * @see AqpQNORMALProcessor and similar
+ *
+ */
+public class AqpFIELDProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("FIELD")) {
+ if (node.getChildren().size() == 1) {
+ return node.getChildren().get(0);
+ }
+
+ String field = getFieldValue(node);
+ node = node.getChildren().get(node.getChildren().size() - 1);
+ if (field != null) {
+ AqpUtils.applyFieldToAllChildren(EscapeQuerySyntaxImpl.discardEscapeChar(field)
+ .toString(), node);
+ }
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+ private String getFieldValue(QueryNode fieldNode) throws QueryNodeException {
+
+ if (fieldNode != null && fieldNode.getChildren() != null) {
+ return ((AqpANTLRNode) fieldNode.getChildren().get(0)).getTokenInput();
+ }
+ return null;
+ }
+
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpNullDefaultFieldProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpNullDefaultFieldProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpNullDefaultFieldProcessor.java (revision 0)
@@ -0,0 +1,66 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldableNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.standard.processors.AnalyzerQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.MatchAllDocsQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.processors.MultiFieldQueryNodeProcessor;
+
+/**
+ * This processor changes field value 'null' into ''.
+ *
+ * The processor solves the following problem (probably affecting SOLR only):
+ *
+ * {@link MultiFieldQueryNodeProcessor} looks at {@link FieldableNode} and
+ * eventually creates several instances of them (eg. "query" becomes field:query
+ * fieldb:query). But this works only when the initial field==null. If it was
+ * '', nothing happens. If the current configuration contains
+ * {@link MultiFieldQueryNodeProcessor} but it is empty, also the field will be
+ * null (because {@link DefaultFieldAttribute} is by default null)
+ *
+ * {@link AnalyzerQueryNodeProcessor}, on the other hand, expects that field is
+ * a string value - to be precise, it asks the current analyzer to check the
+ * field. And if the field was null, then with SOLR this throws
+ * {@link NullPointerException}
+ *
+ * Please put {@link AqpNullDefaultFieldProcessor} also before
+ * {@link MatchAllDocsQueryNodeProcessor} otherwise you will get
+ * {@link NullPointerException} if the default field is null
+ *
+ * @see FieldableNode
+ * @see MultiFieldQueryNodeProcessor
+ * @see AnalyzerQueryNodeProcessor
+ * @see AqpInvenioQueryParser
+ * @see DefaultFieldAttribute
+ *
+ */
+public class AqpNullDefaultFieldProcessor extends QueryNodeProcessorImpl
+ implements QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof FieldQueryNode
+ && ((FieldQueryNode) node).getField() == null) {
+ ((FieldQueryNode) node).setField("");
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpGroupQueryOptimizerProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpGroupQueryOptimizerProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpGroupQueryOptimizerProcessor.java (revision 0)
@@ -0,0 +1,171 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.BooleanQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.BoostQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.GroupQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.standard.nodes.BooleanModifierNode;
+
+/**
+ * Optimizes the query by removing the superfluous GroupQuery nodes. We harvest
+ * all parameters from fuzzy, boost, and modifier nodes and apply those that are
+ * closest to the actual query.
+ *
+ *
+ * Example:
+ *
+ *
+ * this (+(-(+(-(that thus))^0.1))^0.3)
+ *
+ *
+ * Will be optimized into (when DEFOP = AND):
+ *
+ *
+ * +field:this -((+field:that +field:thus)^0.1)
+ *
+ *
+ *
+ */
+public class AqpGroupQueryOptimizerProcessor extends QueryNodeProcessorImpl
+ implements QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof GroupQueryNode) {
+ QueryNode immediateChild = node.getChildren().get(0);
+ ClauseData data = harvestData(immediateChild);
+ QueryNode changedNode = data.getLastChild();
+
+ if (data.getLevelsDeep() > 0) {
+ boolean modified = false;
+ if (data.getBoost() != null) {
+ changedNode = new BoostQueryNode(changedNode, data.getBoost());
+ modified = true;
+ }
+ if (data.getModifier() != null) {
+ changedNode = new BooleanModifierNode(changedNode, data.getModifier());
+ modified = true;
+ /*
+ * Why was I doing this? Firstly, it is buggy, the second branch
+ * always executes - why am i creating new BooleanNode?
+ * List children = new ArrayList(); if
+ * (children.size() == 1) { return children.get(0); } else {
+ * children.add(new ModifierQueryNode(node, data.getModifier())); node
+ * = new BooleanQueryNode(children); }
+ */
+ }
+ /*
+ * if (modified && node.getParent()==null) { List children =
+ * new ArrayList(); children.add(node); changedNode = new
+ * BooleanQueryNode(children); }
+ */
+ return changedNode;
+ }
+ return immediateChild;
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+ /*
+ * methods below not used now, but might be added - it tries to compact
+ * consecutive CLAUSE nodes into one clause, taking only the last
+ * modifier/tmodifier values
+ */
+ private ClauseData harvestData(QueryNode clauseNode) {
+ ClauseData data = new ClauseData();
+ harvestData(clauseNode, data);
+ return data;
+ }
+
+ private void harvestData(QueryNode node, ClauseData data) {
+
+ if (node instanceof ModifierQueryNode) {
+ data.setModifier(((ModifierQueryNode) node).getModifier());
+ } else if (node instanceof BoostQueryNode) {
+ data.setBoost(((BoostQueryNode) node).getValue());
+ } else if (node instanceof GroupQueryNode) {
+ data.addLevelsDeep();
+ } else {
+ data.setLastChild(node);
+ return; // break processing
+ }
+ if (!node.isLeaf() && node.getChildren().size() == 1) {
+ harvestData(node.getChildren().get(0), data);
+ }
+
+ }
+
+ class ClauseData {
+ private ModifierQueryNode.Modifier modifier;
+ private Float boost;
+ private QueryNode lastValidNode;
+ private boolean keepOutmost = true; // change this to false if you want that
+ // modifiers that are closer to the clause are applied to ti
+ private int levelsDeep = 0;
+
+ ClauseData() {
+ }
+
+ ClauseData(ModifierQueryNode.Modifier mod, Float boost) {
+ this.modifier = mod;
+ this.boost = boost;
+ }
+
+ public ModifierQueryNode.Modifier getModifier() {
+ return modifier;
+ }
+
+ public void setModifier(ModifierQueryNode.Modifier modifier) {
+ if (keepOutmost && this.modifier != null) {
+ return;
+ }
+ this.modifier = modifier;
+ }
+
+ public Float getBoost() {
+ return boost;
+ }
+
+ public void setBoost(Float boost) {
+ if (keepOutmost && this.boost != null) {
+ return;
+ }
+ this.boost = boost;
+ }
+
+ public QueryNode getLastChild() {
+ return lastValidNode;
+ }
+
+ public void setLastChild(QueryNode lastNonClause) {
+ this.lastValidNode = lastNonClause;
+ }
+
+ public int getLevelsDeep() {
+ return levelsDeep;
+ }
+
+ public void addLevelsDeep() {
+ this.levelsDeep++;
+ }
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpBOOSTProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpBOOSTProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpBOOSTProcessor.java (revision 0)
@@ -0,0 +1,103 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.BoostQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardQueryConfigHandler;
+
+/**
+ * Sets the node into the BoostQueryNode, this processor requires that
+ * {@link AqpTMODIFIERProcessor} ran before. Because we depend on the proper
+ * tree shape.
+ *
+ * If BOOST node contains only one child, we return that child and do nothing.
+ *
+ * If BOOST node contains two children, we take the first and check its input,
+ * eg.
+ *
+ *
+ * BOOST
+ * / \
+ * ^0.1 rest
+ *
+ *
+ * We create a new node BoostQueryNode(rest, 0.1) and return that node.
+ *
+ * Presence of the BOOST node child means user specified at least "^" We'll use
+ * the default from the configuration {@see BoostAttribute}
+ *
+ * @see AqpTMODIFIERProcessor
+ * @see AqpFUZZYProcessor
+ */
+public class AqpBOOSTProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("BOOST")) {
+
+ if (node.getChildren().size() == 1) {
+ return node.getChildren().get(0);
+ }
+
+ Float boost = getBoostValue(node);
+ if (boost == null) {
+ return node.getChildren().get(node.getChildren().size() - 1);
+ }
+ return new BoostQueryNode(node.getChildren().get(
+ node.getChildren().size() - 1), boost);
+
+ }
+ return node;
+
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+ private Float getBoostValue(QueryNode boostNode) throws QueryNodeException {
+ if (boostNode.getChildren() != null) {
+
+ AqpANTLRNode child = ((AqpANTLRNode) boostNode.getChildren().get(0));
+ String input = child.getTokenInput();
+ float boost;
+
+ if (input.equals("^")) {
+ QueryConfigHandler queryConfig = getQueryConfigHandler();
+ if (queryConfig == null
+ || !queryConfig
+ .has(AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_BOOST)) {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "Configuration error: IMPLICIT_BOOST value is missing"));
+ }
+ boost = queryConfig
+ .get(AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_BOOST);
+ } else {
+ boost = Float.valueOf(input.replace("^", ""));
+ }
+
+ return boost;
+
+ }
+ return null;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpOptimizationProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpOptimizationProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpOptimizationProcessor.java (revision 0)
@@ -0,0 +1,87 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpBooleanQueryNode;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.BooleanQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.ModifierQueryNode.Modifier;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+
+/**
+ * Optimizes the query tree - on root node - turns +whathever into whatever if
+ * there is only one child (but only if Modifier is positive, MOD_REQ or
+ * MOD_NONE)
+ *
+ */
+public class AqpOptimizationProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node.getParent() == null && node.getChildren() != null
+ && node.getChildren().size() == 1) {
+ if (node instanceof BooleanQueryNode) {
+ QueryNode c = node.getChildren().get(0);
+ if (c instanceof ModifierQueryNode
+ && ((ModifierQueryNode) c).getModifier() != Modifier.MOD_NOT) {
+ return ((ModifierQueryNode) c).getChild();
+ }
+ }
+ } else if (node instanceof AqpBooleanQueryNode) {
+
+ List children = node.getChildren();
+ String thisOp = ((AqpBooleanQueryNode) node).getOperator();
+ boolean rewriteSafe = true;
+
+ QueryNode modifier;
+ QueryNode subClause;
+ for (int i = 0; i < children.size(); i++) {
+ modifier = children.get(i);
+ if (modifier.isLeaf()) {
+ rewriteSafe = false;
+ break;
+ }
+ subClause = modifier.getChildren().get(0);
+ if (!(subClause instanceof AqpBooleanQueryNode && ((AqpBooleanQueryNode) subClause)
+ .getOperator().equals(thisOp))) {
+ rewriteSafe = false;
+ break;
+ }
+ }
+
+ if (rewriteSafe == true) {
+ List childrenList = new ArrayList();
+
+ for (int i = 0; i < children.size(); i++) {
+ subClause = children.get(i).getChildren().get(0);
+ for (QueryNode nod : subClause.getChildren()) {
+ childrenList.add(nod);
+ }
+ }
+
+ children.clear();
+ node.set(childrenList);
+ }
+ }
+
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFUZZYProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFUZZYProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFUZZYProcessor.java (revision 0)
@@ -0,0 +1,116 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpFuzzyModifierNode;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardQueryConfigHandler;
+
+/**
+ * Sets the node into the BoostQueryNode, this processor requires that
+ * {@link AqpTMODIFIERProcessor} ran before. Because we depend on the proper
+ * tree shape.
+ *
+ *
+ *
+ * If BOOST node contains only one child, we return that child and do nothing.
+ *
+ *
+ *
+ * If BOOST node contains two children, we take the first and check its input,
+ * eg.
+ *
+ *
+ * FUZZY
+ * / \
+ * ~0.1 rest
+ *
+ *
+ * We create a new node {@@link AqpFuzzyModifierNode} (rest, 0.1) and
+ * return that node.
+ *
+ *
+ *
+ * Presence of the BOOST node child means user specified at least "^" We'll use
+ * the default from the configuration {@link BoostAttribute}
+ *
+ * @see AqpTMODIFIERProcessor
+ * @see AqpFUZZYProcessor
+ */
+public class AqpFUZZYProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("FUZZY")) {
+
+ if (node.getChildren().size() == 1) {
+ return node.getChildren().get(0);
+ }
+
+ Float fuzzy = getFuzzyValue(node);
+
+ if (fuzzy == null) {
+ return node.getChildren().get(node.getChildren().size() - 1);
+ }
+
+ return new AqpFuzzyModifierNode(node.getChildren().get(
+ node.getChildren().size() - 1), fuzzy);
+
+ }
+ return node;
+
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+ private Float getFuzzyValue(QueryNode fuzzyNode) throws QueryNodeException {
+ if (fuzzyNode.getChildren() != null) {
+
+ AqpANTLRNode child = ((AqpANTLRNode) fuzzyNode.getChildren().get(0));
+ String input = child.getTokenInput();
+ float fuzzy;
+
+ if (input.equals("~")) {
+ QueryConfigHandler queryConfig = getQueryConfigHandler();
+ if (queryConfig == null
+ || !queryConfig
+ .has(AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_FUZZY)) {
+ throw new QueryNodeException(
+ new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "Configuration error: "
+ + AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_FUZZY
+ .toString() + " is missing"));
+ }
+ fuzzy = queryConfig
+ .get(AqpStandardQueryConfigHandler.ConfigurationKeys.IMPLICIT_FUZZY);
+ } else {
+ fuzzy = Float.valueOf(input.replace("~", ""));
+ }
+
+ return fuzzy;
+
+ }
+ return null;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMULTIVALUEProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMULTIVALUEProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpMULTIVALUEProcessor.java (revision 0)
@@ -0,0 +1,34 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+public class AqpMULTIVALUEProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("MULTIVALUE")) {
+ return node;
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFieldMapperProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFieldMapperProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpFieldMapperProcessor.java (revision 0)
@@ -0,0 +1,73 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+import java.util.Map;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardQueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardQueryConfigHandler.ConfigurationKeys;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.ConfigurationKey;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.FieldQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+
+/**
+ * Looks at the QueryNode(s) and translates the field name if we have a mapping
+ * for it. It is used to change the field names on-the-fly
+ *
+ * @see AqpFieldMapper
+ * @see QueryConfigHandler
+ *
+ */
+public class AqpFieldMapperProcessor extends QueryNodeProcessorImpl {
+
+ private Map fieldMap;
+ ConfigurationKey> mapKey = AqpStandardQueryConfigHandler.ConfigurationKeys.FIELD_MAPPER;
+
+ public AqpFieldMapperProcessor() {
+ // empty constructor
+ }
+
+ @Override
+ public QueryNode process(QueryNode queryTree) throws QueryNodeException {
+ if (getQueryConfigHandler().has(mapKey)) {
+ fieldMap = getQueryConfigHandler().get(mapKey);
+ if (this.fieldMap != null) {
+ return super.process(queryTree);
+ }
+ }
+
+ return queryTree;
+ }
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+ if (node instanceof FieldQueryNode) {
+ String field = ((FieldQueryNode) node).getFieldAsString();
+ if (fieldMap.containsKey(field)) {
+ String newField = fieldMap.get(field);
+ if (newField == null) {
+ throw new QueryNodeException(new MessageImpl("Server error",
+ "The configuration error, field " + field
+ + " is translated to: null"));
+ }
+ ((FieldQueryNode) node).setField(newField);
+ }
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQREGEXProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQREGEXProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpQREGEXProcessor.java (revision 0)
@@ -0,0 +1,45 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.standard.nodes.RegexpQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpAdsabsRegexQueryNode;
+
+/**
+ * Converts QREGEX node into @{link {@link RegexpQueryNode}. The field value is
+ * the @{link DefaultFieldAttribute} specified in the configuration.
+ *
+ *
+ *
+ * If the user specified a field, it will be set by the @{link
+ * AqpFIELDProcessor} Therefore the {@link AqpQNORMALProcessor} should run
+ * before it.
+ *
+ *
+ * @see QueryConfigHandler
+ * @see DefaultFieldAttribute
+ *
+ */
+public class AqpQREGEXProcessor extends AqpQProcessor {
+
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenLabel().equals("QREGEX")) {
+ return true;
+ }
+ return false;
+ }
+
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+ String field = getDefaultFieldName();
+
+ AqpANTLRNode subChild = (AqpANTLRNode) node.getChildren().get(0);
+ String input = subChild.getTokenInput();
+ return new AqpAdsabsRegexQueryNode(field, input.substring(1,
+ input.length() - 1), subChild.getTokenStart(), subChild.getTokenEnd());
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpOPERATORProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpOPERATORProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpOPERATORProcessor.java (revision 0)
@@ -0,0 +1,137 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.AndQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.OrQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpAndQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpDefopQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpNearQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpNotQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpOrQueryNode;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardQueryConfigHandler;
+
+/**
+ * This processor operates on OPERATOR nodes, these are the nodes with labels
+ * AND, OR, NOT, DEFOP, NEAR and possibly others.
+ * I have decided to create special QueryNodes for each type of the operator,
+ * because the default implementation ({@link AndQueryNode}, {@link OrQueryNode}
+ * ) was confusing.
+ *
+ *
+ * AND
+ * - creates {@link AqpAndQueryNode}
+ * OR
+ * - creates {@link AqpOrQueryNode}
+ * NOT
+ * - creates {@link AqpNotQueryNode}
+ * NEAR
+ * - creates {@link AqpNearQueryNode}
+ * WITH
+ * - not implemented yet
+ * PARAGRAPH
+ * - not implemented yet
+ *
+ *
+ * This processor should run after {@link AqpDEFOPProcessor}, and also after
+ * {@link AqpMODIFIERProcessor} because modifiers should have precedence over
+ * operators. Like in the query: "this OR +that"
+ *
+ */
+public class AqpOPERATORProcessor extends AqpQProcessorPost {
+
+ @Override
+ public boolean nodeIsWanted(AqpANTLRNode node) {
+ if (node.getTokenName().equals("OPERATOR")) {
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public QueryNode createQNode(AqpANTLRNode node) throws QueryNodeException {
+
+ String label = node.getTokenLabel();
+
+ if (label.equals("DEFOP")) {
+ return new AqpDefopQueryNode(node.getChildren(), getDefaultOperator());
+ } else if (label.equals("AND")) {
+ return new AqpAndQueryNode(node.getChildren());
+ } else if (label.equals("OR")) {
+ return new AqpOrQueryNode(node.getChildren());
+ } else if (label.equals("NOT")) {
+ return new AqpNotQueryNode(node.getChildren());
+ } else if (label.toUpperCase().contains("NEAR")) {
+ if (label.length() <= 4) {
+ return new AqpNearQueryNode(node.getChildren(),
+ getDefaultProximityValue());
+ } else {
+ int distance = Integer.parseInt(label.substring(4));
+ if (isProximityValueAllowed(distance)) {
+ return new AqpNearQueryNode(node.getChildren(), distance);
+ } else {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.INVALID_SYNTAX,
+ "Proximity is only allowed in a range: " + getRange()));
+ }
+ }
+
+ } else {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.INVALID_SYNTAX, "Unknown operator " + label));
+ }
+
+ }
+
+ private Integer getDefaultProximityValue() throws QueryNodeException {
+ QueryConfigHandler queryConfig = getQueryConfigHandler();
+ if (queryConfig == null
+ || !queryConfig
+ .has(AqpStandardQueryConfigHandler.ConfigurationKeys.DEFAULT_PROXIMITY)) {
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "Configuration error: " + "DefaultProximity value is missing"));
+ }
+ return queryConfig
+ .get(AqpStandardQueryConfigHandler.ConfigurationKeys.DEFAULT_PROXIMITY);
+ }
+
+ private int[] getRange() {
+ QueryConfigHandler queryConfig = getQueryConfigHandler();
+ return queryConfig
+ .get(AqpStandardQueryConfigHandler.ConfigurationKeys.ALLOWED_PROXIMITY_RANGE);
+
+ }
+
+ private boolean isProximityValueAllowed(int userValue) {
+ int[] range = getRange();
+ if (userValue >= range[0] && userValue <= range[1]) {
+ return true;
+ }
+ return false;
+ }
+
+ protected StandardQueryConfigHandler.Operator getDefaultOperator()
+ throws QueryNodeException {
+ QueryConfigHandler queryConfig = getQueryConfigHandler();
+
+ if (queryConfig != null) {
+ if (queryConfig
+ .has(StandardQueryConfigHandler.ConfigurationKeys.DEFAULT_OPERATOR)) {
+ return queryConfig
+ .get(StandardQueryConfigHandler.ConfigurationKeys.DEFAULT_OPERATOR);
+ }
+ }
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "Configuration error: "
+ + StandardQueryConfigHandler.ConfigurationKeys.class.toString()
+ + " is missing"));
+ }
+
+}
Index: lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpDEFOPProcessor.java
===================================================================
--- lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpDEFOPProcessor.java (revision 0)
+++ lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/aqp/processors/AqpDEFOPProcessor.java (revision 0)
@@ -0,0 +1,149 @@
+package org.apache.lucene.queryparser.flexible.aqp.processors;
+
+import java.util.List;
+
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.aqp.AqpQueryParser;
+import org.apache.lucene.queryparser.flexible.aqp.nodes.AqpANTLRNode;
+
+/**
+ * Finds the {@link AqpANTLRNode} with tokenLabel
+ *
+ *
+ * DEFOP
+ *
+ *
+ * and sets their @{code tokenInput} to be the name of the default operator.
+ *
+ * If there is only one child, the child is returned and we remove the operator.
+ * This happens mainly for simple queries such as
+ *
+ *
+ * field:value
+ *
+ *
+ * But also for queries which are itself clauses, like:
+ *
+ *
+ * +(this that)
+ *
+ *
+ * which produces:
+ *
+ *
+ * DEFOP
+ * |
+ * MODIFIER
+ * / \
+ * TMODIFIER
+ * |
+ * CLAUSE
+ * |
+ * DEFOP
+ * / \
+ * MODIFIER MODIFIER
+ * | |
+ *
+ *
+ *
+ * @see DefaultOperatorAttribute
+ * @see AqpQueryParser#setDefaultOperator(org.apache.lucene.queryparser.flexible.standard.config.DefaultOperatorAttribute.Operator)
+ *
+ */
+public class AqpDEFOPProcessor extends QueryNodeProcessorImpl implements
+ QueryNodeProcessor {
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node) throws QueryNodeException {
+
+ if (node instanceof AqpANTLRNode
+ && ((AqpANTLRNode) node).getTokenLabel().equals("DEFOP")) {
+
+ // only one child, we'll simplify the tree
+ if (node.getChildren().size() == 1) {
+ QueryNode child = node.getChildren().get(0);
+ while (child instanceof AqpANTLRNode
+ && ((AqpANTLRNode) child).getTokenLabel().equals("DEFOP")) {
+ child = child.getChildren().get(0);
+ }
+ return child;
+ }
+
+ /*
+ * This used to be here to modify the AST tree, but is now handled by the
+ * AqpOptimizationProcessor
+ *
+ * AqpANTLRNode thisNode = (AqpANTLRNode) node;
+ * StandardQueryConfigHandler.Operator op = getDefaultOperator();
+ *
+ * // Turn the DEFOP into the default operator
+ * thisNode.setTokenLabel(op.name());
+ *
+ * List children = node.getChildren(); if (children != null &&
+ * children.size() == 1) { AqpANTLRNode child = (AqpANTLRNode)
+ * children.get(0); if (child.getTokenName().equals("OPERATOR") ||
+ * child.getTokenLabel().equals("CLAUSE") ||
+ * child.getTokenLabel().equals("ATOM")) { return child; } } else if
+ * (children != null && children.size() > 1) { // several childeren
+ * (=clauses) below the operator // we check if we can put them together,
+ * ie // (this) AND (that) --> this AND that
+ *
+ * String thisOp = thisNode.getTokenLabel(); String last = ((AqpANTLRNode)
+ * children.get(0)).getTokenLabel(); boolean rewriteSafe = true;
+ *
+ * for (int i = 1; i < children.size(); i++) { AqpANTLRNode t =
+ * (AqpANTLRNode) children.get(i); String tt = t.getTokenLabel(); if
+ * (!(tt.equals(last) && t.getTokenLabel().equals(thisOp))) { rewriteSafe
+ * = false; break; } }
+ *
+ * if (rewriteSafe == true) { QueryNode firstChild = children.get(0);
+ * List childrenList = firstChild.getChildren();
+ *
+ * for (int i = 1; i < children.size(); i++) { QueryNode otherChild =
+ * children.get(i); for (QueryNode nod : otherChild.getChildren()) {
+ * childrenList.add(nod); } }
+ *
+ * children.clear(); thisNode.set(childrenList); } }
+ */
+ }
+ return node;
+ }
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
+ return node;
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+ return children;
+ }
+
+ protected StandardQueryConfigHandler.Operator getDefaultOperator()
+ throws QueryNodeException {
+ QueryConfigHandler queryConfig = getQueryConfigHandler();
+
+ if (queryConfig != null) {
+
+ if (queryConfig
+ .has(StandardQueryConfigHandler.ConfigurationKeys.DEFAULT_OPERATOR)) {
+ return queryConfig
+ .get(StandardQueryConfigHandler.ConfigurationKeys.DEFAULT_OPERATOR);
+ }
+ }
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.LUCENE_QUERY_CONVERSION_ERROR,
+ "Configuration error: "
+ + StandardQueryConfigHandler.ConfigurationKeys.class.toString()
+ + " is missing"));
+ }
+
+}
Index: lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGMultiField.java
===================================================================
--- lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGMultiField.java (revision 0)
+++ lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGMultiField.java (revision 0)
@@ -0,0 +1,392 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.Reader;
+import java.io.StringReader;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.MockAnalyzer;
+import org.apache.lucene.analysis.standard.StandardAnalyzer;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.TextField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.standard.QueryParserUtil;
+import org.apache.lucene.queryparser.flexible.standard.TestQPHelper;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler.Operator;
+import org.apache.lucene.queryparser.flexible.aqp.AqpQueryParser;
+import org.apache.lucene.queryparser.flexible.aqp.util.AqpQueryParserUtil;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreDoc;
+import org.apache.lucene.search.BooleanClause.Occur;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.RAMDirectory;
+import org.apache.lucene.util.IOUtils;
+
+/**
+ * This test case is a copy of the core Lucene query parser test, it was adapted
+ * to use new QueryParserHelper instead of the old query parser.
+ *
+ * Tests QueryParser.
+ */
+public class TestAqpSLGMultiField extends AqpTestAbstractCase {
+
+ /**
+ * test stop words parsing for both the non static form, and for the
+ * corresponding static form (qtxt, fields[]).
+ */
+ public void testStopwordsParsing() throws Exception {
+ assertStopQueryEquals("one", "b:one t:one");
+ assertStopQueryEquals("one stop", "b:one t:one");
+ assertStopQueryEquals("one (stop)", "b:one t:one");
+ assertStopQueryEquals("one ((stop))", "b:one t:one");
+ assertStopQueryEquals("stop", "");
+ assertStopQueryEquals("(stop)", "");
+ assertStopQueryEquals("((stop))", "");
+ }
+
+ // verify parsing of query using a stopping analyzer
+ private void assertStopQueryEquals(String qtxt, String expectedRes)
+ throws Exception {
+ String[] fields = { "b", "t" };
+ Occur occur[] = { Occur.SHOULD, Occur.SHOULD };
+ TestQPHelper.QPTestAnalyzer a = new TestQPHelper.QPTestAnalyzer();
+ AqpQueryParser mfqp = getParser();
+ mfqp.setMultiFields(fields);
+ mfqp.setAnalyzer(a);
+
+ Query q = mfqp.parse(qtxt, null);
+ assertEquals(expectedRes, q.toString());
+
+ q = QueryParserUtil.parse(qtxt, fields, occur, a);
+ assertEquals(expectedRes, q.toString());
+ }
+
+ public void testSimple() throws Exception {
+ String[] fields = { "b", "t" };
+ AqpQueryParser mfqp = getParser();
+ mfqp.setMultiFields(fields);
+ mfqp.setAnalyzer(new StandardAnalyzer(TEST_VERSION_CURRENT));
+
+ Query q = mfqp.parse("one", null);
+ assertEquals("b:one t:one", q.toString());
+
+ q = mfqp.parse("one two", null);
+ assertEquals("(b:one t:one) (b:two t:two)", q.toString());
+
+ q = mfqp.parse("+one +two", null);
+ assertEquals("+(b:one t:one) +(b:two t:two)", q.toString());
+
+ q = mfqp.parse("+one -two -three", null);
+ assertEquals("+(b:one t:one) -(b:two t:two) -(b:three t:three)",
+ q.toString());
+
+ q = mfqp.parse("one^2 two", null);
+ assertEquals("((b:one t:one)^2.0) (b:two t:two)", q.toString());
+
+ mfqp.setAllowSlowFuzzy(true);
+ q = mfqp.parse("one~ two", null);
+ assertEquals("(b:one~0.5 t:one~0.5) (b:two t:two)", q.toString());
+
+ q = mfqp.parse("one~0.8 two^2", null);
+ assertEquals("(b:one~0.8 t:one~0.8) ((b:two t:two)^2.0)", q.toString());
+
+ q = mfqp.parse("one* two*", null);
+ assertEquals("(b:one* t:one*) (b:two* t:two*)", q.toString());
+
+ q = mfqp.parse("[a TO c] two", null);
+ assertEquals("(b:[a TO c] t:[a TO c]) (b:two t:two)", q.toString());
+
+ q = mfqp.parse("w?ldcard", null);
+ assertEquals("b:w?ldcard t:w?ldcard", q.toString());
+
+ q = mfqp.parse("\"foo bar\"", null);
+ assertEquals("b:\"foo bar\" t:\"foo bar\"", q.toString());
+
+ q = mfqp.parse("\"aa bb cc\" \"dd ee\"", null);
+ assertEquals("(b:\"aa bb cc\" t:\"aa bb cc\") (b:\"dd ee\" t:\"dd ee\")",
+ q.toString());
+
+ q = mfqp.parse("\"foo bar\"~4", null);
+ assertEquals("b:\"foo bar\"~4 t:\"foo bar\"~4", q.toString());
+
+ // LUCENE-1213: QueryParser was ignoring slop when phrase
+ // had a field.
+ q = mfqp.parse("b:\"foo bar\"~4", null);
+ assertEquals("b:\"foo bar\"~4", q.toString());
+
+ // make sure that terms which have a field are not touched:
+ q = mfqp.parse("one f:two", null);
+ assertEquals("(b:one t:one) f:two", q.toString());
+
+ // AND mode:
+ mfqp.setDefaultOperator(Operator.AND);
+ q = mfqp.parse("one two", null);
+ assertEquals("+(b:one t:one) +(b:two t:two)", q.toString());
+ q = mfqp.parse("\"aa bb cc\" \"dd ee\"", null);
+ assertEquals("+(b:\"aa bb cc\" t:\"aa bb cc\") +(b:\"dd ee\" t:\"dd ee\")",
+ q.toString());
+
+ }
+
+ public void testBoostsSimple() throws Exception {
+ Map boosts = new HashMap();
+ boosts.put("b", Float.valueOf(5));
+ boosts.put("t", Float.valueOf(10));
+ String[] fields = { "b", "t" };
+ AqpQueryParser mfqp = getParser();
+ mfqp.setMultiFields(fields);
+ mfqp.setFieldsBoost(boosts);
+ mfqp.setAnalyzer(new StandardAnalyzer(TEST_VERSION_CURRENT));
+
+ // Check for simple
+ Query q = mfqp.parse("one", null);
+ assertEquals("b:one^5.0 t:one^10.0", q.toString());
+
+ // Check for AND
+ q = mfqp.parse("one AND two", null);
+ assertEquals("+(b:one^5.0 t:one^10.0) +(b:two^5.0 t:two^10.0)",
+ q.toString());
+
+ // Check for OR
+ q = mfqp.parse("one OR two", null);
+ assertEquals("(b:one^5.0 t:one^10.0) (b:two^5.0 t:two^10.0)", q.toString());
+
+ // Check for AND and a field
+ q = mfqp.parse("one AND two AND foo:test", null);
+ assertEquals("+(b:one^5.0 t:one^10.0) +(b:two^5.0 t:two^10.0) +foo:test",
+ q.toString());
+
+ q = mfqp.parse("one^3 AND two^4", null);
+ assertEquals("+((b:one^5.0 t:one^10.0)^3.0) +((b:two^5.0 t:two^10.0)^4.0)",
+ q.toString());
+ }
+
+ public void testStaticMethod1() throws Exception {
+ String[] fields = { "b", "t" };
+ String[] queries = { "one", "two" };
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(new StandardAnalyzer(TEST_VERSION_CURRENT));
+ Query q = AqpQueryParserUtil.parse(qp, queries, fields);
+ assertEquals("b:one t:two", q.toString());
+
+ String[] queries2 = { "+one", "+two" };
+ q = AqpQueryParserUtil.parse(qp, queries2, fields);
+ assertEquals("b:one t:two", q.toString());
+
+ String[] queries3 = { "one", "+two" };
+ q = AqpQueryParserUtil.parse(qp, queries3, fields);
+ assertEquals("b:one t:two", q.toString());
+
+ String[] queries4 = { "one +more", "+two" };
+ q = AqpQueryParserUtil.parse(qp, queries4, fields);
+ assertEquals("(b:one +b:more) t:two", q.toString());
+
+ String[] queries5 = { "blah" };
+ try {
+ q = AqpQueryParserUtil.parse(qp, queries5, fields);
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected exception, array length differs
+ }
+
+ // check also with stop words for this static form (qtxts[], fields[]).
+ TestQPHelper.QPTestAnalyzer stopA = new TestQPHelper.QPTestAnalyzer();
+ qp.setAnalyzer(stopA);
+
+ String[] queries6 = { "((+stop))", "+((stop))" };
+ q = AqpQueryParserUtil.parse(qp, queries6, fields);
+ assertEquals("", q.toString());
+
+ String[] queries7 = { "one ((+stop)) +more", "+((stop)) +two" };
+ q = AqpQueryParserUtil.parse(qp, queries7, fields);
+ // well, aqp is better in removing the parens from top-level,
+ // so this is the correct result (the AqpQueryUtils has fundamental flaw
+ // anyway)
+ // original was: (b:one +b:more) (+t:two)
+ assertEquals("(b:one +b:more) t:two", q.toString());
+
+ }
+
+ public void testStaticMethod2() throws QueryNodeException {
+ String[] fields = { "b", "t" };
+ BooleanClause.Occur[] flags = { BooleanClause.Occur.MUST,
+ BooleanClause.Occur.MUST_NOT };
+ Query q = QueryParserUtil.parse("one", fields, flags, new StandardAnalyzer(
+ TEST_VERSION_CURRENT));
+ assertEquals("+b:one -t:one", q.toString());
+
+ q = QueryParserUtil.parse("one two", fields, flags, new StandardAnalyzer(
+ TEST_VERSION_CURRENT));
+ assertEquals("+(b:one b:two) -(t:one t:two)", q.toString());
+
+ try {
+ BooleanClause.Occur[] flags2 = { BooleanClause.Occur.MUST };
+ q = QueryParserUtil.parse("blah", fields, flags2, new StandardAnalyzer(
+ TEST_VERSION_CURRENT));
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected exception, array length differs
+ }
+ }
+
+ public void testStaticMethod2Old() throws Exception {
+ String[] fields = { "b", "t" };
+ BooleanClause.Occur[] flags = { BooleanClause.Occur.MUST,
+ BooleanClause.Occur.MUST_NOT };
+ AqpQueryParser parser = getParser();
+ parser.setMultiFields(fields);
+ parser.setAnalyzer(new StandardAnalyzer(TEST_VERSION_CURRENT));
+
+ Query q = QueryParserUtil.parse("one", fields, flags, new StandardAnalyzer(
+ TEST_VERSION_CURRENT));// , fields, flags, new
+ // StandardAnalyzer());
+ assertEquals("+b:one -t:one", q.toString());
+
+ q = QueryParserUtil.parse("one two", fields, flags, new StandardAnalyzer(
+ TEST_VERSION_CURRENT));
+ assertEquals("+(b:one b:two) -(t:one t:two)", q.toString());
+
+ try {
+ BooleanClause.Occur[] flags2 = { BooleanClause.Occur.MUST };
+ q = QueryParserUtil.parse("blah", fields, flags2, new StandardAnalyzer(
+ TEST_VERSION_CURRENT));
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected exception, array length differs
+ }
+ }
+
+ public void testStaticMethod3() throws QueryNodeException {
+ String[] queries = { "one", "two", "three" };
+ String[] fields = { "f1", "f2", "f3" };
+ BooleanClause.Occur[] flags = { BooleanClause.Occur.MUST,
+ BooleanClause.Occur.MUST_NOT, BooleanClause.Occur.SHOULD };
+ Query q = QueryParserUtil.parse(queries, fields, flags,
+ new StandardAnalyzer(TEST_VERSION_CURRENT));
+ assertEquals("+f1:one -f2:two f3:three", q.toString());
+
+ try {
+ BooleanClause.Occur[] flags2 = { BooleanClause.Occur.MUST };
+ q = QueryParserUtil.parse(queries, fields, flags2, new StandardAnalyzer(
+ TEST_VERSION_CURRENT));
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected exception, array length differs
+ }
+ }
+
+ public void testStaticMethod3Old() throws QueryNodeException {
+ String[] queries = { "one", "two" };
+ String[] fields = { "b", "t" };
+ BooleanClause.Occur[] flags = { BooleanClause.Occur.MUST,
+ BooleanClause.Occur.MUST_NOT };
+ Query q = QueryParserUtil.parse(queries, fields, flags,
+ new StandardAnalyzer(TEST_VERSION_CURRENT));
+ assertEquals("+b:one -t:two", q.toString());
+
+ try {
+ BooleanClause.Occur[] flags2 = { BooleanClause.Occur.MUST };
+ q = QueryParserUtil.parse(queries, fields, flags2, new StandardAnalyzer(
+ TEST_VERSION_CURRENT));
+ fail();
+ } catch (IllegalArgumentException e) {
+ // expected exception, array length differs
+ }
+ }
+
+ public void testAnalyzerReturningNull() throws Exception {
+ String[] fields = new String[] { "f1", "f2", "f3" };
+ AqpQueryParser parser = getParser();
+ parser.setMultiFields(fields);
+ parser.setAnalyzer(new AnalyzerReturningNull());
+
+ Query q = parser.parse("bla AND blo", null);
+ assertEquals("+(f2:bla f3:bla) +(f2:blo f3:blo)", q.toString());
+ // the following queries are not affected as their terms are not
+ // analyzed anyway:
+ q = parser.parse("bla*", null);
+ assertEquals("f1:bla* f2:bla* f3:bla*", q.toString());
+ q = parser.parse("bla~", null);
+ assertEquals("f1:bla~1 f2:bla~1 f3:bla~1", q.toString());
+ q = parser.parse("[a TO c]", null);
+ assertEquals("f1:[a TO c] f2:[a TO c] f3:[a TO c]", q.toString());
+ }
+
+ public void testStopWordSearching() throws Exception {
+ Analyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
+ Directory ramDir = new RAMDirectory();
+ IndexWriter iw = new IndexWriter(ramDir, newIndexWriterConfig(
+ TEST_VERSION_CURRENT, analyzer));
+ Document doc = new Document();
+ doc.add(newField("body", "blah the footest blah", TextField.TYPE_NOT_STORED));
+ iw.addDocument(doc);
+ iw.close();
+
+ AqpQueryParser mfqp = getParser();
+
+ mfqp.setMultiFields(new String[] { "body" });
+ mfqp.setAnalyzer(analyzer);
+ mfqp.setDefaultOperator(Operator.AND);
+ Query q = mfqp.parse("the footest", null);
+ IndexSearcher is = new IndexSearcher(DirectoryReader.open(ramDir));
+ ScoreDoc[] hits = is.search(q, null, 1000).scoreDocs;
+ assertEquals(1, hits.length);
+ ramDir.close();
+ }
+
+ /**
+ * Return empty tokens for field "f1".
+ */
+ private static class AnalyzerReturningNull extends Analyzer {
+ MockAnalyzer stdAnalyzer = new MockAnalyzer(random());
+
+ public AnalyzerReturningNull() {
+ super(new PerFieldReuseStrategy());
+ }
+
+ @Override
+ protected Reader initReader(String fieldName, Reader reader) {
+ if ("f1".equals(fieldName)) {
+ // we don't use the reader, so close it:
+ IOUtils.closeWhileHandlingException(reader);
+ // return empty reader, so MockTokenizer returns no tokens:
+ return new StringReader("");
+ } else {
+ return super.initReader(fieldName, reader);
+ }
+ }
+
+ @Override
+ public TokenStreamComponents createComponents(String fieldName, Reader reader) {
+ return stdAnalyzer.createComponents(fieldName, reader);
+ }
+ }
+
+ // Uniquely for Junit 3
+ public static junit.framework.Test suite() {
+ return new junit.framework.JUnit4TestAdapter(TestAqpSLGMultiField.class);
+ }
+
+}
Index: lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGStandardTest.java
===================================================================
--- lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGStandardTest.java (revision 0)
+++ lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGStandardTest.java (revision 0)
@@ -0,0 +1,1080 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+import java.io.Reader;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TimeZone;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.MockAnalyzer;
+import org.apache.lucene.analysis.MockTokenizer;
+import org.apache.lucene.analysis.TokenFilter;
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.Tokenizer;
+import org.apache.lucene.analysis.core.StopAnalyzer;
+import org.apache.lucene.analysis.core.StopFilter;
+import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
+import org.apache.lucene.analysis.standard.StandardAnalyzer;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
+import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
+import org.apache.lucene.document.DateTools;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.TextField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.queryparser.flexible.messages.MessageImpl;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.builders.QueryTreeBuilder;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.messages.QueryParserMessages;
+import org.apache.lucene.queryparser.flexible.core.nodes.FuzzyQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorImpl;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorPipeline;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler.Operator;
+import org.apache.lucene.queryparser.flexible.standard.nodes.WildcardQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.processors.GroupQueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.aqp.AqpQueryParser;
+import org.apache.lucene.queryparser.flexible.aqp.AqpSyntaxParser;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardLuceneParser;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.search.MultiPhraseQuery;
+import org.apache.lucene.search.MultiTermQuery;
+import org.apache.lucene.search.PhraseQuery;
+import org.apache.lucene.search.PrefixQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.TermRangeQuery;
+import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.RAMDirectory;
+import org.apache.lucene.util.automaton.BasicAutomata;
+import org.apache.lucene.util.automaton.CharacterRunAutomaton;
+
+/**
+ * This test case is a copy of the core Lucene query parser test, it was adapted
+ * to use new QueryParserHelper instead of the old query parser.
+ *
+ * TODO: modify the QueryParserHelper so that we can extend it (it is not
+ * flexible in getting the parser, otherwise we could use the test methods there
+ * for most part)
+ *
+ * Tests QueryParser.
+ */
+public class TestAqpSLGStandardTest extends AqpTestAbstractCase {
+
+ public static Analyzer qpAnalyzer = new QPTestAnalyzer();
+
+ public static final class QPTestFilter extends TokenFilter {
+ private final CharTermAttribute termAtt = addAttribute(CharTermAttribute.class);
+ private final OffsetAttribute offsetAtt = addAttribute(OffsetAttribute.class);
+
+ /**
+ * Filter which discards the token 'stop' and which expands the token
+ * 'phrase' into 'phrase1 phrase2'
+ */
+ public QPTestFilter(TokenStream in) {
+ super(in);
+ }
+
+ boolean inPhrase = false;
+ int savedStart = 0, savedEnd = 0;
+
+ @Override
+ public boolean incrementToken() throws IOException {
+ if (inPhrase) {
+ inPhrase = false;
+ clearAttributes();
+ termAtt.setEmpty().append("phrase2");
+ offsetAtt.setOffset(savedStart, savedEnd);
+ return true;
+ } else
+ while (input.incrementToken()) {
+ if (termAtt.toString().equals("phrase")) {
+ inPhrase = true;
+ savedStart = offsetAtt.startOffset();
+ savedEnd = offsetAtt.endOffset();
+ termAtt.setEmpty().append("phrase1");
+ offsetAtt.setOffset(savedStart, savedEnd);
+ return true;
+ } else if (!termAtt.toString().equals("stop"))
+ return true;
+ }
+ return false;
+ }
+ }
+
+ public static final class QPTestAnalyzer extends Analyzer {
+
+ /** Filters MockTokenizer with StopFilter. */
+ @Override
+ public final TokenStreamComponents createComponents(String fieldName,
+ Reader reader) {
+ Tokenizer tokenizer = new MockTokenizer(reader, MockTokenizer.SIMPLE,
+ true);
+ return new TokenStreamComponents(tokenizer, new QPTestFilter(tokenizer));
+ }
+ }
+
+ public static class QPTestParser extends AqpQueryParser {
+ public QPTestParser(QueryConfigHandler config, AqpSyntaxParser parser,
+ QueryNodeProcessorPipeline processor, QueryTreeBuilder builder) {
+ super(config, parser, processor, builder);
+ // TODO Auto-generated constructor stub
+ }
+
+ public static AqpQueryParser init(Analyzer a) throws Exception {
+ AqpQueryParser p = AqpStandardLuceneParser.init();
+
+ ((QueryNodeProcessorPipeline) p.getQueryNodeProcessor())
+ .add(new QPTestParserQueryNodeProcessor());
+ p.setAnalyzer(a);
+ return p;
+ }
+
+ private static class QPTestParserQueryNodeProcessor extends
+ QueryNodeProcessorImpl {
+
+ @Override
+ protected QueryNode postProcessNode(QueryNode node)
+ throws QueryNodeException {
+
+ return node;
+
+ }
+
+ @Override
+ protected QueryNode preProcessNode(QueryNode node)
+ throws QueryNodeException {
+
+ if (node instanceof WildcardQueryNode || node instanceof FuzzyQueryNode) {
+
+ throw new QueryNodeException(new MessageImpl(
+ QueryParserMessages.EMPTY_MESSAGE));
+
+ }
+
+ return node;
+
+ }
+
+ @Override
+ protected List setChildrenOrder(List children)
+ throws QueryNodeException {
+
+ return children;
+
+ }
+
+ }
+
+ }
+
+ @Override
+ public void setUp() throws Exception {
+ super.setUp();
+ originalMaxClauses = BooleanQuery.getMaxClauseCount();
+ }
+
+ public void testConstantScoreAutoRewrite() throws Exception {
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(new WhitespaceAnalyzer(TEST_VERSION_CURRENT));
+
+ Query q = qp.parse("foo*bar", "field");
+ assertTrue(q instanceof WildcardQuery);
+ assertEquals(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT,
+ ((MultiTermQuery) q).getRewriteMethod());
+
+ q = qp.parse("foo*", "field");
+ assertTrue(q instanceof PrefixQuery);
+ assertEquals(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT,
+ ((MultiTermQuery) q).getRewriteMethod());
+
+ q = qp.parse("[a TO z]", "field");
+ assertTrue(q instanceof TermRangeQuery);
+ assertEquals(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT,
+ ((MultiTermQuery) q).getRewriteMethod());
+ }
+
+ public void testCJK() throws Exception {
+ // Test Ideographic Space - As wide as a CJK character cell (fullwidth)
+ // used google to translate the word "term" to japanese -> ??
+ assertQueryEquals("term\u3000term\u3000term", null,
+ "term\u0020term\u0020term");
+ assertQueryEqualsAllowLeadingWildcard("??\u3000??\u3000??", null,
+ "??\u0020??\u0020??");
+ }
+
+ public void testCJKTerm() throws Exception {
+ // individual CJK chars as terms
+ StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
+
+ BooleanQuery expected = new BooleanQuery();
+ expected.add(new TermQuery(new Term("field", "ä¸")),
+ BooleanClause.Occur.SHOULD);
+ expected.add(new TermQuery(new Term("field", "国")),
+ BooleanClause.Occur.SHOULD);
+
+ assertEquals(expected, getQuery("ä¸å›½", analyzer));
+ }
+
+ public void testCJKBoostedTerm() throws Exception {
+ // individual CJK chars as terms
+ StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
+
+ BooleanQuery expected = new BooleanQuery();
+ expected.setBoost(0.5f);
+ expected.add(new TermQuery(new Term("field", "ä¸")),
+ BooleanClause.Occur.SHOULD);
+ expected.add(new TermQuery(new Term("field", "国")),
+ BooleanClause.Occur.SHOULD);
+
+ assertEquals(expected, getQuery("ä¸å›½^0.5", analyzer));
+ }
+
+ public void testCJKPhrase() throws Exception {
+ // individual CJK chars as terms
+ StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
+
+ PhraseQuery expected = new PhraseQuery();
+ expected.add(new Term("field", "ä¸"));
+ expected.add(new Term("field", "国"));
+
+ assertEquals(expected, getQuery("\"ä¸å›½\"", analyzer));
+ }
+
+ public void testCJKBoostedPhrase() throws Exception {
+ // individual CJK chars as terms
+ StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
+
+ PhraseQuery expected = new PhraseQuery();
+ expected.setBoost(0.5f);
+ expected.add(new Term("field", "ä¸"));
+ expected.add(new Term("field", "国"));
+
+ assertEquals(expected, getQuery("\"ä¸å›½\"^0.5", analyzer));
+ }
+
+ public void testCJKSloppyPhrase() throws Exception {
+ // individual CJK chars as terms
+ StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
+
+ PhraseQuery expected = new PhraseQuery();
+ expected.setSlop(3);
+ expected.add(new Term("field", "ä¸"));
+ expected.add(new Term("field", "国"));
+
+ assertEquals(expected, getQuery("\"ä¸å›½\"~3", analyzer));
+ }
+
+ public void testSimple() throws Exception {
+ assertQueryEquals("\"term germ\"~2", null, "\"term germ\"~2");
+ assertQueryEquals("term term term", null, "term term term");
+ assertQueryEquals("t�rm term term", new WhitespaceAnalyzer(
+ TEST_VERSION_CURRENT), "t�rm term term");
+ assertQueryEquals("�mlaut", new WhitespaceAnalyzer(TEST_VERSION_CURRENT),
+ "�mlaut");
+
+ // XXX: not allowed, TODO???
+ // assertQueryEquals("\"\"", new KeywordAnalyzer(), "");
+ // assertQueryEquals("foo:\"\"", new KeywordAnalyzer(), "foo:");
+
+ assertQueryEquals("a AND b", null, "+a +b");
+ assertQueryEquals("(a AND b)", null, "+a +b");
+ assertQueryEquals("c OR (a AND b)", null, "c (+a +b)");
+
+ assertQueryEquals("a AND NOT b", null, "+a -b");
+ assertQueryEquals("a NOT b", null, "+a -b");
+
+ assertQueryEquals("a AND -b", null, "+a -b");
+
+ assertQueryEquals("a AND !b", null, "+a -b");
+
+ assertQueryEquals("a && b", null, "+a +b");
+
+ assertQueryEquals("a && ! b", null, "+a -b");
+
+ assertQueryEquals("a OR b", null, "a b");
+ assertQueryEquals("a || b", null, "a b");
+
+ assertQueryEquals("a OR !b", null, "a -b");
+
+ assertQueryEquals("a OR ! b", null, "a -b");
+
+ assertQueryEquals("a OR -b", null, "a -b");
+
+ assertQueryEquals("+term -term term", null, "+term -term term");
+ assertQueryEquals("foo:term AND field:anotherTerm", null,
+ "+foo:term +anotherterm");
+ assertQueryEquals("term AND \"phrase phrase\"", null,
+ "+term +\"phrase phrase\"");
+ assertQueryEquals("\"hello there\"", null, "\"hello there\"");
+ assertTrue(getQuery("a AND b", null) instanceof BooleanQuery);
+ assertTrue(getQuery("hello", null) instanceof TermQuery);
+ assertTrue(getQuery("\"hello there\"", null) instanceof PhraseQuery);
+
+ assertQueryEquals("germ term^2.0", null, "germ term^2.0");
+ assertQueryEquals("(term)^2.0", null, "term^2.0");
+ assertQueryEquals("(germ term)^2.0", null, "(germ term)^2.0");
+ assertQueryEquals("term^2.0", null, "term^2.0");
+ assertQueryEquals("term^2", null, "term^2.0");
+ assertQueryEquals("\"germ term\"^2.0", null, "\"germ term\"^2.0");
+ assertQueryEquals("\"term germ\"^2", null, "\"term germ\"^2.0");
+
+ assertQueryEquals("(foo OR bar) AND (baz OR boo)", null,
+ "+(foo bar) +(baz boo)");
+
+ assertQueryEquals("((a OR b) AND NOT c) OR d", null, "(+(a b) -c) d");
+ assertQueryEquals("((a OR b) NOT c) OR d", null, "(+(a b) -c) d");
+
+ assertQueryEquals("+(apple \"steve jobs\") -(foo bar baz)", null,
+ "+(apple \"steve jobs\") -(foo bar baz)");
+ assertQueryEquals("+title:(dog OR cat) -author:\"bob dole\"", null,
+ "+(title:dog title:cat) -author:\"bob dole\"");
+
+ AqpQueryParser qp = getParser();
+ qp.setDefaultOperator(Operator.OR);
+ assertQueryMatch(qp, "title:(+a -b c)", "text", "+title:a -title:b title:c");
+
+ qp.setDefaultOperator(Operator.AND);
+ assertQueryMatch(qp, "title:(+a -b c)", "text",
+ "+title:a -title:b +title:c");
+
+ }
+
+ public void testPunct() throws Exception {
+ Analyzer a = new WhitespaceAnalyzer(TEST_VERSION_CURRENT);
+ assertQueryEquals("a&b", a, "a&b");
+ assertQueryEquals("a&&b", a, "a&&b");
+ assertQueryEquals(".NET", a, ".NET");
+ }
+
+ public void testSlop() throws Exception {
+
+ assertQueryEquals("\"term germ\"~2", null, "\"term germ\"~2");
+ assertQueryEquals("\"term germ\"~2 flork", null, "\"term germ\"~2 flork");
+ assertQueryEquals("\"term\"~2", null, "term");
+ assertQueryEquals("\" \"~2 germ", null, "germ");
+ assertQueryEquals("\"term germ\"~2^2", null, "\"term germ\"~2^2.0");
+ }
+
+ public void testNumber() throws Exception {
+ // The numbers go away because SimpleAnalzyer ignores them
+ assertQueryEquals("3", null, "");
+ assertQueryEquals("term 1.0 1 2", null, "term");
+ assertQueryEquals("term term1 term2", null, "term term term");
+
+ Analyzer a = new StandardAnalyzer(TEST_VERSION_CURRENT);
+ assertQueryEquals("3", a, "3");
+ assertQueryEquals("term 1.0 1 2", a, "term 1.0 1 2");
+ assertQueryEquals("term term1 term2", a, "term term1 term2");
+ }
+
+ public void testWildcard() throws Exception {
+ assertQueryEquals("term*", null, "term*");
+ assertQueryEquals("term*^2", null, "term*^2.0");
+ assertQueryEquals("term~", null, "term~2");
+ assertQueryEquals("term~0.7", null, "term~1");
+
+ assertQueryEquals("term~^2", null, "term~2^2.0");
+
+ assertQueryEquals("term^2~", null, "term~2^2.0");
+ assertQueryEquals("term*germ", null, "term*germ");
+ assertQueryEquals("term*germ^3", null, "term*germ^3.0");
+
+ assertTrue(getQuery("term*", null) instanceof PrefixQuery);
+ assertTrue(getQuery("term*^2", null) instanceof PrefixQuery);
+ assertTrue(getQuery("term~", null) instanceof FuzzyQuery);
+ assertTrue(getQuery("term~0.7", null) instanceof FuzzyQuery);
+
+ FuzzyQuery fq = (FuzzyQuery) getQuery("term~0.7", null);
+ assertEquals(1, fq.getMaxEdits());
+ assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());
+ fq = (FuzzyQuery) getQuery("term~", null);
+ assertEquals(2, fq.getMaxEdits());
+ assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());
+
+ assertTrue(getQuery("term*germ", null) instanceof WildcardQuery);
+
+ /*
+ * Tests to see that wild card terms are (or are not) properly lower-cased
+ * with propery parser configuration
+ */
+ // First prefix queries:
+ // by default, convert to lowercase:
+ assertWildcardQueryEquals("Term*", true, "term*");
+ // explicitly set lowercase:
+ assertWildcardQueryEquals("term*", true, "term*");
+ assertWildcardQueryEquals("Term*", true, "term*");
+ assertWildcardQueryEquals("TERM*", true, "term*");
+ // explicitly disable lowercase conversion:
+ assertWildcardQueryEquals("term*", false, "term*");
+ assertWildcardQueryEquals("Term*", false, "Term*");
+ assertWildcardQueryEquals("TERM*", false, "TERM*");
+ // Then 'full' wildcard queries:
+ // by default, convert to lowercase:
+ assertWildcardQueryEquals("Te?m", "te?m");
+ // explicitly set lowercase:
+ assertWildcardQueryEquals("te?m", true, "te?m");
+ assertWildcardQueryEquals("Te?m", true, "te?m");
+ assertWildcardQueryEquals("TE?M", true, "te?m");
+ assertWildcardQueryEquals("Te?m*gerM", true, "te?m*germ");
+ // explicitly disable lowercase conversion:
+ assertWildcardQueryEquals("te?m", false, "te?m");
+ assertWildcardQueryEquals("Te?m", false, "Te?m");
+ assertWildcardQueryEquals("TE?M", false, "TE?M");
+ assertWildcardQueryEquals("Te?m*gerM", false, "Te?m*gerM");
+ // Fuzzy queries:
+ assertWildcardQueryEquals("Term~", "term~2");
+ assertWildcardQueryEquals("Term~", true, "term~2");
+ assertWildcardQueryEquals("Term~", false, "Term~2");
+ // Range queries:
+
+ // TODO: implement this on QueryParser
+ // Q0002E_INVALID_SYNTAX_CANNOT_PARSE: Syntax Error, cannot parse '[A TO
+ // C]': Lexical error at line 1, column 1. Encountered: "[" (91), after
+ // : ""
+ assertWildcardQueryEquals("[A TO C]", "[a TO c]");
+ assertWildcardQueryEquals("[A TO C]", true, "[a TO c]");
+ assertWildcardQueryEquals("[A TO C]", false, "[A TO C]");
+ // Test suffix queries: first disallow
+ try {
+ assertWildcardQueryEquals("*Term", true, "*term");
+ fail();
+ } catch (QueryNodeException pe) {
+ // expected exception
+ }
+ try {
+ assertWildcardQueryEquals("?Term", true, "?term");
+ fail();
+ } catch (QueryNodeException pe) {
+ // expected exception
+ }
+ // Test suffix queries: then allow
+ assertWildcardQueryEquals("*Term", true, "*term", true);
+ assertWildcardQueryEquals("?Term", true, "?term", true);
+ }
+
+ public void testLeadingWildcardType() throws Exception {
+ AqpQueryParser qp = getParser(null);
+ qp.setAllowLeadingWildcard(true);
+ assertEquals(WildcardQuery.class, qp.parse("t*erm*", "field").getClass());
+ assertEquals(WildcardQuery.class, qp.parse("?term*", "field").getClass());
+ assertEquals(WildcardQuery.class, qp.parse("*term*", "field").getClass());
+ }
+
+ public void testQPA() throws Exception {
+ assertQueryEquals("term term^3.0 term", qpAnalyzer, "term term^3.0 term");
+ assertQueryEquals("term stop^3.0 term", qpAnalyzer, "term term");
+
+ assertQueryEquals("term term term", qpAnalyzer, "term term term");
+ assertQueryEquals("term +stop term", qpAnalyzer, "term term");
+ assertQueryEquals("term -stop term", qpAnalyzer, "term term");
+
+ assertQueryEquals("drop AND (stop) AND roll", qpAnalyzer, "+drop +roll");
+ assertQueryEquals("term +(stop) term", qpAnalyzer, "term term");
+ assertQueryEquals("term -(stop) term", qpAnalyzer, "term term");
+
+ assertQueryEquals("drop AND stop AND roll", qpAnalyzer, "+drop +roll");
+ // rca TODO: plug the modifier GroupQueryNodeProcessor
+ // expected: term phrase1 phrase2 term
+ assertQueryEquals("term phrase term", qpAnalyzer,
+ "term (phrase1 phrase2) term");
+
+ // TODO: plug the modifier GroupQueryNodeProcessor
+ // expected: term phrase1 phrase2 term
+ assertQueryEquals("term AND NOT phrase term", qpAnalyzer,
+ "(+term -(phrase1 phrase2)) term");
+
+ assertQueryEquals("stop^3", qpAnalyzer, "");
+ assertQueryEquals("stop", qpAnalyzer, "");
+ assertQueryEquals("(stop)^3", qpAnalyzer, "");
+ assertQueryEquals("((stop))^3", qpAnalyzer, "");
+ assertQueryEquals("(stop^3)", qpAnalyzer, "");
+ assertQueryEquals("((stop)^3)", qpAnalyzer, "");
+ assertQueryEquals("(stop)", qpAnalyzer, "");
+ assertQueryEquals("((stop))", qpAnalyzer, "");
+ assertTrue(getQuery("term term term", qpAnalyzer) instanceof BooleanQuery);
+ assertTrue(getQuery("term +stop", qpAnalyzer) instanceof TermQuery);
+ }
+
+ public void testRange() throws Exception {
+ assertQueryEquals("[ a TO z]", null, "[a TO z]");
+ assertEquals(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT,
+ ((TermRangeQuery) getQuery("[ a TO z]", null)).getRewriteMethod());
+
+ AqpQueryParser qp = getParser();
+
+ qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
+ assertEquals(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE,
+ ((TermRangeQuery) qp.parse("[ a TO z]", "field")).getRewriteMethod());
+
+ assertQueryEquals("[ a TO z ]", null, "[a TO z]");
+ assertQueryEquals("{ a TO z}", null, "{a TO z}");
+ assertQueryEquals("{ a TO z }", null, "{a TO z}");
+ assertQueryEquals("{ a TO z }^2.0", null, "{a TO z}^2.0");
+ assertQueryEquals("[ a TO z] OR bar", null, "[a TO z] bar");
+ assertQueryEquals("[ a TO z] AND bar", null, "+[a TO z] +bar");
+ assertQueryEquals("( bar blar { a TO z}) ", null, "bar blar {a TO z}");
+
+ // the original expected value was: gack (bar blar {a TO z})
+ assertQueryEquals("gack ( bar blar { a TO z}) ", null,
+ "gack bar blar {a TO z}");
+ }
+
+ /**
+ * removed in lucene-4.0 public void testFarsiRangeCollating() throws
+ * Exception { Directory ramDir = newDirectory(); IndexWriter iw = new
+ * IndexWriter(ramDir, newIndexWriterConfig(TEST_VERSION_CURRENT, new
+ * WhitespaceAnalyzer(TEST_VERSION_CURRENT))); Document doc = new Document();
+ * doc.add(newField("content", "\u0633\u0627\u0628", Field.Store.YES,
+ * Field.Index.NOT_ANALYZED)); iw.addDocument(doc); iw.close(); IndexSearcher
+ * is = new IndexSearcher(ramDir, true);
+ *
+ * AqpQueryParser qp = getParser(); qp.setAnalyzer(new
+ * WhitespaceAnalyzer(TEST_VERSION_CURRENT));
+ *
+ * // Neither Java 1.4.2 nor 1.5.0 has Farsi Locale collation available in //
+ * RuleBasedCollator. However, the Arabic Locale seems to order the // Farsi
+ * // characters properly. Collator c = Collator.getInstance(new
+ * Locale("ar")); qp.setRangeCollator(c);
+ *
+ * // Unicode order would include U+0633 in [ U+062F - U+0698 ], but Farsi //
+ * orders the U+0698 character before the U+0633 character, so the // single
+ * // index Term below should NOT be returned by a ConstantScoreRangeQuery //
+ * with a Farsi Collator (or an Arabic one for the case when Farsi is // not
+ * // supported).
+ *
+ * // Test ConstantScoreRangeQuery
+ * qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
+ * ScoreDoc[] result = is.search(qp.parse("[ \u062F TO \u0698 ]", "content"),
+ * null, 1000).scoreDocs;
+ * assertEquals("The index Term should not be included.", 0, result.length);
+ *
+ * result = is.search(qp.parse("[ \u0633 TO \u0638 ]", "content"), null,
+ * 1000).scoreDocs; assertEquals("The index Term should be included.", 1,
+ * result.length);
+ *
+ * // Test RangeQuery
+ * qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
+ * result = is.search(qp.parse("[ \u062F TO \u0698 ]", "content"), null,
+ * 1000).scoreDocs; assertEquals("The index Term should not be included.", 0,
+ * result.length);
+ *
+ * result = is.search(qp.parse("[ \u0633 TO \u0638 ]", "content"), null,
+ * 1000).scoreDocs; assertEquals("The index Term should be included.", 1,
+ * result.length);
+ *
+ * is.close(); ramDir.close(); }
+ */
+
+ public void testDateRange() throws Exception {
+ String startDate = getLocalizedDate(2002, 1, 1);
+ String endDate = getLocalizedDate(2002, 1, 4);
+ Calendar endDateExpected = new GregorianCalendar();
+ endDateExpected.clear();
+ endDateExpected.set(2002, 1, 4, 23, 59, 59);
+ endDateExpected.set(Calendar.MILLISECOND, 999);
+ final String defaultField = "default";
+ final String monthField = "month";
+ final String hourField = "hour";
+ AqpQueryParser qp = getParser();
+
+ Map dateRes = new HashMap();
+
+ // set a field specific date resolution
+ dateRes.put(monthField, DateTools.Resolution.MONTH);
+ qp.setDateResolution(dateRes);
+
+ // set default date resolution to MILLISECOND
+ qp.setDateResolution(DateTools.Resolution.MILLISECOND);
+
+ // set second field specific date resolution
+ dateRes.put(hourField, DateTools.Resolution.HOUR);
+ qp.setDateResolution(dateRes);
+
+ // for this field no field specific date resolution has been set,
+ // so verify if the default resolution is used
+ assertDateRangeQueryEquals(qp, defaultField, startDate, endDate,
+ endDateExpected.getTime(), DateTools.Resolution.MILLISECOND);
+
+ // verify if field specific date resolutions are used for these two
+ // fields
+ assertDateRangeQueryEquals(qp, monthField, startDate, endDate,
+ endDateExpected.getTime(), DateTools.Resolution.MONTH);
+
+ assertDateRangeQueryEquals(qp, hourField, startDate, endDate,
+ endDateExpected.getTime(), DateTools.Resolution.HOUR);
+ }
+
+ public void testEscaped() throws Exception {
+ Analyzer a = new WhitespaceAnalyzer(TEST_VERSION_CURRENT);
+
+ /*
+ * assertQueryEquals("\\[brackets", a, "\\[brackets");
+ * assertQueryEquals("\\[brackets", null, "brackets");
+ * assertQueryEquals("\\\\", a, "\\\\"); assertQueryEquals("\\+blah", a,
+ * "\\+blah"); assertQueryEquals("\\(blah", a, "\\(blah");
+ *
+ * assertQueryEquals("\\-blah", a, "\\-blah"); assertQueryEquals("\\!blah",
+ * a, "\\!blah"); assertQueryEquals("\\{blah", a, "\\{blah");
+ * assertQueryEquals("\\}blah", a, "\\}blah"); assertQueryEquals("\\:blah",
+ * a, "\\:blah"); assertQueryEquals("\\^blah", a, "\\^blah");
+ * assertQueryEquals("\\[blah", a, "\\[blah"); assertQueryEquals("\\]blah",
+ * a, "\\]blah"); assertQueryEquals("\\\"blah", a, "\\\"blah");
+ * assertQueryEquals("\\(blah", a, "\\(blah"); assertQueryEquals("\\)blah",
+ * a, "\\)blah"); assertQueryEquals("\\~blah", a, "\\~blah");
+ * assertQueryEquals("\\*blah", a, "\\*blah"); assertQueryEquals("\\?blah",
+ * a, "\\?blah"); //assertQueryEquals("foo \\&\\& bar", a,
+ * "foo \\&\\& bar"); //assertQueryEquals("foo \\|| bar", a,
+ * "foo \\|| bar"); //assertQueryEquals("foo \\AND bar", a,
+ * "foo \\AND bar");
+ */
+
+ assertQueryEquals("\\*", a, "*");
+
+ assertQueryEquals("\\a", a, "a");
+
+ assertQueryEquals("a\\-b:c", a, "a-b:c");
+ assertQueryEquals("a\\+b:c", a, "a+b:c");
+ assertQueryEquals("a\\:b:c", a, "a:b:c");
+ assertQueryEquals("a\\\\b:c", a, "a\\b:c");
+
+ assertQueryEquals("a:b\\-c", a, "a:b-c");
+ assertQueryEquals("a:b\\+c", a, "a:b+c");
+ assertQueryEquals("a:b\\:c", a, "a:b:c");
+ assertQueryEquals("a:b\\\\c", a, "a:b\\c");
+
+ assertQueryEquals("a:b\\-c*", a, "a:b-c*");
+ assertQueryEquals("a:b\\+c*", a, "a:b+c*");
+ assertQueryEquals("a:b\\:c*", a, "a:b:c*");
+
+ assertQueryEquals("a:b\\\\c*", a, "a:b\\c*");
+
+ assertQueryEquals("a:b\\-?c", a, "a:b-?c");
+ assertQueryEquals("a:b\\+?c", a, "a:b+?c");
+ assertQueryEquals("a:b\\:?c", a, "a:b:?c");
+
+ assertQueryEquals("a:b\\\\?c", a, "a:b\\?c");
+
+ assertQueryEquals("a:b\\-c~", a, "a:b-c~1");
+ assertQueryEquals("a:b\\+c~", a, "a:b+c~1");
+ assertQueryEquals("a:b\\:c~", a, "a:b:c~1");
+ assertQueryEquals("a:b\\\\c~", a, "a:b\\c~1");
+
+ // TODO: implement Range queries on QueryParser
+ assertQueryEquals("[ a\\- TO a\\+ ]", null, "[a- TO a+]");
+ assertQueryEquals("[ a\\: TO a\\~ ]", null, "[a: TO a~]");
+ assertQueryEquals("[ a\\\\ TO a\\* ]", null, "[a\\ TO a*]");
+
+ assertQueryEquals(
+ "[\"c\\:\\\\temp\\\\\\~foo0.txt\" TO \"c\\:\\\\temp\\\\\\~foo9.txt\"]",
+ a, "[c:\\temp\\~foo0.txt TO c:\\temp\\~foo9.txt]");
+
+ assertQueryEquals("a\\\\\\+b", a, "a\\+b");
+
+ assertQueryEquals("a \\\"b c\\\" d", a, "a \"b c\" d");
+ assertQueryEquals("\"a \\\"b c\\\" d\"", a, "\"a \"b c\" d\"");
+ assertQueryEquals("\"a \\+b c d\"", a, "\"a +b c d\"");
+
+ assertQueryEquals("c\\:\\\\temp\\\\\\~foo.txt", a, "c:\\temp\\~foo.txt");
+
+ assertQueryNodeException("XY\\"); // there must be a character after the
+ // escape char
+
+ // test unicode escaping
+ assertQueryEquals("a\\u0062c", a, "abc");
+ assertQueryEquals("XY\\u005a", a, "XYZ");
+ assertQueryEquals("XY\\u005A", a, "XYZ");
+ assertQueryEquals("\"a \\\\\\u0028\\u0062\\\" c\"", a, "\"a \\(b\" c\"");
+
+ assertQueryNodeException("XY\\u005G"); // test non-hex character in escaped
+ // unicode sequence
+ assertQueryNodeException("XY\\u005"); // test incomplete escaped unicode
+ // sequence
+
+ // Tests bug LUCENE-800
+ assertQueryEquals("(item:\\\\ item:ABCD\\\\)", a, "item:\\ item:ABCD\\");
+ assertQueryNodeException("(item:\\\\ item:ABCD\\\\))"); // unmatched closing
+ assertQueryNodeException("(item:\\\\ item:ABCD\\\\)))"); // unmatched closing
+ assertQueryNodeException("(item:\\\\ item:ABCD\\\\) foo)"); // unmatched closing
+
+ // paranthesis
+ assertQueryEquals("\\*", a, "*");
+ assertQueryEquals("\\\\", a, "\\"); // escaped backslash
+
+ assertQueryNodeException("\\"); // a backslash must always be escaped
+
+ // LUCENE-1189
+ // the original result was set to be:
+ // assertQueryEquals("(\"a\\\\\") or (\"b\")", a, "a\\ or b");
+ // however, this is wrong, because the query is: ("a\\") or ("b")
+ // the AQP parser is handling escaped chars (even escaped escapes)
+ // correctly
+ assertQueryEquals("(\"a\\\\\") or (\"b\")", a, "a\\ b");
+ assertQueryEquals("(foo:\"a\\\\\") or (bar:\"b\")", a, "foo:a\\ bar:b");
+ }
+
+ public void testQueryStringEscaping() throws Exception {
+ Analyzer a = new WhitespaceAnalyzer(TEST_VERSION_CURRENT);
+
+ assertEscapedQueryEquals("a-b:c", a, "a\\-b\\:c");
+ assertEscapedQueryEquals("a+b:c", a, "a\\+b\\:c");
+ assertEscapedQueryEquals("a:b:c", a, "a\\:b\\:c");
+ assertEscapedQueryEquals("a\\b:c", a, "a\\\\b\\:c");
+
+ assertEscapedQueryEquals("a:b-c", a, "a\\:b\\-c");
+ assertEscapedQueryEquals("a:b+c", a, "a\\:b\\+c");
+ assertEscapedQueryEquals("a:b:c", a, "a\\:b\\:c");
+ assertEscapedQueryEquals("a:b\\c", a, "a\\:b\\\\c");
+
+ assertEscapedQueryEquals("a:b-c*", a, "a\\:b\\-c\\*");
+ assertEscapedQueryEquals("a:b+c*", a, "a\\:b\\+c\\*");
+ assertEscapedQueryEquals("a:b:c*", a, "a\\:b\\:c\\*");
+
+ assertEscapedQueryEquals("a:b\\\\c*", a, "a\\:b\\\\\\\\c\\*");
+
+ assertEscapedQueryEquals("a:b-?c", a, "a\\:b\\-\\?c");
+ assertEscapedQueryEquals("a:b+?c", a, "a\\:b\\+\\?c");
+ assertEscapedQueryEquals("a:b:?c", a, "a\\:b\\:\\?c");
+
+ assertEscapedQueryEquals("a:b?c", a, "a\\:b\\?c");
+
+ assertEscapedQueryEquals("a:b-c~", a, "a\\:b\\-c\\~");
+ assertEscapedQueryEquals("a:b+c~", a, "a\\:b\\+c\\~");
+ assertEscapedQueryEquals("a:b:c~", a, "a\\:b\\:c\\~");
+ assertEscapedQueryEquals("a:b\\c~", a, "a\\:b\\\\c\\~");
+
+ assertEscapedQueryEquals("[ a - TO a+ ]", null, "\\[ a \\- TO a\\+ \\]");
+ assertEscapedQueryEquals("[ a : TO a~ ]", null, "\\[ a \\: TO a\\~ \\]");
+ assertEscapedQueryEquals("[ a\\ TO a* ]", null, "\\[ a\\\\ TO a\\* \\]");
+
+ // LUCENE-881
+ assertEscapedQueryEquals("|| abc ||", a, "\\|\\| abc \\|\\|");
+ assertEscapedQueryEquals("&& abc &&", a, "\\&\\& abc \\&\\&");
+ }
+
+ public void testTabNewlineCarriageReturn() throws Exception {
+ assertQueryEqualsDOA("+weltbank +worlbank", null, "+weltbank +worlbank");
+
+ assertQueryEqualsDOA("+weltbank\n+worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \n+worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \n +worlbank", null, "+weltbank +worlbank");
+
+ assertQueryEqualsDOA("+weltbank\r+worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \r+worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \r +worlbank", null, "+weltbank +worlbank");
+
+ assertQueryEqualsDOA("+weltbank\r\n+worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \r\n+worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \r\n +worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \r \n +worlbank", null,
+ "+weltbank +worlbank");
+
+ assertQueryEqualsDOA("+weltbank\t+worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \t+worlbank", null, "+weltbank +worlbank");
+ assertQueryEqualsDOA("weltbank \t +worlbank", null, "+weltbank +worlbank");
+ }
+
+ public void testSimpleDAO() throws Exception {
+ assertQueryEqualsDOA("term term term", null, "+term +term +term");
+ assertQueryEqualsDOA("term +term term", null, "+term +term +term");
+ assertQueryEqualsDOA("term term +term", null, "+term +term +term");
+ assertQueryEqualsDOA("term +term +term", null, "+term +term +term");
+ assertQueryEqualsDOA("-term term term", null, "-term +term +term");
+ }
+
+ public void testBoost() throws Exception {
+ CharacterRunAutomaton stopSet = new CharacterRunAutomaton(
+ BasicAutomata.makeString("on"));
+ Analyzer oneStopAnalyzer = new MockAnalyzer(random(), MockTokenizer.SIMPLE,
+ true, stopSet);
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(oneStopAnalyzer);
+
+ Query q = qp.parse("on^1.0", "field");
+ assertNotNull(q);
+ q = qp.parse("\"hello\"^2.0", "field");
+ assertNotNull(q);
+ assertEquals(q.getBoost(), (float) 2.0, (float) 0.5);
+ q = qp.parse("hello^2.0", "field");
+ assertNotNull(q);
+ assertEquals(q.getBoost(), (float) 2.0, (float) 0.5);
+ q = qp.parse("\"on\"^1.0", "field");
+ assertNotNull(q);
+
+ AqpQueryParser qp2 = getParser();
+ qp2.setAnalyzer(new StandardAnalyzer(TEST_VERSION_CURRENT));
+
+ q = qp2.parse("the^3", "field");
+ // "the" is a stop word so the result is an empty query:
+ assertNotNull(q);
+ assertEquals("", q.toString());
+ assertEquals(1.0f, q.getBoost(), 0.01f);
+ }
+
+ public void testException() throws Exception {
+ assertQueryNodeException("*leadingWildcard"); // disallowed by default
+ assertQueryNodeException("(foo bar");
+
+ assertQueryNodeException("\"some phrase");
+ assertQueryNodeException("foo bar))");
+ assertQueryNodeException("field:term:with:colon some more terms");
+ assertQueryNodeException("(sub query)^5.0^2.0 plus more");
+ assertQueryNodeException("secret AND illegal) AND access:confidential");
+ }
+
+ public void testCustomQueryParserWildcard() throws Exception {
+ try {
+ QPTestParser.init(new WhitespaceAnalyzer(TEST_VERSION_CURRENT)).parse(
+ "a?t", "contents");
+ fail("Wildcard queries should not be allowed");
+ } catch (QueryNodeException expected) {
+ // expected exception
+ }
+ }
+
+ public void testCustomQueryParserFuzzy() throws Exception {
+ try {
+ QPTestParser.init(new WhitespaceAnalyzer(TEST_VERSION_CURRENT)).parse(
+ "xunit~", "contents");
+ fail("Fuzzy queries should not be allowed");
+ } catch (QueryNodeException expected) {
+ // expected exception
+ }
+ }
+
+ public void testBooleanQuery() throws Exception {
+ BooleanQuery.setMaxClauseCount(2);
+ try {
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(new WhitespaceAnalyzer(TEST_VERSION_CURRENT));
+
+ qp.parse("one two three", "field");
+ fail("ParseException expected due to too many boolean clauses");
+ } catch (QueryNodeException expected) {
+ // too many boolean clauses, so ParseException is expected
+ }
+ }
+
+ /**
+ * This test differs from TestPrecedenceQueryParser
+ */
+ public void testPrecedence() throws Exception {
+ AqpQueryParser qp1 = getParser();
+ qp1.setAnalyzer(new WhitespaceAnalyzer(TEST_VERSION_CURRENT));
+
+ AqpQueryParser qp2 = getParser();
+ qp2.setAnalyzer(new WhitespaceAnalyzer(TEST_VERSION_CURRENT));
+
+ // TODO: to achieve standard lucene behaviour (no operator precedence)
+ // modify the GroupQueryNodeProcessor to recognize our new BooleanQN classes
+ // then do:
+ QueryNodeProcessorPipeline processor = (QueryNodeProcessorPipeline) qp1
+ .getQueryNodeProcessor();
+ processor.add(new GroupQueryNodeProcessor());
+
+ Query query1 = qp1.parse("A AND B OR C AND D", "field");
+ Query query2 = qp2.parse("+A +B +C +D", "field");
+
+ assertEquals(query1, query2);
+ }
+
+ public void testLocalDateFormat() throws IOException, QueryNodeException,
+ ParseException {
+ Directory ramDir = new RAMDirectory();
+ IndexWriter iw = new IndexWriter(ramDir, newIndexWriterConfig(
+ TEST_VERSION_CURRENT, new WhitespaceAnalyzer(TEST_VERSION_CURRENT)));
+ addDateDoc("a", 2005, 12, 2, 10, 15, 33, iw);
+ addDateDoc("b", 2005, 12, 4, 22, 15, 00, iw);
+ iw.close();
+ IndexSearcher is = new IndexSearcher(DirectoryReader.open(ramDir));
+
+ SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy", Locale.ROOT);
+ Date d1_12 = format.parse("1/12/2005");
+ Date d3_12 = format.parse("3/12/2005");
+ Date d4_12 = format.parse("4/12/2005");
+ Date d28_12 = format.parse("28/12/2005");
+
+ DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT,
+ Locale.getDefault());
+ String dec1 = df.format(d1_12);
+ String dec2 = df.format(format.parse("2/12/2005"));
+ String dec3 = df.format(d3_12);
+ String dec4 = df.format(d4_12);
+ String dec28 = df.format(d28_12);
+
+ assertHits(2, String.format("[%s TO %s]", dec1, dec28), is);
+ assertHits(2, String.format("[%s TO %s]", dec1, dec4), is);
+
+ assertHits(2, String.format("{%s TO %s}", dec1, dec28), is);
+ assertHits(1, String.format("{%s TO %s}", dec1, dec4), is);
+ assertHits(0, String.format("{%s TO %s}", dec3, dec4), is);
+
+ ramDir.close();
+ }
+
+ public void testStopwords() throws Exception {
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(new StopAnalyzer(TEST_VERSION_CURRENT, StopFilter
+ .makeStopSet(TEST_VERSION_CURRENT, "the", "foo")));
+
+ Query result = qp.parse("a:the OR a:foo", "a");
+ assertNotNull("result is null and it shouldn't be", result);
+ assertTrue("result is not a BooleanQuery", result instanceof BooleanQuery);
+ assertTrue(((BooleanQuery) result).clauses().size() + " does not equal: "
+ + 0, ((BooleanQuery) result).clauses().size() == 0);
+ result = qp.parse("a:woo OR a:the", "a");
+ assertNotNull("result is null and it shouldn't be", result);
+ assertTrue("result is not a TermQuery", result instanceof TermQuery);
+
+ result = qp.parse(
+ "(fieldX:xxxxx OR fieldy:xxxxxxxx)^2 AND (fieldx:the OR fieldy:foo)",
+ "a");
+
+ assertNotNull("result is null and it shouldn't be", result);
+ assertTrue("result is not a BooleanQuery", result instanceof BooleanQuery);
+ if (VERBOSE)
+ System.out.println("Result: " + result);
+ assertTrue(((BooleanQuery) result).clauses().size() + " does not equal: "
+ + 2, ((BooleanQuery) result).clauses().size() == 2);
+ }
+
+ public void testPositionIncrement() throws Exception {
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(new StopAnalyzer(TEST_VERSION_CURRENT, StopFilter
+ .makeStopSet(TEST_VERSION_CURRENT, "the", "in", "are", "this")));
+
+ qp.setEnablePositionIncrements(true);
+
+ String qtxt = "\"the words in poisitions pos02578 are stopped in this phrasequery\"";
+ // 0 2 5 7 8
+ int expectedPositions[] = { 1, 3, 4, 6, 9 };
+ PhraseQuery pq = (PhraseQuery) qp.parse(qtxt, "a");
+ // System.out.println("Query text: "+qtxt);
+ // System.out.println("Result: "+pq);
+ Term t[] = pq.getTerms();
+ int pos[] = pq.getPositions();
+ for (int i = 0; i < t.length; i++) {
+ // System.out.println(i+". "+t[i]+" pos: "+pos[i]);
+ assertEquals("term " + i + " = " + t[i] + " has wrong term-position!",
+ expectedPositions[i], pos[i]);
+ }
+ }
+
+ public void testMatchAllDocs() throws Exception {
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(new WhitespaceAnalyzer(TEST_VERSION_CURRENT));
+
+ assertEquals(new MatchAllDocsQuery(), qp.parse("*:*", "field"));
+ assertEquals(new MatchAllDocsQuery(), qp.parse("(*:*)", "field"));
+ BooleanQuery bq = (BooleanQuery) qp.parse("+*:* -*:*", "field");
+ assertTrue(bq.getClauses()[0].getQuery() instanceof MatchAllDocsQuery);
+ assertTrue(bq.getClauses()[1].getQuery() instanceof MatchAllDocsQuery);
+ }
+
+ private class CannedTokenizer extends Tokenizer {
+ private int upto = 0;
+ private final PositionIncrementAttribute posIncr = addAttribute(PositionIncrementAttribute.class);
+ private final CharTermAttribute term = addAttribute(CharTermAttribute.class);
+
+ public CannedTokenizer(Reader reader) {
+ super(reader);
+ }
+
+ @Override
+ public boolean incrementToken() {
+ clearAttributes();
+ if (upto == 4) {
+ return false;
+ }
+ if (upto == 0) {
+ posIncr.setPositionIncrement(1);
+ term.setEmpty().append("a");
+ } else if (upto == 1) {
+ posIncr.setPositionIncrement(1);
+ term.setEmpty().append("b");
+ } else if (upto == 2) {
+ posIncr.setPositionIncrement(0);
+ term.setEmpty().append("c");
+ } else {
+ posIncr.setPositionIncrement(0);
+ term.setEmpty().append("d");
+ }
+ upto++;
+ return true;
+ }
+
+ @Override
+ public void reset() throws IOException {
+ super.reset();
+ this.upto = 0;
+ }
+ }
+
+ private class CannedAnalyzer extends Analyzer {
+ @Override
+ public TokenStreamComponents createComponents(String ignored,
+ Reader alsoIgnored) {
+ return new TokenStreamComponents(new CannedTokenizer(alsoIgnored));
+ }
+ }
+
+ public void testMultiPhraseQuery() throws Exception {
+ Directory dir = newDirectory();
+ IndexWriter w = new IndexWriter(dir, newIndexWriterConfig(
+ TEST_VERSION_CURRENT, new CannedAnalyzer()));
+ Document doc = new Document();
+ doc.add(newField("field", "", TextField.TYPE_NOT_STORED));
+ w.addDocument(doc);
+ w.commit();
+ IndexReader r = DirectoryReader.open(w.getDirectory());
+ IndexSearcher s = newSearcher(r);
+
+ Query q = QPTestParser.init(new CannedAnalyzer()).parse("\"a\"", "field");
+ assertTrue(q instanceof MultiPhraseQuery);
+ assertEquals(1, s.search(q, 10).totalHits);
+ r.close();
+ w.close();
+ dir.close();
+ }
+
+ // Uniquely for Junit 3
+ public static junit.framework.Test suite() {
+ return new junit.framework.JUnit4TestAdapter(TestAqpSLGStandardTest.class);
+ }
+
+}
Index: lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGMultiAnalyzer.java
===================================================================
--- lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGMultiAnalyzer.java (revision 0)
+++ lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGMultiAnalyzer.java (revision 0)
@@ -0,0 +1,268 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+import java.io.Reader;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.MockTokenizer;
+import org.apache.lucene.analysis.TokenFilter;
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.Tokenizer;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
+import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
+import org.apache.lucene.analysis.tokenattributes.TypeAttribute;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler.Operator;
+import org.apache.lucene.queryparser.flexible.aqp.AqpQueryParser;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardLuceneParser;
+import org.apache.lucene.search.Query;
+
+/**
+ * This test case is a copy of the core Lucene query parser test, it was adapted
+ * to use new QueryParserHelper instead of the old query parser.
+ *
+ * Test QueryParser's ability to deal with Analyzers that return more than one
+ * token per position or that return tokens with a position increment > 1.
+ */
+public class TestAqpSLGMultiAnalyzer extends AqpTestAbstractCase {
+
+ private static int multiToken = 0;
+
+ public void testMultiAnalyzer() throws QueryNodeException, Exception {
+
+ AqpQueryParser qp = getParser();
+ qp.setDefaultOperator(Operator.OR);
+ qp.setAnalyzer(new MultiAnalyzer());
+
+ // trivial, no multiple tokens:
+ assertEquals("foo", qp.parse("foo", "").toString());
+ assertEquals("foo", qp.parse("\"foo\"", "").toString());
+ assertEquals("foo foobar", qp.parse("foo foobar", "").toString());
+ assertEquals("\"foo foobar\"", qp.parse("\"foo foobar\"", "").toString());
+ assertEquals("\"foo foobar blah\"", qp.parse("\"foo foobar blah\"", "")
+ .toString());
+
+ // two tokens at the same position:
+ assertEquals("(multi multi2) foo", qp.parse("multi foo", "").toString());
+ assertEquals("foo (multi multi2)", qp.parse("foo multi", "").toString());
+ assertEquals("(multi multi2) (multi multi2)", qp.parse("multi multi", "")
+ .toString());
+ Query q = qp.parse("(foo multi) +(bar multi)", "");
+ assertEquals("foo (multi multi2) +(bar (multi multi2))",
+ qp.parse("(foo multi) +(bar multi)", "").toString());
+ assertEquals("+(foo (multi multi2)) field:\"bar (multi multi2)\"", qp
+ .parse("+(foo multi) field:\"bar multi\"", "").toString());
+
+ // phrases:
+ assertEquals("\"(multi multi2) foo\"", qp.parse("\"multi foo\"", "")
+ .toString());
+ assertEquals("\"foo (multi multi2)\"", qp.parse("\"foo multi\"", "")
+ .toString());
+ assertEquals("\"foo (multi multi2) foobar (multi multi2)\"",
+ qp.parse("\"foo multi foobar multi\"", "").toString());
+
+ // fields:
+ assertEquals("(field:multi field:multi2) field:foo",
+ qp.parse("field:multi field:foo", "").toString());
+ assertEquals("field:\"(multi multi2) foo\"",
+ qp.parse("field:\"multi foo\"", "").toString());
+
+ // three tokens at one position:
+ assertEquals("triplemulti multi3 multi2", qp.parse("triplemulti", "")
+ .toString());
+ assertEquals("foo (triplemulti multi3 multi2) foobar",
+ qp.parse("foo triplemulti foobar", "").toString());
+
+ // phrase with non-default slop:
+ assertEquals("\"(multi multi2) foo\"~10", qp.parse("\"multi foo\"~10", "")
+ .toString());
+
+ // phrase with non-default boost:
+ assertEquals("\"(multi multi2) foo\"^2.0", qp.parse("\"multi foo\"^2", "")
+ .toString());
+
+ // phrase after changing default slop
+ qp.setDefaultPhraseSlop(99);
+ assertEquals("\"(multi multi2) foo\"~99 bar",
+ qp.parse("\"multi foo\" bar", "").toString());
+ assertEquals("\"(multi multi2) foo\"~99 \"foo bar\"~2",
+ qp.parse("\"multi foo\" \"foo bar\"~2", "").toString());
+ qp.setDefaultPhraseSlop(0);
+
+ // non-default operator:
+ qp.setDefaultOperator(Operator.AND);
+ assertEquals("+(multi multi2) +foo", qp.parse("multi foo", "").toString());
+
+ }
+
+ // public void testMultiAnalyzerWithSubclassOfQueryParser() throws
+ // ParseException {
+ // this test doesn't make sense when using the new QueryParser API
+ // DumbQueryParser qp = new DumbQueryParser("", new MultiAnalyzer());
+ // qp.setPhraseSlop(99); // modified default slop
+ //
+ // // direct call to (super's) getFieldQuery to demonstrate differnce
+ // // between phrase and multiphrase with modified default slop
+ // assertEquals("\"foo bar\"~99",
+ // qp.getSuperFieldQuery("","foo bar").toString());
+ // assertEquals("\"(multi multi2) bar\"~99",
+ // qp.getSuperFieldQuery("","multi bar").toString());
+ //
+ //
+ // // ask sublcass to parse phrase with modified default slop
+ // assertEquals("\"(multi multi2) foo\"~99 bar",
+ // qp.parse("\"multi foo\" bar").toString());
+ //
+ // }
+
+ public void testPosIncrementAnalyzer() throws QueryNodeException, Exception {
+ AqpQueryParser qp = getParser();
+ qp.setDefaultOperator(Operator.OR);
+
+ qp.setAnalyzer(new PosIncrementAnalyzer());
+
+ assertEquals("quick brown", qp.parse("the quick brown", "").toString());
+ assertEquals("\"quick brown\"", qp.parse("\"the quick brown\"", "")
+ .toString());
+ assertEquals("quick brown fox", qp.parse("the quick brown fox", "")
+ .toString());
+ assertEquals("\"quick brown fox\"", qp.parse("\"the quick brown fox\"", "")
+ .toString());
+ }
+
+ /**
+ * Expands "multi" to "multi" and "multi2", both at the same position, and
+ * expands "triplemulti" to "triplemulti", "multi3", and "multi2".
+ */
+ private class MultiAnalyzer extends Analyzer {
+
+ @Override
+ public TokenStreamComponents createComponents(String fieldName,
+ Reader reader) {
+ Tokenizer result = new MockTokenizer(reader, MockTokenizer.WHITESPACE,
+ true);
+ return new TokenStreamComponents(result, new TestFilter(result));
+ }
+ }
+
+ private final class TestFilter extends TokenFilter {
+
+ private String prevType;
+ private int prevStartOffset;
+ private int prevEndOffset;
+
+ private final CharTermAttribute termAtt = addAttribute(CharTermAttribute.class);
+ private final PositionIncrementAttribute posIncrAtt = addAttribute(PositionIncrementAttribute.class);
+ private final OffsetAttribute offsetAtt = addAttribute(OffsetAttribute.class);
+ private final TypeAttribute typeAtt = addAttribute(TypeAttribute.class);
+
+ public TestFilter(TokenStream in) {
+ super(in);
+ }
+
+ @Override
+ public final boolean incrementToken() throws java.io.IOException {
+ if (multiToken > 0) {
+ termAtt.setEmpty().append("multi" + (multiToken + 1));
+ offsetAtt.setOffset(prevStartOffset, prevEndOffset);
+ typeAtt.setType(prevType);
+ posIncrAtt.setPositionIncrement(0);
+ multiToken--;
+ return true;
+ } else {
+ boolean next = input.incrementToken();
+ if (!next) {
+ return false;
+ }
+ prevType = typeAtt.type();
+ prevStartOffset = offsetAtt.startOffset();
+ prevEndOffset = offsetAtt.endOffset();
+ String text = termAtt.toString();
+ if (text.equals("triplemulti")) {
+ multiToken = 2;
+ return true;
+ } else if (text.equals("multi")) {
+ multiToken = 1;
+ return true;
+ } else {
+ return true;
+ }
+ }
+ }
+
+ @Override
+ public void reset() throws IOException {
+ super.reset();
+ this.prevType = null;
+ this.prevStartOffset = 0;
+ this.prevEndOffset = 0;
+ }
+ }
+
+ /**
+ * Analyzes "the quick brown" as: quick(incr=2) brown(incr=1). Does not work
+ * correctly for input other than "the quick brown ...".
+ */
+ private class PosIncrementAnalyzer extends Analyzer {
+
+ @Override
+ public TokenStreamComponents createComponents(String fieldName,
+ Reader reader) {
+ Tokenizer result = new MockTokenizer(reader, MockTokenizer.WHITESPACE,
+ true);
+ return new TokenStreamComponents(result, new TestPosIncrementFilter(
+ result));
+ }
+ }
+
+ private class TestPosIncrementFilter extends TokenFilter {
+
+ private final CharTermAttribute termAtt = addAttribute(CharTermAttribute.class);
+ private final PositionIncrementAttribute posIncrAtt = addAttribute(PositionIncrementAttribute.class);
+
+ public TestPosIncrementFilter(TokenStream in) {
+ super(in);
+ }
+
+ @Override
+ public final boolean incrementToken() throws java.io.IOException {
+ while (input.incrementToken()) {
+ if (termAtt.toString().equals("the")) {
+ // stopword, do nothing
+ } else if (termAtt.toString().equals("quick")) {
+ posIncrAtt.setPositionIncrement(2);
+ return true;
+ } else {
+ posIncrAtt.setPositionIncrement(1);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ }
+
+ // Uniquely for Junit 3
+ public static junit.framework.Test suite() {
+ return new junit.framework.JUnit4TestAdapter(TestAqpSLGMultiAnalyzer.class);
+ }
+
+}
Index: lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/parser/BuildAST.java
===================================================================
--- lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/parser/BuildAST.java (revision 0)
+++ lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/parser/BuildAST.java (revision 0)
@@ -0,0 +1,109 @@
+package org.apache.lucene.queryparser.flexible.aqp.parser;
+
+import org.antlr.runtime.*;
+import org.antlr.runtime.tree.*;
+import org.antlr.stringtemplate.*;
+import java.lang.reflect.*;
+
+import org.apache.lucene.queryparser.flexible.aqp.parser.*;
+
+/**
+ * A utility class for generating the dot/graph representations of the query
+ *
+ *
+ */
+
+// import
+// org.apache.lucene.queryparser.flexible.aqp.parser.StandardLuceneGrammarLexer;
+// import
+// org.apache.lucene.queryparser.flexible.aqp.parser.StandardLuceneGrammarParser;
+
+/*
+ * Arguments: - grammar - query - rule-name (optional, default "mainQ") - action
+ * (optional, default: dot)
+ */
+public class BuildAST {
+ @SuppressWarnings("unchecked")
+ public static void main(String[] args) throws Exception {
+ String grammar = args[0];
+ String ruleName = "mainQ";
+ String action = "dot";
+
+ if (args.length > 2) {
+ ruleName = args[2];
+ }
+
+ if (args.length > 3) {
+ if (args[3].toLowerCase().equals("dot")) {
+ action = "dot";
+ } else if (args[3].toLowerCase().equals("tree")) {
+ action = "tree";
+ } else {
+ throw new Exception("Unknown argument " + args[3]
+ + ". Allowed actions: dot,tree");
+ }
+ }
+
+ System.err.println("Grammar: " + grammar + " rule:" + ruleName
+ + "\nquery: " + (args.length > 1 ? args[1] : "--"));
+ String input = args.length > 1 ? args[1] : "No input given";
+
+ ANTLRStringStream in = new ANTLRStringStream(input);
+ // Lexer lexer = new StandardLuceneGrammarLexer(in);
+ // CommonTokenStream ts = new CommonTokenStream(lexer);
+
+ // System.err.println(ts.toString());
+
+ // CommonTokenStream tokens = new CommonTokenStream(lexer);
+
+ // StandardLuceneGrammarParser parser = new
+ // StandardLuceneGrammarParser(tokens);
+ // StandardLuceneGrammarParser.mainQ_return returnValue = parser.mainQ();
+ // CommonTree tree = (CommonTree)returnValue.getTree();
+
+ // get the Classes
+ Class clsLexer = Class
+ .forName("org.apache.lucene.queryparser.flexible.aqp.parser." + grammar
+ + "Lexer");
+ Class clsParser = Class
+ .forName("org.apache.lucene.queryparser.flexible.aqp.parser." + grammar
+ + "Parser");
+
+ // insantiate lexer with one parameter
+ Class partypes[] = new Class[1];
+ partypes[0] = CharStream.class;
+ Constructor ctLexer = clsLexer.getConstructor(partypes);
+
+ Object arglist[] = new Object[1];
+ arglist[0] = in;
+ Object iLexer = ctLexer.newInstance(arglist);
+
+ // get tokens
+ CommonTokenStream tokens = new CommonTokenStream(
+ (TokenSource) clsLexer.cast(iLexer));
+
+ // instantiate parser using parameters
+ Class partypes2[] = new Class[1];
+ partypes2[0] = TokenStream.class;
+ Constructor ct = clsParser.getConstructor(partypes2);
+
+ Object arglist2[] = new Object[1];
+ arglist2[0] = tokens;
+ Object iParser = ct.newInstance(arglist2);
+
+ // call the mainQ parser rule
+ Method iParserMainQ = clsParser.getDeclaredMethod(ruleName);
+ Object retVal = iParserMainQ.invoke(iParser);
+ Method getMethod = iParserMainQ.getReturnType().getMethod("getTree");
+ CommonTree tree = (CommonTree) (getMethod.invoke(retVal));
+
+ // print the output
+ if (action.equals("dot")) {
+ DOTTreeGenerator gen = new DOTTreeGenerator();
+ StringTemplate st = gen.toDOT(tree);
+ System.out.println(st);
+ } else if (action.equals("tree")) {
+ System.out.println(tree.toStringTree());
+ }
+ }
+}
Index: lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/AqpTestAbstractCase.java
===================================================================
--- lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/AqpTestAbstractCase.java (revision 0)
+++ lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/AqpTestAbstractCase.java (revision 0)
@@ -0,0 +1,430 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+import java.text.DateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Iterator;
+import java.util.Locale;
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.core.SimpleAnalyzer;
+import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
+import org.apache.lucene.document.DateTools;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.StringField;
+import org.apache.lucene.document.TextField;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.QueryParserHelper;
+import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler;
+import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
+import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor;
+import org.apache.lucene.queryparser.flexible.standard.QueryParserUtil;
+import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler.Operator;
+import org.apache.lucene.queryparser.flexible.standard.processors.StandardQueryNodeProcessorPipeline;
+import org.apache.lucene.queryparser.flexible.aqp.AqpQueryParser;
+import org.apache.lucene.queryparser.flexible.aqp.parser.AqpStandardLuceneParser;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreDoc;
+import org.apache.lucene.util.LuceneTestCase;
+
+/**
+ * This test case is a copy of the core Lucene query parser test, it was adapted
+ * to use new QueryParserHelper instead of the old query parser.
+ *
+ * Tests QueryParser.
+ */
+public class AqpTestAbstractCase extends LuceneTestCase {
+
+ public int originalMaxClauses;
+ public boolean debugParser = false;
+ protected String grammarName = "StandardLuceneGrammar";
+ protected int noFailures = 0;
+
+ public void setUp() throws Exception {
+ super.setUp();
+ originalMaxClauses = BooleanQuery.getMaxClauseCount();
+ }
+
+ public static void fail(String message) {
+ System.err.println(message);
+ LuceneTestCase.fail(message);
+ }
+
+ public void setDebug(boolean d) {
+ debugParser = d;
+ }
+
+ public void setGrammarName(String name) {
+ grammarName = name;
+ }
+
+ public String getGrammarName() {
+ return grammarName;
+ }
+
+ public AqpQueryParser getParser(Analyzer a) throws Exception {
+ if (a == null)
+ a = new SimpleAnalyzer(TEST_VERSION_CURRENT);
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(a);
+ return qp;
+
+ }
+
+ public QueryParserHelper getParser(Analyzer a, boolean standard)
+ throws Exception {
+ if (standard) {
+ StandardQueryParser sp = new StandardQueryParser(a);
+ if (this.debugParser) {
+ sp.setQueryNodeProcessor(new DebuggingQueryNodeProcessorPipeline(sp
+ .getQueryConfigHandler()));
+ }
+ return sp;
+ } else {
+ return getParser(a);
+ }
+ }
+
+ public AqpQueryParser getParser() throws Exception {
+ AqpQueryParser qp = AqpStandardLuceneParser.init(getGrammarName());
+ qp.setDebug(this.debugParser);
+ return qp;
+ }
+
+ public Query getQuery(String query, Analyzer a) throws Exception {
+ return getParser(a).parse(query, "field");
+ }
+
+ public Query getQueryAllowLeadingWildcard(String query, Analyzer a)
+ throws Exception {
+ AqpQueryParser parser = getParser(a);
+ parser.setAllowLeadingWildcard(true);
+ return parser.parse(query, "field");
+ }
+
+ public Query assertQueryEquals(String query, Analyzer a, String result)
+ throws Exception {
+ Query q = getQuery(query, a);
+ String s = q.toString("field");
+ if (!s.equals(result)) {
+ debugFail(q.toString(), result, s);
+ }
+ return q;
+ }
+
+ public Query assertQueryEquals(String query, Analyzer a, String result,
+ Class clazz) throws Exception {
+ Query q = assertQueryEquals(query, a, result);
+ if (!q.getClass().isAssignableFrom(clazz)) {
+ debugFail(q.toString(), result,
+ "Query is not: " + clazz + " but: " + q.getClass());
+ }
+ return q;
+ }
+
+ public void assertQueryEqualsAllowLeadingWildcard(String query, Analyzer a,
+ String result) throws Exception {
+ Query q = getQueryAllowLeadingWildcard(query, a);
+ String s = q.toString("field");
+ if (!s.equals(result)) {
+ fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
+ + "/");
+ }
+ }
+
+ public void assertQueryEquals(AqpQueryParser qp, String field, String query,
+ String result) throws Exception {
+ Query q = qp.parse(query, field);
+ String s = q.toString(field);
+ if (!s.equals(result)) {
+ fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
+ + "/");
+ }
+ }
+
+ public void assertEscapedQueryEquals(String query, Analyzer a, String result)
+ throws Exception {
+ String escapedQuery = QueryParserUtil.escape(query);
+ if (!escapedQuery.equals(result)) {
+ fail("Query /" + query + "/ yielded /" + escapedQuery + "/, expecting /"
+ + result + "/");
+ }
+ }
+
+ public void assertWildcardQueryEquals(String query, boolean lowercase,
+ String result, boolean allowLeadingWildcard) throws Exception {
+ AqpQueryParser qp = getParser(null);
+ qp.setLowercaseExpandedTerms(lowercase);
+ qp.setAllowLeadingWildcard(allowLeadingWildcard);
+ Query q = qp.parse(query, "field");
+ String s = q.toString("field");
+ if (!s.equals(result)) {
+ fail("WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /"
+ + result + "/");
+ }
+ }
+
+ public void assertWildcardQueryEquals(String query, boolean lowercase,
+ String result) throws Exception {
+ assertWildcardQueryEquals(query, lowercase, result, false);
+ }
+
+ public void assertWildcardQueryEquals(String query, String result)
+ throws Exception {
+ AqpQueryParser qp = getParser(null);
+ Query q = qp.parse(query, "field");
+ String s = q.toString("field");
+ if (!s.equals(result)) {
+ fail("WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /"
+ + result + "/");
+ }
+ }
+
+ public Query getQueryDOA(String query, Analyzer a) throws Exception {
+ if (a == null)
+ a = new SimpleAnalyzer(TEST_VERSION_CURRENT);
+ AqpQueryParser qp = getParser();
+ qp.setAnalyzer(a);
+ qp.setDefaultOperator(Operator.AND);
+
+ return qp.parse(query, "field");
+
+ }
+
+ public void assertQueryEqualsDOA(String query, Analyzer a, String result)
+ throws Exception {
+ Query q = getQueryDOA(query, a);
+ String s = q.toString("field");
+ if (!s.equals(result)) {
+ fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
+ + "/");
+ }
+ }
+
+ /** for testing DateTools support */
+ private String getDate(String s, DateTools.Resolution resolution)
+ throws Exception {
+ DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
+ return getDate(df.parse(s), resolution);
+ }
+
+ /** for testing DateTools support */
+ private String getDate(Date d, DateTools.Resolution resolution) {
+ return DateTools.dateToString(d, resolution);
+ }
+
+ public String escapeDateString(String s) {
+ if (s.contains(" ")) {
+ return "\"" + s + "\"";
+ } else {
+ return s;
+ }
+ }
+
+ public String getLocalizedDate(int year, int month, int day) {
+ DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
+ Calendar calendar = new GregorianCalendar();
+ calendar.clear();
+ calendar.set(year, month, day);
+ calendar.set(Calendar.HOUR_OF_DAY, 23);
+ calendar.set(Calendar.MINUTE, 59);
+ calendar.set(Calendar.SECOND, 59);
+ calendar.set(Calendar.MILLISECOND, 999);
+ return df.format(calendar.getTime());
+ }
+
+ public void assertDateRangeQueryEquals(AqpQueryParser qp, String field,
+ String startDate, String endDate, Date endDateInclusive,
+ DateTools.Resolution resolution) throws Exception {
+ assertQueryEquals(
+ qp,
+ field,
+ field + ":[" + escapeDateString(startDate) + " TO "
+ + escapeDateString(endDate) + "]",
+ "[" + getDate(startDate, resolution) + " TO "
+ + getDate(endDateInclusive, resolution) + "]");
+ assertQueryEquals(
+ qp,
+ field,
+ field + ":{" + escapeDateString(startDate) + " TO "
+ + escapeDateString(endDate) + "}",
+ "{" + getDate(startDate, resolution) + " TO "
+ + getDate(endDate, resolution) + "}");
+ }
+
+ public void assertHits(int expected, String query, IndexSearcher is)
+ throws IOException, QueryNodeException {
+ AqpQueryParser qp;
+ try {
+ qp = getParser();
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new QueryNodeException(e);
+ }
+ qp.setAnalyzer(new WhitespaceAnalyzer(TEST_VERSION_CURRENT));
+ // qp.setLocale(Locale.ENGLISH);
+ qp.setDateResolution(DateTools.Resolution.DAY);
+
+ Query q = qp.parse(query, "date");
+ ScoreDoc[] hits = is.search(q, null, 1000).scoreDocs;
+ assertEquals(expected, hits.length);
+ }
+
+ public void assertQueryNodeException(String queryString) throws Exception {
+ try {
+ getQuery(queryString, null);
+ } catch (QueryNodeException expected) {
+ return;
+ }
+ debugFail("ParseException expected, not thrown");
+ }
+
+ public void addDateDoc(String content, int year, int month, int day,
+ int hour, int minute, int second, IndexWriter iw) throws IOException {
+ Document d = new Document();
+ d.add(new Field("f", content, TextField.TYPE_STORED));
+ Calendar cal = Calendar.getInstance(Locale.ROOT);
+ cal.set(year, month - 1, day, hour, minute, second);
+ d.add(new Field("date", getDate(cal.getTime(), DateTools.Resolution.DAY),
+ StringField.TYPE_NOT_STORED));
+ iw.addDocument(d);
+ }
+
+ public void assertQueryMatch(AqpQueryParser qp, String queryString,
+ String defaultField, String expectedResult) throws Exception {
+
+ try {
+ Query query = qp.parse(queryString, defaultField);
+ String queryParsed = query.toString();
+
+ if (!queryParsed.equals(expectedResult)) {
+
+ if (this.debugParser) {
+
+ System.out.println("query:\t\t" + queryString);
+
+ if (qp.getDebug() != true) { // it already printed debug
+ qp.setDebug(true);
+ qp.parse(queryString, defaultField);
+ qp.setDebug(false);
+ }
+ System.out.println("");
+ System.out.println("query:\t\t" + queryString);
+ System.out.println("result:\t\t" + queryParsed);
+
+ }
+
+ String msg = "Query /" + queryString + "/ with field: " + defaultField
+ + "/ yielded /" + queryParsed + "/, expecting /" + expectedResult
+ + "/";
+
+ debugFail(queryString, expectedResult, queryParsed);
+
+ } else {
+ if (this.debugParser) {
+ System.out.println("OK \"" + queryString + "\" ---> " + queryParsed);
+ }
+ }
+ } catch (Exception e) {
+ if (this.debugParser) {
+ System.err.println(queryString);
+ e.printStackTrace();
+ } else {
+ throw e;
+ }
+ }
+
+ }
+
+ public void debugFail(String message) {
+ if (this.debugParser) {
+ System.err.println("Number of failures: " + ++noFailures);
+ System.err.println(message);
+ } else {
+ fail(message);
+ }
+ }
+
+ public void debugFail(String query, String expected, String actual) {
+ if (this.debugParser) {
+ System.err.println("Number of failures: " + ++noFailures);
+ System.err.println("query:/" + query + "/ expected:/" + expected
+ + "/ actual:/" + actual + "/");
+ } else {
+ assertEquals(expected, actual);
+ }
+ }
+
+ @Override
+ public void tearDown() throws Exception {
+ BooleanQuery.setMaxClauseCount(originalMaxClauses);
+ super.tearDown();
+ }
+
+ class DebuggingQueryNodeProcessorPipeline extends
+ StandardQueryNodeProcessorPipeline {
+ DebuggingQueryNodeProcessorPipeline(QueryConfigHandler queryConfig) {
+ super(queryConfig);
+ }
+
+ public QueryNode process(QueryNode queryTree) throws QueryNodeException {
+ String oldVal = null;
+ String newVal = null;
+
+ oldVal = queryTree.toString();
+ int i = 1;
+ System.out.println(" 0. starting");
+ System.out.println("--------------------------------------------");
+ System.out.println(oldVal);
+
+ Iterator it = this.iterator();
+
+ QueryNodeProcessor processor;
+ while (it.hasNext()) {
+ processor = it.next();
+
+ System.out.println(" " + i + ". step "
+ + processor.getClass().toString());
+ queryTree = processor.process(queryTree);
+ newVal = queryTree.toString();
+ System.out.println(" Tree changed: "
+ + (newVal.equals(oldVal) ? "NO" : "YES"));
+ System.out.println("--------------------------------------------");
+ System.out.println(newVal);
+ oldVal = newVal;
+ i += 1;
+ }
+
+ System.out.println("");
+ System.out.println("final result:");
+ System.out.println("--------------------------------------------");
+ System.out.println(queryTree.toString());
+ return queryTree;
+
+ }
+ }
+
+}
Index: lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGSimple.java
===================================================================
--- lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGSimple.java (revision 0)
+++ lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/aqp/TestAqpSLGSimple.java (revision 0)
@@ -0,0 +1,240 @@
+package org.apache.lucene.queryparser.flexible.aqp;
+
+import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.core.builders.QueryTreeBuilder;
+import org.apache.lucene.queryparser.flexible.core.nodes.BooleanQueryNode;
+import org.apache.lucene.queryparser.flexible.core.nodes.BoostQueryNode;
+import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser;
+import org.apache.lucene.queryparser.flexible.standard.builders.BooleanQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.builders.BoostQueryNodeBuilder;
+import org.apache.lucene.queryparser.flexible.standard.config.StandardQueryConfigHandler.Operator;
+import org.apache.lucene.queryparser.flexible.aqp.AqpQueryParser;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.Query;
+
+/**
+ * This test case is a copy of the core Lucene query parser test, it was adapted
+ * to use new QueryParserHelper instead of the old query parser.
+ *
+ * Tests QueryParser.
+ */
+public class TestAqpSLGSimple extends AqpTestAbstractCase {
+
+ private boolean verbose = true;
+
+ private int originalMaxClauses;
+
+ @Override
+ public void setUp() throws Exception {
+ super.setUp();
+ originalMaxClauses = BooleanQuery.getMaxClauseCount();
+ setGrammarName("StandardLuceneGrammar");
+ }
+
+ public void testBooleanQuery() throws Exception {
+
+ WhitespaceAnalyzer analyzer = new WhitespaceAnalyzer(TEST_VERSION_CURRENT);
+
+ AqpQueryParser qp = getParser(analyzer);
+
+ StandardQueryParser sp = (StandardQueryParser) getParser(analyzer, true);
+
+ // DEFAULT OPERATOR IS AND
+ qp.setDefaultOperator(Operator.AND);
+ sp.setDefaultOperator(Operator.AND);
+
+ // test the clause rewriting/optimization
+ Query q = qp.parse("a -(-(+(-(x)^0.6))^0.2)^0.3", "");
+ assertQueryMatch(qp, "a -(-(+(-(x)^0.6))^0.2)^0.3", "", "+a -x^0.3");
+ assertQueryMatch(qp, "-(-(+(-(x)^0.6))^0.2)^0.3", "", "x^0.3"); // not
+ // minus,
+ // because
+ // that is
+ // not
+ // allowed
+ assertQueryMatch(qp, "-(-(+(-(x)^0.6))^0.2)^", "", "x"); // because defualt
+ // boost is 1.0f
+ assertQueryMatch(qp, "-(-(+(-(x)^))^0.2)^0.1", "", "x^0.1"); // because
+ // defualt
+ // boost is
+ // 1.0f
+
+ Query qa = sp.parse("kahnn-strauss", "x");
+ Query qb = qp.parse("kahnn-strauss", "x");
+ assertQueryMatch(qp, "kahnn-strauss", "x", qa.toString());
+
+ qa = sp.parse("a \\\"b \\\"c d", "x");
+ qb = qp.parse("a \\\"b \\\"c d", "x");
+ assertQueryMatch(qp, "a \\\"b \\\"c d", "x", qa.toString());
+
+ qa = sp.parse("\"a \\\"b c\\\" d\"", "x");
+ qb = qp.parse("\"a \\\"b c\\\" d\"", "x");
+ assertQueryMatch(qp, "\"a \\\"b c\\\" d\"", "x", qa.toString());
+
+ assertQueryMatch(qp, "+(-(-(-(x)^0.6))^0.2)^", "field", "field:x");
+ assertQueryMatch(qp, "+(-(-(-(x)^0.6))^0.2)^0.5", "field", "field:x^0.5");
+
+ // the first element will be positive, because the negative X NOT Y
+ // is currently implemented that way (the first must return something)
+ // TODO: this should be:
+ // "((+field:a +field:b)^0.8) -((+field:x +field:y)^0.2)"
+
+ assertQueryMatch(qp, "(+(-(a b)))^0.8 OR -(x y)^0.2", "field",
+ "+((+field:a +field:b)^0.8) -((+field:x +field:y)^0.2)");
+
+ assertQueryMatch(qp, "(+(-(a b)))^0.8 AND -(x y)^0.2", "field",
+ "+((+field:a +field:b)^0.8) -((+field:x +field:y)^0.2)");
+
+ assertQueryMatch(qp, "(+(-(a b)))^0.8 -(x y)", "field",
+ "+((+field:a +field:b)^0.8) -(+field:x +field:y)");
+ // or does -(x y) have different semantics? ... -field:x -field:y
+ // +((-(+field:a +field:b))^0.8) -field:x -field:y
+
+ assertQueryMatch(qp, "+((+(-(a b)))^0.8)^0.7 OR -(x y)^0.2", "field",
+ "+((+field:a +field:b)^0.7) -((+field:x +field:y)^0.2)");
+
+ assertQueryMatch(qp, "+title:(dog cat)", "field", "+title:dog +title:cat");
+
+ assertQueryMatch(qp, "title:(+dog -cat)", "field", "+title:dog -title:cat");
+
+ assertQueryMatch(qp, "\\*", "field", "field:*");
+
+ assertQueryMatch(qp, "term~", "field", "field:term~2");
+ assertQueryMatch(qp, "term~1", "field", "field:term~1");
+ assertQueryMatch(qp, "term~2", "field", "field:term~2");
+
+ qp.setAllowSlowFuzzy(true);
+ assertQueryMatch(qp, "term~", "field", "field:term~0.5");
+ assertQueryMatch(qp, "term~0.1", "field", "field:term~0.1");
+ assertQueryMatch(qp, "term~0.2", "field", "field:term~0.2");
+ qp.setAllowSlowFuzzy(false);
+
+ assertQueryMatch(qp, "something", "field", "field:something");
+
+ assertQueryMatch(qp, "x:something", "field", "x:something");
+
+ assertQueryMatch(qp, "x:\"something else\"", "field",
+ "x:\"something else\"");
+
+ assertQueryMatch(qp, "x:\"someth*\"", "field", "x:someth*");
+
+ assertQueryMatch(qp, "x:\"someth?ng\"", "field", "x:someth?ng");
+
+ assertQueryMatch(qp, "A AND B C AND D", "field",
+ "+field:A +field:B +field:C +field:D");
+
+ assertQueryMatch(qp, "A AND B C AND D OR E", "field",
+ "+(+field:A +field:B) +((+field:C +field:D) field:E)");
+
+ assertQueryMatch(qp, "one OR +two", "f", "f:one +f:two");
+
+ assertQueryMatch(qp, "one OR two NOT three", "field",
+ "field:one (+field:two -field:three)");
+
+ assertQueryMatch(qp, "one OR (two AND three) NOT four", "field",
+ "field:one (+(+field:two +field:three) -field:four)");
+
+ assertQueryMatch(qp, "-one -two", "field", "-field:one -field:two");
+
+ assertQueryMatch(qp, "x:one NOT y:two -three^0.5", "field",
+ "+(+x:one -y:two) -field:three^0.5");
+
+ qp.setAllowSlowFuzzy(true);
+ assertQueryMatch(qp, "one NOT two -three~0.2", "field",
+ "+(+field:one -field:two) -field:three~0.2");
+
+ assertQueryMatch(qp, "one NOT two NOT three~0.2", "field",
+ "+field:one -field:two -field:three~0.2");
+
+ assertQueryMatch(qp, "one two^0.5 three~0.2", "field",
+ "+field:one +field:two^0.5 +field:three~0.2");
+ qp.setAllowSlowFuzzy(false);
+
+ assertQueryMatch(qp, "one NOT two -three~0.2", "field",
+ "+(+field:one -field:two) -field:three~2");
+
+ assertQueryMatch(qp, "one NOT two NOT three~0.2", "field",
+ "+field:one -field:two -field:three~2");
+
+ assertQueryMatch(qp, "one two^0.5 three~0.2", "field",
+ "+field:one +field:two^0.5 +field:three~2");
+
+ q = qp.parse("one (two three)^0.8", "field");
+
+ // I know where the problem is: builder does not have access
+ // to the config, so that when a default operator is changed
+ // *after* the parser was instantiated, the builder behaves
+ // the old way(s) -- this is a bigger problem, and I didn't
+ // want to change the flex parser API
+
+ ((QueryTreeBuilder) qp.getQueryBuilder()).setBuilder(BooleanQueryNode.class, new BooleanQueryNodeBuilder(BooleanClause.Occur.MUST));
+
+ qa = qp.parse("one (two three)^0.8", "field");
+ assertQueryMatch(qp, "one (two three)^0.8", "field",
+ "+field:one +((+field:two +field:three)^0.8)");
+
+ assertQueryMatch(qp, "one (x:two three)^0.8", "field",
+ "+field:one +((+x:two +field:three)^0.8)");
+
+ // TODO: the original value was -((+one:two +one:three)^0.8)
+ // but that is not a valid Lucene query (or is it?)
+ assertQueryMatch(qp, "-one:(two three)^0.8", "field",
+ "(+one:two +one:three)^0.8");
+
+
+ assertQueryMatch(qp, "one:(two three)^0.8", "field",
+ "(+one:two +one:three)^0.8");
+
+ assertQueryMatch(qp, "+one:(two three)^0.8", "field",
+ "(+one:two +one:three)^0.8");
+
+ assertQueryMatch(qp, "[one TO five]", "field", "field:[one TO five]");
+
+ assertQueryMatch(qp, "z:[one TO five]", "field", "z:[one TO five]");
+
+ assertQueryMatch(qp, "{one TO five}", "field", "field:{one TO five}");
+
+ assertQueryMatch(qp, "z:{one TO five}", "field", "z:{one TO five}");
+
+ assertQueryMatch(qp, "z:{\"one\" TO \"five\"}", "field", "z:{one TO five}");
+
+ assertQueryMatch(qp, "z:{one TO *}", "field", "z:{one TO *}");
+
+ assertQueryMatch(qp, "this +(that)", "field", "+field:this +field:that");
+
+ assertQueryMatch(qp, "(this) (that)", "field", "+field:this +field:that");
+
+ assertQueryMatch(qp, "this ((((+(that))))) ", "field",
+ "+field:this +field:that");
+
+ assertQueryMatch(qp, "this (+(that)^0.7)", "field",
+ "+field:this +field:that^0.7");
+
+ assertQueryMatch(qp, "this (+(that thus)^0.7)", "field",
+ "+field:this +((+field:that +field:thus)^0.7)");
+
+ assertQueryMatch(qp, "this (-(+(that thus))^0.7)", "field",
+ "+field:this -((+field:that +field:thus)^0.7)");
+
+ assertQueryMatch(qp, "this (+(-(+(-(that thus))^0.1))^0.3)", "field",
+ "+field:this +((+field:that +field:thus)^0.3)");
+
+ BooleanQuery.setMaxClauseCount(2);
+ try {
+ qp = getParser(new WhitespaceAnalyzer(TEST_VERSION_CURRENT));
+
+ qp.parse("one two three", "field");
+ fail("ParseException expected due to too many boolean clauses");
+ } catch (QueryNodeException expected) {
+ // too many boolean clauses, so ParseException is expected
+ }
+ }
+
+ // Uniquely for Junit 3
+ public static junit.framework.Test suite() {
+ return new junit.framework.JUnit4TestAdapter(TestAqpSLGSimple.class);
+ }
+
+}
Index: lucene/queryparser/grammars/build.properties
===================================================================
--- lucene/queryparser/grammars/build.properties (revision 0)
+++ lucene/queryparser/grammars/build.properties (revision 0)
@@ -0,0 +1,16 @@
+
+# Adjust these if you are building grammars using AQP
+# they are used only for generating the nice html charts
+# of parse trees for a grammar
+
+# command for the dot viewer
+# on mac, this might be "open -a graphviz"
+# or on linux /usr/bin/xdot
+
+dot_viewer=xdot
+
+svg_generator=dot
+
+java_executable=java
+
+python=python
\ No newline at end of file
Index: lucene/queryparser/grammars/generate_asts.py
===================================================================
--- lucene/queryparser/grammars/generate_asts.py (revision 0)
+++ lucene/queryparser/grammars/generate_asts.py (revision 0)
@@ -0,0 +1,201 @@
+
+import sys
+import subprocess as sub
+import os
+
+"""
+Simple utility script to generate HTML charts of how ANTLR parses
+every query and what is the resulting AST.
+"""
+
+def run(grammar_name, basedir='',
+ cp='.:../lib/antlr-3.4-complete.jar',
+ grammardir='',
+ java_executable='java',
+ dot_executable='dot'
+ ):
+
+
+ if not basedir:
+ basedir = os.path.abspath('../../build/queryparser')
+
+ old_dir = os.getcwd()
+
+ thisdir = grammardir
+ if not thisdir:
+ thisdir = os.path.dirname(os.path.abspath(__file__))
+ os.chdir(thisdir)
+
+ cp += os.pathsep + basedir
+
+ print "We'll generate ANTLR graphs\ngramar: %s\nbasedir: %s\nclasspath: %s\nparserdir: %s" % (grammar_name, basedir, cp, thisdir)
+
+ grammar_file = os.path.join(thisdir, grammar_name + '.g')
+
+ if not os.path.exists(grammar_file):
+ raise Exception('Grammar %s does not exist in classpath: %s' % (grammar_file, cp))
+
+ tmp_file = os.path.join(basedir, 'ast-tree.dot')
+ index_file = os.path.join(basedir, '%s.html' % grammar_name)
+ gunit_file = os.path.join(thisdir, grammar_name + '.gunit')
+ generate_ast_command = '%s -cp %s org.apache.lucene.queryparser.flexible.aqp.parser.BuildAST %s "%%s"' % (java_executable, cp, grammar_name)
+
+
+ generate_svg_command = '%s -Tsvg %s' % (dot_executable, tmp_file)
+
+ test_cases = load_gunit_file(gunit_file)
+
+ index_fo = open(index_file, 'w')
+ index_fo.write('Test cases generated from grammar: %s
\n' % grammar_name)
+
+ out_lines = []
+ i = 0
+ cmds = generate_ast_command.split()
+ cmds_svg = generate_svg_command.split()
+
+ total = sum(map(lambda x: len(x), test_cases.values()))
+
+ toc = []
+ data = []
+
+ toc.append('')
+
+ for section,values in test_cases.items():
+ output = tree = svg = ''
+
+ toc.append('The rule: %s
' % (section, section))
+
+ # generate AST tree
+ for query in values:
+ i += 1
+ cmds[-1] = query
+
+ #tmp_dot = os.path.join(basedir, 'tmp-%s.dot' % i)
+
+ tmp_dot = tmp_file
+
+ if os.path.exists(tmp_dot):
+ os.remove(tmp_dot)
+
+ toc.append('%s. %s
' % (i, i, query))
+
+ print '// %s/%s :: %s' % (i, total, query)
+
+
+ #generate graph
+ p = sub.Popen(cmds,stdout=sub.PIPE,stderr=sub.PIPE)
+
+ output, errors = p.communicate()
+ if output:
+ fo = open(tmp_dot, 'w')
+ fo.write(output)
+ fo.close()
+ else:
+ print 'Error generating AST for: ' + query
+ print errors
+ if 'java.lang.ClassNotFoundException' in errors:
+ raise Exception('Please fix your classpath')
+ continue
+
+ #generate tree
+ cmds.append(section)
+ cmds.append("tree")
+ p = sub.Popen(cmds,stdout=sub.PIPE,stderr=sub.PIPE)
+
+ tree, errors = p.communicate()
+ if tree:
+ q = query.replace('\\', '\\\\').replace('"', '\\"').replace('\'', '\\\'')
+ t = tree.strip().replace('\\', '\\\\').replace('"', '\\"').replace("'", "\\'")
+ print "\"%s\" -> \"%s\"" % (q, t)
+ else:
+ print 'Error generating AST for: ' + query
+ print errors
+ tree = errors
+
+ cmds.pop()
+ cmds.pop()
+
+ cmds_svg[-1] = tmp_dot
+
+ try:
+ p = sub.Popen(cmds_svg,stdout=sub.PIPE,stderr=sub.PIPE)
+ except Exception, e:
+ print "The following command failed:"
+ print ' '.join(cmds_svg)
+ raise e
+
+ output, errors = p.communicate()
+
+ data.append(' %s. %s ^
' % (i, i, query))
+ data.append(output)
+ data.append('
' + tree + '
')
+ data.append('
')
+
+ index_fo.write('''
+
+
+
+
+
+
+ ''')
+ index_fo.write('\n'.join(toc))
+ index_fo.write('\n'.join(data))
+
+ index_fo.write('''
+