All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.opendaylight.yangtools.yang.parser.antlr.LeafRefPathParser Maven / Gradle / Ivy

There is a newer version: 14.0.4
Show newest version
// Generated from org/opendaylight/yangtools/yang/parser/antlr/LeafRefPathParser.g4 by ANTLR 4.13.1
package org.opendaylight.yangtools.yang.parser.antlr;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class LeafRefPathParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		COLON=1, SLASH=2, DOTS=3, EQUAL=4, LEFT_SQUARE_BRACKET=5, RIGHT_SQUARE_BRACKET=6, 
		LEFT_PARENTHESIS=7, RIGHT_PARENTHESIS=8, CURRENT_KEYWORD=9, DEREF_KEYWORD=10, 
		SEP=11, IDENTIFIER=12;
	public static final int
		RULE_path_arg = 0, RULE_deref_expr = 1, RULE_path_str = 2, RULE_absolute_path = 3, 
		RULE_relative_path = 4, RULE_descendant_path = 5, RULE_path_predicate = 6, 
		RULE_path_equality_expr = 7, RULE_path_key_expr = 8, RULE_rel_path_keyexpr = 9, 
		RULE_node_identifier = 10, RULE_current_function_invocation = 11, RULE_deref_function_invocation = 12, 
		RULE_prefix = 13, RULE_identifier = 14;
	private static String[] makeRuleNames() {
		return new String[] {
			"path_arg", "deref_expr", "path_str", "absolute_path", "relative_path", 
			"descendant_path", "path_predicate", "path_equality_expr", "path_key_expr", 
			"rel_path_keyexpr", "node_identifier", "current_function_invocation", 
			"deref_function_invocation", "prefix", "identifier"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "':'", "'/'", "'..'", "'='", "'['", "']'", "'('", "')'", "'current'", 
			"'deref'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "COLON", "SLASH", "DOTS", "EQUAL", "LEFT_SQUARE_BRACKET", "RIGHT_SQUARE_BRACKET", 
			"LEFT_PARENTHESIS", "RIGHT_PARENTHESIS", "CURRENT_KEYWORD", "DEREF_KEYWORD", 
			"SEP", "IDENTIFIER"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "LeafRefPathParser.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public LeafRefPathParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Path_argContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(LeafRefPathParser.EOF, 0); }
		public Deref_exprContext deref_expr() {
			return getRuleContext(Deref_exprContext.class,0);
		}
		public Path_strContext path_str() {
			return getRuleContext(Path_strContext.class,0);
		}
		public Path_argContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_path_arg; }
	}

	public final Path_argContext path_arg() throws RecognitionException {
		Path_argContext _localctx = new Path_argContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_path_arg);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(32);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
			case 1:
				{
				setState(30);
				deref_expr();
				}
				break;
			case 2:
				{
				setState(31);
				path_str();
				}
				break;
			}
			setState(34);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Deref_exprContext extends ParserRuleContext {
		public Deref_function_invocationContext deref_function_invocation() {
			return getRuleContext(Deref_function_invocationContext.class,0);
		}
		public TerminalNode SLASH() { return getToken(LeafRefPathParser.SLASH, 0); }
		public Relative_pathContext relative_path() {
			return getRuleContext(Relative_pathContext.class,0);
		}
		public List SEP() { return getTokens(LeafRefPathParser.SEP); }
		public TerminalNode SEP(int i) {
			return getToken(LeafRefPathParser.SEP, i);
		}
		public Deref_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deref_expr; }
	}

	public final Deref_exprContext deref_expr() throws RecognitionException {
		Deref_exprContext _localctx = new Deref_exprContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_deref_expr);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(36);
			deref_function_invocation();
			setState(38);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(37);
				match(SEP);
				}
			}

			setState(40);
			match(SLASH);
			setState(42);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(41);
				match(SEP);
				}
			}

			setState(44);
			relative_path();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Path_strContext extends ParserRuleContext {
		public Absolute_pathContext absolute_path() {
			return getRuleContext(Absolute_pathContext.class,0);
		}
		public Relative_pathContext relative_path() {
			return getRuleContext(Relative_pathContext.class,0);
		}
		public Path_strContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_path_str; }
	}

	public final Path_strContext path_str() throws RecognitionException {
		Path_strContext _localctx = new Path_strContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_path_str);
		try {
			setState(48);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SLASH:
				enterOuterAlt(_localctx, 1);
				{
				setState(46);
				absolute_path();
				}
				break;
			case DOTS:
			case CURRENT_KEYWORD:
			case DEREF_KEYWORD:
			case IDENTIFIER:
				enterOuterAlt(_localctx, 2);
				{
				setState(47);
				relative_path();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Absolute_pathContext extends ParserRuleContext {
		public List SLASH() { return getTokens(LeafRefPathParser.SLASH); }
		public TerminalNode SLASH(int i) {
			return getToken(LeafRefPathParser.SLASH, i);
		}
		public List node_identifier() {
			return getRuleContexts(Node_identifierContext.class);
		}
		public Node_identifierContext node_identifier(int i) {
			return getRuleContext(Node_identifierContext.class,i);
		}
		public List path_predicate() {
			return getRuleContexts(Path_predicateContext.class);
		}
		public Path_predicateContext path_predicate(int i) {
			return getRuleContext(Path_predicateContext.class,i);
		}
		public Absolute_pathContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_absolute_path; }
	}

	public final Absolute_pathContext absolute_path() throws RecognitionException {
		Absolute_pathContext _localctx = new Absolute_pathContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_absolute_path);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(58); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(50);
				match(SLASH);
				setState(51);
				node_identifier();
				setState(55);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==LEFT_SQUARE_BRACKET) {
					{
					{
					setState(52);
					path_predicate();
					}
					}
					setState(57);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				}
				setState(60); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==SLASH );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Relative_pathContext extends ParserRuleContext {
		public Descendant_pathContext descendant_path() {
			return getRuleContext(Descendant_pathContext.class,0);
		}
		public List DOTS() { return getTokens(LeafRefPathParser.DOTS); }
		public TerminalNode DOTS(int i) {
			return getToken(LeafRefPathParser.DOTS, i);
		}
		public List SLASH() { return getTokens(LeafRefPathParser.SLASH); }
		public TerminalNode SLASH(int i) {
			return getToken(LeafRefPathParser.SLASH, i);
		}
		public Relative_pathContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_relative_path; }
	}

	public final Relative_pathContext relative_path() throws RecognitionException {
		Relative_pathContext _localctx = new Relative_pathContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_relative_path);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(66);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOTS) {
				{
				{
				setState(62);
				match(DOTS);
				setState(63);
				match(SLASH);
				}
				}
				setState(68);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(69);
			descendant_path();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Descendant_pathContext extends ParserRuleContext {
		public Node_identifierContext node_identifier() {
			return getRuleContext(Node_identifierContext.class,0);
		}
		public Absolute_pathContext absolute_path() {
			return getRuleContext(Absolute_pathContext.class,0);
		}
		public List path_predicate() {
			return getRuleContexts(Path_predicateContext.class);
		}
		public Path_predicateContext path_predicate(int i) {
			return getRuleContext(Path_predicateContext.class,i);
		}
		public Descendant_pathContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_descendant_path; }
	}

	public final Descendant_pathContext descendant_path() throws RecognitionException {
		Descendant_pathContext _localctx = new Descendant_pathContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_descendant_path);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(71);
			node_identifier();
			setState(79);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SLASH || _la==LEFT_SQUARE_BRACKET) {
				{
				setState(75);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==LEFT_SQUARE_BRACKET) {
					{
					{
					setState(72);
					path_predicate();
					}
					}
					setState(77);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(78);
				absolute_path();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Path_predicateContext extends ParserRuleContext {
		public TerminalNode LEFT_SQUARE_BRACKET() { return getToken(LeafRefPathParser.LEFT_SQUARE_BRACKET, 0); }
		public Path_equality_exprContext path_equality_expr() {
			return getRuleContext(Path_equality_exprContext.class,0);
		}
		public TerminalNode RIGHT_SQUARE_BRACKET() { return getToken(LeafRefPathParser.RIGHT_SQUARE_BRACKET, 0); }
		public List SEP() { return getTokens(LeafRefPathParser.SEP); }
		public TerminalNode SEP(int i) {
			return getToken(LeafRefPathParser.SEP, i);
		}
		public Path_predicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_path_predicate; }
	}

	public final Path_predicateContext path_predicate() throws RecognitionException {
		Path_predicateContext _localctx = new Path_predicateContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_path_predicate);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(81);
			match(LEFT_SQUARE_BRACKET);
			setState(83);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(82);
				match(SEP);
				}
			}

			setState(85);
			path_equality_expr();
			setState(87);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(86);
				match(SEP);
				}
			}

			setState(89);
			match(RIGHT_SQUARE_BRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Path_equality_exprContext extends ParserRuleContext {
		public Node_identifierContext node_identifier() {
			return getRuleContext(Node_identifierContext.class,0);
		}
		public TerminalNode EQUAL() { return getToken(LeafRefPathParser.EQUAL, 0); }
		public Path_key_exprContext path_key_expr() {
			return getRuleContext(Path_key_exprContext.class,0);
		}
		public List SEP() { return getTokens(LeafRefPathParser.SEP); }
		public TerminalNode SEP(int i) {
			return getToken(LeafRefPathParser.SEP, i);
		}
		public Path_equality_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_path_equality_expr; }
	}

	public final Path_equality_exprContext path_equality_expr() throws RecognitionException {
		Path_equality_exprContext _localctx = new Path_equality_exprContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_path_equality_expr);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(91);
			node_identifier();
			setState(93);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(92);
				match(SEP);
				}
			}

			setState(95);
			match(EQUAL);
			setState(97);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(96);
				match(SEP);
				}
			}

			setState(99);
			path_key_expr();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Path_key_exprContext extends ParserRuleContext {
		public Current_function_invocationContext current_function_invocation() {
			return getRuleContext(Current_function_invocationContext.class,0);
		}
		public TerminalNode SLASH() { return getToken(LeafRefPathParser.SLASH, 0); }
		public Rel_path_keyexprContext rel_path_keyexpr() {
			return getRuleContext(Rel_path_keyexprContext.class,0);
		}
		public List SEP() { return getTokens(LeafRefPathParser.SEP); }
		public TerminalNode SEP(int i) {
			return getToken(LeafRefPathParser.SEP, i);
		}
		public Path_key_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_path_key_expr; }
	}

	public final Path_key_exprContext path_key_expr() throws RecognitionException {
		Path_key_exprContext _localctx = new Path_key_exprContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_path_key_expr);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(101);
			current_function_invocation();
			setState(103);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(102);
				match(SEP);
				}
			}

			setState(105);
			match(SLASH);
			setState(107);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(106);
				match(SEP);
				}
			}

			setState(109);
			rel_path_keyexpr();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Rel_path_keyexprContext extends ParserRuleContext {
		public List node_identifier() {
			return getRuleContexts(Node_identifierContext.class);
		}
		public Node_identifierContext node_identifier(int i) {
			return getRuleContext(Node_identifierContext.class,i);
		}
		public List DOTS() { return getTokens(LeafRefPathParser.DOTS); }
		public TerminalNode DOTS(int i) {
			return getToken(LeafRefPathParser.DOTS, i);
		}
		public List SLASH() { return getTokens(LeafRefPathParser.SLASH); }
		public TerminalNode SLASH(int i) {
			return getToken(LeafRefPathParser.SLASH, i);
		}
		public List SEP() { return getTokens(LeafRefPathParser.SEP); }
		public TerminalNode SEP(int i) {
			return getToken(LeafRefPathParser.SEP, i);
		}
		public Rel_path_keyexprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rel_path_keyexpr; }
	}

	public final Rel_path_keyexprContext rel_path_keyexpr() throws RecognitionException {
		Rel_path_keyexprContext _localctx = new Rel_path_keyexprContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_rel_path_keyexpr);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(121);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOTS) {
				{
				{
				setState(111);
				match(DOTS);
				setState(113);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==SEP) {
					{
					setState(112);
					match(SEP);
					}
				}

				setState(115);
				match(SLASH);
				setState(117);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==SEP) {
					{
					setState(116);
					match(SEP);
					}
				}

				}
				}
				setState(123);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(134);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(124);
					node_identifier();
					setState(126);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==SEP) {
						{
						setState(125);
						match(SEP);
						}
					}

					setState(128);
					match(SLASH);
					setState(130);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==SEP) {
						{
						setState(129);
						match(SEP);
						}
					}

					}
					} 
				}
				setState(136);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
			}
			setState(137);
			node_identifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Node_identifierContext extends ParserRuleContext {
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public PrefixContext prefix() {
			return getRuleContext(PrefixContext.class,0);
		}
		public TerminalNode COLON() { return getToken(LeafRefPathParser.COLON, 0); }
		public Node_identifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_node_identifier; }
	}

	public final Node_identifierContext node_identifier() throws RecognitionException {
		Node_identifierContext _localctx = new Node_identifierContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_node_identifier);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(142);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				{
				setState(139);
				prefix();
				setState(140);
				match(COLON);
				}
				break;
			}
			setState(144);
			identifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Current_function_invocationContext extends ParserRuleContext {
		public TerminalNode CURRENT_KEYWORD() { return getToken(LeafRefPathParser.CURRENT_KEYWORD, 0); }
		public TerminalNode LEFT_PARENTHESIS() { return getToken(LeafRefPathParser.LEFT_PARENTHESIS, 0); }
		public TerminalNode RIGHT_PARENTHESIS() { return getToken(LeafRefPathParser.RIGHT_PARENTHESIS, 0); }
		public List SEP() { return getTokens(LeafRefPathParser.SEP); }
		public TerminalNode SEP(int i) {
			return getToken(LeafRefPathParser.SEP, i);
		}
		public Current_function_invocationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_current_function_invocation; }
	}

	public final Current_function_invocationContext current_function_invocation() throws RecognitionException {
		Current_function_invocationContext _localctx = new Current_function_invocationContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_current_function_invocation);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(146);
			match(CURRENT_KEYWORD);
			setState(148);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(147);
				match(SEP);
				}
			}

			setState(150);
			match(LEFT_PARENTHESIS);
			setState(152);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(151);
				match(SEP);
				}
			}

			setState(154);
			match(RIGHT_PARENTHESIS);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Deref_function_invocationContext extends ParserRuleContext {
		public TerminalNode DEREF_KEYWORD() { return getToken(LeafRefPathParser.DEREF_KEYWORD, 0); }
		public TerminalNode LEFT_PARENTHESIS() { return getToken(LeafRefPathParser.LEFT_PARENTHESIS, 0); }
		public Relative_pathContext relative_path() {
			return getRuleContext(Relative_pathContext.class,0);
		}
		public TerminalNode RIGHT_PARENTHESIS() { return getToken(LeafRefPathParser.RIGHT_PARENTHESIS, 0); }
		public List SEP() { return getTokens(LeafRefPathParser.SEP); }
		public TerminalNode SEP(int i) {
			return getToken(LeafRefPathParser.SEP, i);
		}
		public Deref_function_invocationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deref_function_invocation; }
	}

	public final Deref_function_invocationContext deref_function_invocation() throws RecognitionException {
		Deref_function_invocationContext _localctx = new Deref_function_invocationContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_deref_function_invocation);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(156);
			match(DEREF_KEYWORD);
			setState(158);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(157);
				match(SEP);
				}
			}

			setState(160);
			match(LEFT_PARENTHESIS);
			setState(162);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(161);
				match(SEP);
				}
			}

			setState(164);
			relative_path();
			setState(166);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEP) {
				{
				setState(165);
				match(SEP);
				}
			}

			setState(168);
			match(RIGHT_PARENTHESIS);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PrefixContext extends ParserRuleContext {
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public PrefixContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_prefix; }
	}

	public final PrefixContext prefix() throws RecognitionException {
		PrefixContext _localctx = new PrefixContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_prefix);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(170);
			identifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IdentifierContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(LeafRefPathParser.IDENTIFIER, 0); }
		public TerminalNode CURRENT_KEYWORD() { return getToken(LeafRefPathParser.CURRENT_KEYWORD, 0); }
		public TerminalNode DEREF_KEYWORD() { return getToken(LeafRefPathParser.DEREF_KEYWORD, 0); }
		public IdentifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_identifier; }
	}

	public final IdentifierContext identifier() throws RecognitionException {
		IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_identifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(172);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 5632L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\u0004\u0001\f\u00af\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
		"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
		"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
		"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
		"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0001\u0000\u0001\u0000"+
		"\u0003\u0000!\b\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001"+
		"\u0003\u0001\'\b\u0001\u0001\u0001\u0001\u0001\u0003\u0001+\b\u0001\u0001"+
		"\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0003\u00021\b\u0002\u0001"+
		"\u0003\u0001\u0003\u0001\u0003\u0005\u00036\b\u0003\n\u0003\f\u00039\t"+
		"\u0003\u0004\u0003;\b\u0003\u000b\u0003\f\u0003<\u0001\u0004\u0001\u0004"+
		"\u0005\u0004A\b\u0004\n\u0004\f\u0004D\t\u0004\u0001\u0004\u0001\u0004"+
		"\u0001\u0005\u0001\u0005\u0005\u0005J\b\u0005\n\u0005\f\u0005M\t\u0005"+
		"\u0001\u0005\u0003\u0005P\b\u0005\u0001\u0006\u0001\u0006\u0003\u0006"+
		"T\b\u0006\u0001\u0006\u0001\u0006\u0003\u0006X\b\u0006\u0001\u0006\u0001"+
		"\u0006\u0001\u0007\u0001\u0007\u0003\u0007^\b\u0007\u0001\u0007\u0001"+
		"\u0007\u0003\u0007b\b\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0003"+
		"\bh\b\b\u0001\b\u0001\b\u0003\bl\b\b\u0001\b\u0001\b\u0001\t\u0001\t\u0003"+
		"\tr\b\t\u0001\t\u0001\t\u0003\tv\b\t\u0005\tx\b\t\n\t\f\t{\t\t\u0001\t"+
		"\u0001\t\u0003\t\u007f\b\t\u0001\t\u0001\t\u0003\t\u0083\b\t\u0005\t\u0085"+
		"\b\t\n\t\f\t\u0088\t\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0003\n"+
		"\u008f\b\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0003\u000b\u0095\b"+
		"\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0099\b\u000b\u0001\u000b\u0001"+
		"\u000b\u0001\f\u0001\f\u0003\f\u009f\b\f\u0001\f\u0001\f\u0003\f\u00a3"+
		"\b\f\u0001\f\u0001\f\u0003\f\u00a7\b\f\u0001\f\u0001\f\u0001\r\u0001\r"+
		"\u0001\u000e\u0001\u000e\u0001\u000e\u0000\u0000\u000f\u0000\u0002\u0004"+
		"\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u0000\u0001"+
		"\u0002\u0000\t\n\f\f\u00ba\u0000 \u0001\u0000\u0000\u0000\u0002$\u0001"+
		"\u0000\u0000\u0000\u00040\u0001\u0000\u0000\u0000\u0006:\u0001\u0000\u0000"+
		"\u0000\bB\u0001\u0000\u0000\u0000\nG\u0001\u0000\u0000\u0000\fQ\u0001"+
		"\u0000\u0000\u0000\u000e[\u0001\u0000\u0000\u0000\u0010e\u0001\u0000\u0000"+
		"\u0000\u0012y\u0001\u0000\u0000\u0000\u0014\u008e\u0001\u0000\u0000\u0000"+
		"\u0016\u0092\u0001\u0000\u0000\u0000\u0018\u009c\u0001\u0000\u0000\u0000"+
		"\u001a\u00aa\u0001\u0000\u0000\u0000\u001c\u00ac\u0001\u0000\u0000\u0000"+
		"\u001e!\u0003\u0002\u0001\u0000\u001f!\u0003\u0004\u0002\u0000 \u001e"+
		"\u0001\u0000\u0000\u0000 \u001f\u0001\u0000\u0000\u0000!\"\u0001\u0000"+
		"\u0000\u0000\"#\u0005\u0000\u0000\u0001#\u0001\u0001\u0000\u0000\u0000"+
		"$&\u0003\u0018\f\u0000%\'\u0005\u000b\u0000\u0000&%\u0001\u0000\u0000"+
		"\u0000&\'\u0001\u0000\u0000\u0000\'(\u0001\u0000\u0000\u0000(*\u0005\u0002"+
		"\u0000\u0000)+\u0005\u000b\u0000\u0000*)\u0001\u0000\u0000\u0000*+\u0001"+
		"\u0000\u0000\u0000+,\u0001\u0000\u0000\u0000,-\u0003\b\u0004\u0000-\u0003"+
		"\u0001\u0000\u0000\u0000.1\u0003\u0006\u0003\u0000/1\u0003\b\u0004\u0000"+
		"0.\u0001\u0000\u0000\u00000/\u0001\u0000\u0000\u00001\u0005\u0001\u0000"+
		"\u0000\u000023\u0005\u0002\u0000\u000037\u0003\u0014\n\u000046\u0003\f"+
		"\u0006\u000054\u0001\u0000\u0000\u000069\u0001\u0000\u0000\u000075\u0001"+
		"\u0000\u0000\u000078\u0001\u0000\u0000\u00008;\u0001\u0000\u0000\u0000"+
		"97\u0001\u0000\u0000\u0000:2\u0001\u0000\u0000\u0000;<\u0001\u0000\u0000"+
		"\u0000<:\u0001\u0000\u0000\u0000<=\u0001\u0000\u0000\u0000=\u0007\u0001"+
		"\u0000\u0000\u0000>?\u0005\u0003\u0000\u0000?A\u0005\u0002\u0000\u0000"+
		"@>\u0001\u0000\u0000\u0000AD\u0001\u0000\u0000\u0000B@\u0001\u0000\u0000"+
		"\u0000BC\u0001\u0000\u0000\u0000CE\u0001\u0000\u0000\u0000DB\u0001\u0000"+
		"\u0000\u0000EF\u0003\n\u0005\u0000F\t\u0001\u0000\u0000\u0000GO\u0003"+
		"\u0014\n\u0000HJ\u0003\f\u0006\u0000IH\u0001\u0000\u0000\u0000JM\u0001"+
		"\u0000\u0000\u0000KI\u0001\u0000\u0000\u0000KL\u0001\u0000\u0000\u0000"+
		"LN\u0001\u0000\u0000\u0000MK\u0001\u0000\u0000\u0000NP\u0003\u0006\u0003"+
		"\u0000OK\u0001\u0000\u0000\u0000OP\u0001\u0000\u0000\u0000P\u000b\u0001"+
		"\u0000\u0000\u0000QS\u0005\u0005\u0000\u0000RT\u0005\u000b\u0000\u0000"+
		"SR\u0001\u0000\u0000\u0000ST\u0001\u0000\u0000\u0000TU\u0001\u0000\u0000"+
		"\u0000UW\u0003\u000e\u0007\u0000VX\u0005\u000b\u0000\u0000WV\u0001\u0000"+
		"\u0000\u0000WX\u0001\u0000\u0000\u0000XY\u0001\u0000\u0000\u0000YZ\u0005"+
		"\u0006\u0000\u0000Z\r\u0001\u0000\u0000\u0000[]\u0003\u0014\n\u0000\\"+
		"^\u0005\u000b\u0000\u0000]\\\u0001\u0000\u0000\u0000]^\u0001\u0000\u0000"+
		"\u0000^_\u0001\u0000\u0000\u0000_a\u0005\u0004\u0000\u0000`b\u0005\u000b"+
		"\u0000\u0000a`\u0001\u0000\u0000\u0000ab\u0001\u0000\u0000\u0000bc\u0001"+
		"\u0000\u0000\u0000cd\u0003\u0010\b\u0000d\u000f\u0001\u0000\u0000\u0000"+
		"eg\u0003\u0016\u000b\u0000fh\u0005\u000b\u0000\u0000gf\u0001\u0000\u0000"+
		"\u0000gh\u0001\u0000\u0000\u0000hi\u0001\u0000\u0000\u0000ik\u0005\u0002"+
		"\u0000\u0000jl\u0005\u000b\u0000\u0000kj\u0001\u0000\u0000\u0000kl\u0001"+
		"\u0000\u0000\u0000lm\u0001\u0000\u0000\u0000mn\u0003\u0012\t\u0000n\u0011"+
		"\u0001\u0000\u0000\u0000oq\u0005\u0003\u0000\u0000pr\u0005\u000b\u0000"+
		"\u0000qp\u0001\u0000\u0000\u0000qr\u0001\u0000\u0000\u0000rs\u0001\u0000"+
		"\u0000\u0000su\u0005\u0002\u0000\u0000tv\u0005\u000b\u0000\u0000ut\u0001"+
		"\u0000\u0000\u0000uv\u0001\u0000\u0000\u0000vx\u0001\u0000\u0000\u0000"+
		"wo\u0001\u0000\u0000\u0000x{\u0001\u0000\u0000\u0000yw\u0001\u0000\u0000"+
		"\u0000yz\u0001\u0000\u0000\u0000z\u0086\u0001\u0000\u0000\u0000{y\u0001"+
		"\u0000\u0000\u0000|~\u0003\u0014\n\u0000}\u007f\u0005\u000b\u0000\u0000"+
		"~}\u0001\u0000\u0000\u0000~\u007f\u0001\u0000\u0000\u0000\u007f\u0080"+
		"\u0001\u0000\u0000\u0000\u0080\u0082\u0005\u0002\u0000\u0000\u0081\u0083"+
		"\u0005\u000b\u0000\u0000\u0082\u0081\u0001\u0000\u0000\u0000\u0082\u0083"+
		"\u0001\u0000\u0000\u0000\u0083\u0085\u0001\u0000\u0000\u0000\u0084|\u0001"+
		"\u0000\u0000\u0000\u0085\u0088\u0001\u0000\u0000\u0000\u0086\u0084\u0001"+
		"\u0000\u0000\u0000\u0086\u0087\u0001\u0000\u0000\u0000\u0087\u0089\u0001"+
		"\u0000\u0000\u0000\u0088\u0086\u0001\u0000\u0000\u0000\u0089\u008a\u0003"+
		"\u0014\n\u0000\u008a\u0013\u0001\u0000\u0000\u0000\u008b\u008c\u0003\u001a"+
		"\r\u0000\u008c\u008d\u0005\u0001\u0000\u0000\u008d\u008f\u0001\u0000\u0000"+
		"\u0000\u008e\u008b\u0001\u0000\u0000\u0000\u008e\u008f\u0001\u0000\u0000"+
		"\u0000\u008f\u0090\u0001\u0000\u0000\u0000\u0090\u0091\u0003\u001c\u000e"+
		"\u0000\u0091\u0015\u0001\u0000\u0000\u0000\u0092\u0094\u0005\t\u0000\u0000"+
		"\u0093\u0095\u0005\u000b\u0000\u0000\u0094\u0093\u0001\u0000\u0000\u0000"+
		"\u0094\u0095\u0001\u0000\u0000\u0000\u0095\u0096\u0001\u0000\u0000\u0000"+
		"\u0096\u0098\u0005\u0007\u0000\u0000\u0097\u0099\u0005\u000b\u0000\u0000"+
		"\u0098\u0097\u0001\u0000\u0000\u0000\u0098\u0099\u0001\u0000\u0000\u0000"+
		"\u0099\u009a\u0001\u0000\u0000\u0000\u009a\u009b\u0005\b\u0000\u0000\u009b"+
		"\u0017\u0001\u0000\u0000\u0000\u009c\u009e\u0005\n\u0000\u0000\u009d\u009f"+
		"\u0005\u000b\u0000\u0000\u009e\u009d\u0001\u0000\u0000\u0000\u009e\u009f"+
		"\u0001\u0000\u0000\u0000\u009f\u00a0\u0001\u0000\u0000\u0000\u00a0\u00a2"+
		"\u0005\u0007\u0000\u0000\u00a1\u00a3\u0005\u000b\u0000\u0000\u00a2\u00a1"+
		"\u0001\u0000\u0000\u0000\u00a2\u00a3\u0001\u0000\u0000\u0000\u00a3\u00a4"+
		"\u0001\u0000\u0000\u0000\u00a4\u00a6\u0003\b\u0004\u0000\u00a5\u00a7\u0005"+
		"\u000b\u0000\u0000\u00a6\u00a5\u0001\u0000\u0000\u0000\u00a6\u00a7\u0001"+
		"\u0000\u0000\u0000\u00a7\u00a8\u0001\u0000\u0000\u0000\u00a8\u00a9\u0005"+
		"\b\u0000\u0000\u00a9\u0019\u0001\u0000\u0000\u0000\u00aa\u00ab\u0003\u001c"+
		"\u000e\u0000\u00ab\u001b\u0001\u0000\u0000\u0000\u00ac\u00ad\u0007\u0000"+
		"\u0000\u0000\u00ad\u001d\u0001\u0000\u0000\u0000\u001b &*07




© 2015 - 2024 Weber Informatics LLC | Privacy Policy