• Home
• com.google.gerrit
• gerrit-plugin-api
• 3.6.8
• source code
• QueryParser.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

antlr3.com.google.gerrit.index.query.QueryParser Maven / Gradle / Ivy

// $ANTLR 3.5.2 antlr3/com/google/gerrit/index/query/Query.g 2023-11-23 23:02:20

package com.google.gerrit.index.query;


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")
public class QueryParser extends Parser {
	public static final String[] tokenNames = new String[] {
		"", "", "", "", "AND", "COLON", "DEFAULT_FIELD", 
		"ESCAPE", "EXACT_PHRASE", "FIELD_NAME", "LOWERCASE_AND_UNDERSCORE", "NON_WORD", 
		"NOT", "OR", "SINGLE_WORD", "WS", "'('", "')'", "'-'"
	};
	public static final int EOF=-1;
	public static final int T__16=16;
	public static final int T__17=17;
	public static final int T__18=18;
	public static final int AND=4;
	public static final int COLON=5;
	public static final int DEFAULT_FIELD=6;
	public static final int ESCAPE=7;
	public static final int EXACT_PHRASE=8;
	public static final int FIELD_NAME=9;
	public static final int LOWERCASE_AND_UNDERSCORE=10;
	public static final int NON_WORD=11;
	public static final int NOT=12;
	public static final int OR=13;
	public static final int SINGLE_WORD=14;
	public static final int WS=15;

	// delegates
	public Parser[] getDelegates() {
		return new Parser[] {};
	}

	// delegators


	public QueryParser(TokenStream input) {
		this(input, new RecognizerSharedState());
	}
	public QueryParser(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;
	}
	@Override public String[] getTokenNames() { return QueryParser.tokenNames; }
	@Override public String getGrammarFileName() { return "antlr3/com/google/gerrit/index/query/Query.g"; }


	  static class QueryParseInternalException extends RuntimeException {
	    private static final long serialVersionUID = 1L;

	    QueryParseInternalException(final String msg) {
	      super(msg);
	    }
	  }

	  public static Tree parse(final String str)
	    throws QueryParseException {
	    try {
	      final QueryParser p = new QueryParser(
	        new TokenRewriteStream(
	          new QueryLexer(
	            new ANTLRStringStream(str)
	          )
	        )
	      );
	      return (Tree)p.query().getTree();
	    } catch (QueryParseInternalException e) {
	      throw new QueryParseException(e.getMessage());
	    } catch (RecognitionException e) {
	      throw new QueryParseException(e.getMessage());
	    }
	  }

	  public static boolean isSingleWord(final String value) {
	    try {
	      final QueryLexer lexer = new QueryLexer(new ANTLRStringStream(value));
	      lexer.mSINGLE_WORD();
	      return lexer.nextToken().getType() == QueryParser.EOF;
	    } catch (QueryParseInternalException e) {
	      return false;
	    } catch (RecognitionException e) {
	      return false;
	    }
	  }

	  @Override
	  public void displayRecognitionError(String[] tokenNames,
	                                      RecognitionException e) {
	      String hdr = getErrorHeader(e);
	      String msg = getErrorMessage(e, tokenNames);
	      throw new QueryParseInternalException(hdr + " " + msg);
	  }


	public static class query_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "query"
	// antlr3/com/google/gerrit/index/query/Query.g:92:1: query : conditionOr ;
	public final QueryParser.query_return query() throws RecognitionException {
		QueryParser.query_return retval = new QueryParser.query_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope conditionOr1 =null;


		try {
			// antlr3/com/google/gerrit/index/query/Query.g:93:3: ( conditionOr )
			// antlr3/com/google/gerrit/index/query/Query.g:93:5: conditionOr
			{
			root_0 = (Object)adaptor.nil();


			pushFollow(FOLLOW_conditionOr_in_query101);
			conditionOr1=conditionOr();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionOr1.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 "query"


	public static class conditionOr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "conditionOr"
	// antlr3/com/google/gerrit/index/query/Query.g:96:1: conditionOr : ( ( conditionAnd OR )=> conditionAnd OR ^ conditionAnd ( OR ! conditionAnd )* | conditionAnd );
	public final QueryParser.conditionOr_return conditionOr() throws RecognitionException {
		QueryParser.conditionOr_return retval = new QueryParser.conditionOr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token OR3=null;
		Token OR5=null;
		ParserRuleReturnScope conditionAnd2 =null;
		ParserRuleReturnScope conditionAnd4 =null;
		ParserRuleReturnScope conditionAnd6 =null;
		ParserRuleReturnScope conditionAnd7 =null;

		Object OR3_tree=null;
		Object OR5_tree=null;

		try {
			// antlr3/com/google/gerrit/index/query/Query.g:97:3: ( ( conditionAnd OR )=> conditionAnd OR ^ conditionAnd ( OR ! conditionAnd )* | conditionAnd )
			int alt2=2;
			switch ( input.LA(1) ) {
			case 18:
				{
				int LA2_1 = input.LA(2);
				if ( (synpred1_Query()) ) {
					alt2=1;
				}
				else if ( (true) ) {
					alt2=2;
				}

				}
				break;
			case NOT:
				{
				int LA2_2 = input.LA(2);
				if ( (synpred1_Query()) ) {
					alt2=1;
				}
				else if ( (true) ) {
					alt2=2;
				}

				}
				break;
			case 16:
				{
				int LA2_3 = input.LA(2);
				if ( (synpred1_Query()) ) {
					alt2=1;
				}
				else if ( (true) ) {
					alt2=2;
				}

				}
				break;
			case FIELD_NAME:
				{
				int LA2_4 = input.LA(2);
				if ( (synpred1_Query()) ) {
					alt2=1;
				}
				else if ( (true) ) {
					alt2=2;
				}

				}
				break;
			case SINGLE_WORD:
				{
				int LA2_5 = input.LA(2);
				if ( (synpred1_Query()) ) {
					alt2=1;
				}
				else if ( (true) ) {
					alt2=2;
				}

				}
				break;
			case EXACT_PHRASE:
				{
				int LA2_6 = input.LA(2);
				if ( (synpred1_Query()) ) {
					alt2=1;
				}
				else if ( (true) ) {
					alt2=2;
				}

				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 2, 0, input);
				throw nvae;
			}
			switch (alt2) {
				case 1 :
					// antlr3/com/google/gerrit/index/query/Query.g:97:5: ( conditionAnd OR )=> conditionAnd OR ^ conditionAnd ( OR ! conditionAnd )*
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_conditionAnd_in_conditionOr126);
					conditionAnd2=conditionAnd();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionAnd2.getTree());

					OR3=(Token)match(input,OR,FOLLOW_OR_in_conditionOr128); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					OR3_tree = (Object)adaptor.create(OR3);
					root_0 = (Object)adaptor.becomeRoot(OR3_tree, root_0);
					}

					pushFollow(FOLLOW_conditionAnd_in_conditionOr131);
					conditionAnd4=conditionAnd();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionAnd4.getTree());

					// antlr3/com/google/gerrit/index/query/Query.g:98:38: ( OR ! conditionAnd )*
					loop1:
					while (true) {
						int alt1=2;
						int LA1_0 = input.LA(1);
						if ( (LA1_0==OR) ) {
							alt1=1;
						}

						switch (alt1) {
						case 1 :
							// antlr3/com/google/gerrit/index/query/Query.g:98:39: OR ! conditionAnd
							{
							OR5=(Token)match(input,OR,FOLLOW_OR_in_conditionOr134); if (state.failed) return retval;
							pushFollow(FOLLOW_conditionAnd_in_conditionOr137);
							conditionAnd6=conditionAnd();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionAnd6.getTree());

							}
							break;

						default :
							break loop1;
						}
					}

					}
					break;
				case 2 :
					// antlr3/com/google/gerrit/index/query/Query.g:99:5: conditionAnd
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_conditionAnd_in_conditionOr145);
					conditionAnd7=conditionAnd();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionAnd7.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 "conditionOr"


	public static class conditionAnd_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "conditionAnd"
	// antlr3/com/google/gerrit/index/query/Query.g:102:1: conditionAnd : ( ( conditionNot AND )=>i+= conditionNot (i+= conditionAnd2 )* -> ^( AND ( $i)+ ) | ( conditionNot conditionNot )=>i+= conditionNot (i+= conditionAnd2 )* -> ^( AND ( $i)+ ) | conditionNot );
	public final QueryParser.conditionAnd_return conditionAnd() throws RecognitionException {
		QueryParser.conditionAnd_return retval = new QueryParser.conditionAnd_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		List