sp4rql.Sp4rql11Parser Maven / Gradle / Ivy
// Generated from sp4rql/Sp4rql11.g4 by ANTLR 4.8
package sp4rql;
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"})
public class Sp4rql11Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, BASE=3, PREFIX=4, SELECT=5, DISTINCT=6, REDUCED=7, CONSTRUCT=8,
WHERE=9, DESCRIBE=10, ASK=11, FROM=12, NAMED=13, GROUP=14, BY=15, HAVING=16,
ORDER=17, ASC=18, DESC=19, LIMIT=20, OFFSET=21, LOAD=22, SILENT=23, INTO=24,
CLEAR=25, DROP=26, CREATE=27, ADD=28, TO=29, MOVE=30, COPY=31, INSERT=32,
DATA=33, DELETE=34, WITH=35, USING=36, DEFAULT=37, GRAPH=38, ALL=39, OPTIONAL=40,
SERVICE=41, BIND=42, AS=43, UNDEF=44, MINUS=45, UNION=46, FILTER=47, A=48,
NOT=49, IN=50, STR=51, LANG=52, LANGMATCHES=53, DATATYPE=54, BOUND=55,
IRI=56, URI=57, BNODE=58, RAND=59, ABS=60, CEIL=61, FLOOR=62, ROUND=63,
CONCAT=64, STRLEN=65, UCASE=66, LCASE=67, ENCODE_FOR_URI=68, CONTAINS=69,
STRSTARTS=70, STRENDS=71, STRBEFORE=72, STRAFTER=73, YEAR=74, MONTH=75,
DAY=76, HOURS=77, MINUTES=78, SECONDS=79, TIMEZONE=80, TZ=81, NOW=82,
UUID=83, STRUUID=84, MD5=85, SHA1=86, SHA256=87, SHA384=88, SHA512=89,
COALESCE=90, IF=91, STRLANG=92, STRDT=93, SAMETERM=94, ISIRI=95, ISURI=96,
ISBLANK=97, ISLITERAL=98, ISNUMERIC=99, REGEX=100, SUBSTR=101, REPLACE=102,
EXISTS=103, COUNT=104, SUM=105, MIN=106, MAX=107, AVG=108, GROUP_CONCAT=109,
SEPARATOR=110, TRUE=111, FALSE=112, VALUES=113, SAMPLE=114, REFERENCE=115,
AND=116, OR=117, OPEN_CURLY_BRACE=118, CLOSE_CURLY_BRACE=119, SEMICOLON=120,
DOT=121, PLUS=122, DASH=123, ASTERISK=124, COMMA=125, NOT_SIGN=126, DIVIDE=127,
EQUAL=128, LESS=129, GREATER=130, OPEN_BRACE=131, CLOSE_BRACE=132, LESS_EQUAL=133,
GREATER_EQUAL=134, NOT_EQUAL=135, OPEN_SQUARE_BRACE=136, CLOSE_SQUARE_BRACE=137,
BAR=138, CARET=139, QUESTION=140, COMMENT=141, IRIREF=142, PNAME_NS=143,
PNAME_LN=144, BLANK_NODE_LABEL=145, VAR1=146, VAR2=147, LANGTAG=148, INTEGER=149,
DECIMAL=150, DOUBLE=151, INTEGER_POSITIVE=152, DECIMAL_POSITIVE=153, DOUBLE_POSITIVE=154,
INTEGER_NEGATIVE=155, DECIMAL_NEGATIVE=156, DOUBLE_NEGATIVE=157, STRING_LITERAL1=158,
STRING_LITERAL2=159, STRING_LITERAL_LONG1=160, STRING_LITERAL_LONG2=161,
NIL=162, WS=163, ANON=164, PLX=165, PERCENT=166, PN_LOCAL_ESC=167, UNQUOTED_IRIREF=168;
public static final int
RULE_queryUnit = 0, RULE_query = 1, RULE_updateUnit = 2, RULE_prologue = 3,
RULE_baseDecl = 4, RULE_prefixDecl = 5, RULE_selectQuery = 6, RULE_subSelect = 7,
RULE_selectClause = 8, RULE_constructQuery = 9, RULE_describeQuery = 10,
RULE_askQuery = 11, RULE_datasetClause = 12, RULE_defaultGraphClause = 13,
RULE_namedGraphClause = 14, RULE_sourceSelector = 15, RULE_whereClause = 16,
RULE_solutionModifier = 17, RULE_groupClause = 18, RULE_groupCondition = 19,
RULE_havingClause = 20, RULE_havingCondition = 21, RULE_orderClause = 22,
RULE_orderCondition = 23, RULE_limitOffsetClauses = 24, RULE_limitClause = 25,
RULE_offsetClause = 26, RULE_valuesClause = 27, RULE_update = 28, RULE_update1 = 29,
RULE_load = 30, RULE_clear = 31, RULE_drop = 32, RULE_create = 33, RULE_add = 34,
RULE_move = 35, RULE_copy = 36, RULE_insertData = 37, RULE_deleteData = 38,
RULE_deleteWhere = 39, RULE_modify = 40, RULE_deleteClause = 41, RULE_insertClause = 42,
RULE_usingClause = 43, RULE_graphOrDefault = 44, RULE_graphRef = 45, RULE_graphRefAll = 46,
RULE_quadPattern = 47, RULE_quadData = 48, RULE_quads = 49, RULE_quadsNotTriples = 50,
RULE_triplesTemplate = 51, RULE_groupGraphPattern = 52, RULE_groupGraphPatternSub = 53,
RULE_triplesBlock = 54, RULE_graphPatternNotTriples = 55, RULE_optionalGraphPattern = 56,
RULE_graphGraphPattern = 57, RULE_serviceGraphPattern = 58, RULE_bind = 59,
RULE_inlineData = 60, RULE_dataBlock = 61, RULE_inlineDataOneVar = 62,
RULE_inlineDataFull = 63, RULE_dataBlockValue = 64, RULE_minusGraphPattern = 65,
RULE_groupOrUnionGraphPattern = 66, RULE_filter = 67, RULE_constraint = 68,
RULE_functionCall = 69, RULE_argList = 70, RULE_expressionList = 71, RULE_constructTemplate = 72,
RULE_constructTriples = 73, RULE_triplesSameSubject = 74, RULE_propertyList = 75,
RULE_propertyListNotEmpty = 76, RULE_verb = 77, RULE_objectList = 78,
RULE_object = 79, RULE_triplesSameSubjectPath = 80, RULE_singleTermQuad = 81,
RULE_propertyListPath = 82, RULE_propertyListPathNotEmpty = 83, RULE_verbPath = 84,
RULE_verbSimple = 85, RULE_objectListPath = 86, RULE_objectPath = 87,
RULE_path = 88, RULE_pathAlternative = 89, RULE_pathSequence = 90, RULE_pathElt = 91,
RULE_pathEltOrInverse = 92, RULE_pathMod = 93, RULE_pathPrimary = 94,
RULE_pathNegatedPropertySet = 95, RULE_pathOneInPropertySet = 96, RULE_integer = 97,
RULE_triplesNode = 98, RULE_blankNodePropertyList = 99, RULE_triplesNodePath = 100,
RULE_blankNodePropertyListPath = 101, RULE_collection = 102, RULE_collectionPath = 103,
RULE_graphNode = 104, RULE_graphNodePath = 105, RULE_varOrTerm = 106,
RULE_varOrTermOrEmbTP = 107, RULE_varOrIri = 108, RULE_var = 109, RULE_embTP = 110,
RULE_graphTerm = 111, RULE_expression = 112, RULE_expressionOrEmbTP = 113,
RULE_conditionalOrExpression = 114, RULE_conditionalAndExpression = 115,
RULE_valueLogical = 116, RULE_relationalExpression = 117, RULE_numericExpression = 118,
RULE_additiveExpression = 119, RULE_multiplicativeExpression = 120, RULE_unaryExpression = 121,
RULE_primaryExpression = 122, RULE_brackettedExpression = 123, RULE_builtInCall = 124,
RULE_regexExpression = 125, RULE_substringExpression = 126, RULE_strReplaceExpression = 127,
RULE_existsFunc = 128, RULE_notExistsFunc = 129, RULE_aggregate = 130,
RULE_iriOrFunction = 131, RULE_rDFLiteral = 132, RULE_numericLiteral = 133,
RULE_numericLiteralUnsigned = 134, RULE_numericLiteralPositive = 135,
RULE_numericLiteralNegative = 136, RULE_booleanLiteral = 137, RULE_string = 138,
RULE_iri = 139, RULE_prefixedName = 140, RULE_blankNode = 141;
private static String[] makeRuleNames() {
return new String[] {
"queryUnit", "query", "updateUnit", "prologue", "baseDecl", "prefixDecl",
"selectQuery", "subSelect", "selectClause", "constructQuery", "describeQuery",
"askQuery", "datasetClause", "defaultGraphClause", "namedGraphClause",
"sourceSelector", "whereClause", "solutionModifier", "groupClause", "groupCondition",
"havingClause", "havingCondition", "orderClause", "orderCondition", "limitOffsetClauses",
"limitClause", "offsetClause", "valuesClause", "update", "update1", "load",
"clear", "drop", "create", "add", "move", "copy", "insertData", "deleteData",
"deleteWhere", "modify", "deleteClause", "insertClause", "usingClause",
"graphOrDefault", "graphRef", "graphRefAll", "quadPattern", "quadData",
"quads", "quadsNotTriples", "triplesTemplate", "groupGraphPattern", "groupGraphPatternSub",
"triplesBlock", "graphPatternNotTriples", "optionalGraphPattern", "graphGraphPattern",
"serviceGraphPattern", "bind", "inlineData", "dataBlock", "inlineDataOneVar",
"inlineDataFull", "dataBlockValue", "minusGraphPattern", "groupOrUnionGraphPattern",
"filter", "constraint", "functionCall", "argList", "expressionList",
"constructTemplate", "constructTriples", "triplesSameSubject", "propertyList",
"propertyListNotEmpty", "verb", "objectList", "object", "triplesSameSubjectPath",
"singleTermQuad", "propertyListPath", "propertyListPathNotEmpty", "verbPath",
"verbSimple", "objectListPath", "objectPath", "path", "pathAlternative",
"pathSequence", "pathElt", "pathEltOrInverse", "pathMod", "pathPrimary",
"pathNegatedPropertySet", "pathOneInPropertySet", "integer", "triplesNode",
"blankNodePropertyList", "triplesNodePath", "blankNodePropertyListPath",
"collection", "collectionPath", "graphNode", "graphNodePath", "varOrTerm",
"varOrTermOrEmbTP", "varOrIri", "var", "embTP", "graphTerm", "expression",
"expressionOrEmbTP", "conditionalOrExpression", "conditionalAndExpression",
"valueLogical", "relationalExpression", "numericExpression", "additiveExpression",
"multiplicativeExpression", "unaryExpression", "primaryExpression", "brackettedExpression",
"builtInCall", "regexExpression", "substringExpression", "strReplaceExpression",
"existsFunc", "notExistsFunc", "aggregate", "iriOrFunction", "rDFLiteral",
"numericLiteral", "numericLiteralUnsigned", "numericLiteralPositive",
"numericLiteralNegative", "booleanLiteral", "string", "iri", "prefixedName",
"blankNode"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'<<'", "'>>'", null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, "'^^'", "'&&'", "'||'",
"'{'", "'}'", "';'", "'.'", "'+'", "'-'", "'*'", "','", "'!'", "'/'",
"'='", "'<'", "'>'", "'('", "')'", "'<='", "'>='", "'!='", "'['", "']'",
"'|'", "'^'", "'?'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, "BASE", "PREFIX", "SELECT", "DISTINCT", "REDUCED",
"CONSTRUCT", "WHERE", "DESCRIBE", "ASK", "FROM", "NAMED", "GROUP", "BY",
"HAVING", "ORDER", "ASC", "DESC", "LIMIT", "OFFSET", "LOAD", "SILENT",
"INTO", "CLEAR", "DROP", "CREATE", "ADD", "TO", "MOVE", "COPY", "INSERT",
"DATA", "DELETE", "WITH", "USING", "DEFAULT", "GRAPH", "ALL", "OPTIONAL",
"SERVICE", "BIND", "AS", "UNDEF", "MINUS", "UNION", "FILTER", "A", "NOT",
"IN", "STR", "LANG", "LANGMATCHES", "DATATYPE", "BOUND", "IRI", "URI",
"BNODE", "RAND", "ABS", "CEIL", "FLOOR", "ROUND", "CONCAT", "STRLEN",
"UCASE", "LCASE", "ENCODE_FOR_URI", "CONTAINS", "STRSTARTS", "STRENDS",
"STRBEFORE", "STRAFTER", "YEAR", "MONTH", "DAY", "HOURS", "MINUTES",
"SECONDS", "TIMEZONE", "TZ", "NOW", "UUID", "STRUUID", "MD5", "SHA1",
"SHA256", "SHA384", "SHA512", "COALESCE", "IF", "STRLANG", "STRDT", "SAMETERM",
"ISIRI", "ISURI", "ISBLANK", "ISLITERAL", "ISNUMERIC", "REGEX", "SUBSTR",
"REPLACE", "EXISTS", "COUNT", "SUM", "MIN", "MAX", "AVG", "GROUP_CONCAT",
"SEPARATOR", "TRUE", "FALSE", "VALUES", "SAMPLE", "REFERENCE", "AND",
"OR", "OPEN_CURLY_BRACE", "CLOSE_CURLY_BRACE", "SEMICOLON", "DOT", "PLUS",
"DASH", "ASTERISK", "COMMA", "NOT_SIGN", "DIVIDE", "EQUAL", "LESS", "GREATER",
"OPEN_BRACE", "CLOSE_BRACE", "LESS_EQUAL", "GREATER_EQUAL", "NOT_EQUAL",
"OPEN_SQUARE_BRACE", "CLOSE_SQUARE_BRACE", "BAR", "CARET", "QUESTION",
"COMMENT", "IRIREF", "PNAME_NS", "PNAME_LN", "BLANK_NODE_LABEL", "VAR1",
"VAR2", "LANGTAG", "INTEGER", "DECIMAL", "DOUBLE", "INTEGER_POSITIVE",
"DECIMAL_POSITIVE", "DOUBLE_POSITIVE", "INTEGER_NEGATIVE", "DECIMAL_NEGATIVE",
"DOUBLE_NEGATIVE", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1",
"STRING_LITERAL_LONG2", "NIL", "WS", "ANON", "PLX", "PERCENT", "PN_LOCAL_ESC",
"UNQUOTED_IRIREF"
};
}
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 "Sp4rql11.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public Sp4rql11Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class QueryUnitContext extends ParserRuleContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public QueryUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterQueryUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitQueryUnit(this);
}
}
public final QueryUnitContext queryUnit() throws RecognitionException {
QueryUnitContext _localctx = new QueryUnitContext(_ctx, getState());
enterRule(_localctx, 0, RULE_queryUnit);
try {
enterOuterAlt(_localctx, 1);
{
setState(284);
query();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QueryContext extends ParserRuleContext {
public PrologueContext prologue() {
return getRuleContext(PrologueContext.class,0);
}
public ValuesClauseContext valuesClause() {
return getRuleContext(ValuesClauseContext.class,0);
}
public SelectQueryContext selectQuery() {
return getRuleContext(SelectQueryContext.class,0);
}
public ConstructQueryContext constructQuery() {
return getRuleContext(ConstructQueryContext.class,0);
}
public DescribeQueryContext describeQuery() {
return getRuleContext(DescribeQueryContext.class,0);
}
public AskQueryContext askQuery() {
return getRuleContext(AskQueryContext.class,0);
}
public QueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_query; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitQuery(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 2, RULE_query);
try {
enterOuterAlt(_localctx, 1);
{
setState(286);
prologue();
setState(291);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
{
setState(287);
selectQuery();
}
break;
case CONSTRUCT:
{
setState(288);
constructQuery();
}
break;
case DESCRIBE:
{
setState(289);
describeQuery();
}
break;
case ASK:
{
setState(290);
askQuery();
}
break;
default:
throw new NoViableAltException(this);
}
setState(293);
valuesClause();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateUnitContext extends ParserRuleContext {
public UpdateContext update() {
return getRuleContext(UpdateContext.class,0);
}
public UpdateUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterUpdateUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitUpdateUnit(this);
}
}
public final UpdateUnitContext updateUnit() throws RecognitionException {
UpdateUnitContext _localctx = new UpdateUnitContext(_ctx, getState());
enterRule(_localctx, 4, RULE_updateUnit);
try {
enterOuterAlt(_localctx, 1);
{
setState(295);
update();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrologueContext extends ParserRuleContext {
public List baseDecl() {
return getRuleContexts(BaseDeclContext.class);
}
public BaseDeclContext baseDecl(int i) {
return getRuleContext(BaseDeclContext.class,i);
}
public List prefixDecl() {
return getRuleContexts(PrefixDeclContext.class);
}
public PrefixDeclContext prefixDecl(int i) {
return getRuleContext(PrefixDeclContext.class,i);
}
public PrologueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prologue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPrologue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPrologue(this);
}
}
public final PrologueContext prologue() throws RecognitionException {
PrologueContext _localctx = new PrologueContext(_ctx, getState());
enterRule(_localctx, 6, RULE_prologue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(301);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BASE || _la==PREFIX) {
{
setState(299);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BASE:
{
setState(297);
baseDecl();
}
break;
case PREFIX:
{
setState(298);
prefixDecl();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BaseDeclContext extends ParserRuleContext {
public TerminalNode BASE() { return getToken(Sp4rql11Parser.BASE, 0); }
public TerminalNode IRIREF() { return getToken(Sp4rql11Parser.IRIREF, 0); }
public TerminalNode UNQUOTED_IRIREF() { return getToken(Sp4rql11Parser.UNQUOTED_IRIREF, 0); }
public BaseDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_baseDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterBaseDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitBaseDecl(this);
}
}
public final BaseDeclContext baseDecl() throws RecognitionException {
BaseDeclContext _localctx = new BaseDeclContext(_ctx, getState());
enterRule(_localctx, 8, RULE_baseDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(304);
match(BASE);
setState(305);
_la = _input.LA(1);
if ( !(_la==IRIREF || _la==UNQUOTED_IRIREF) ) {
_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 class PrefixDeclContext extends ParserRuleContext {
public TerminalNode PREFIX() { return getToken(Sp4rql11Parser.PREFIX, 0); }
public TerminalNode PNAME_NS() { return getToken(Sp4rql11Parser.PNAME_NS, 0); }
public TerminalNode IRIREF() { return getToken(Sp4rql11Parser.IRIREF, 0); }
public TerminalNode UNQUOTED_IRIREF() { return getToken(Sp4rql11Parser.UNQUOTED_IRIREF, 0); }
public PrefixDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefixDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPrefixDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPrefixDecl(this);
}
}
public final PrefixDeclContext prefixDecl() throws RecognitionException {
PrefixDeclContext _localctx = new PrefixDeclContext(_ctx, getState());
enterRule(_localctx, 10, RULE_prefixDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(307);
match(PREFIX);
setState(308);
match(PNAME_NS);
setState(309);
_la = _input.LA(1);
if ( !(_la==IRIREF || _la==UNQUOTED_IRIREF) ) {
_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 class SelectQueryContext extends ParserRuleContext {
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public SolutionModifierContext solutionModifier() {
return getRuleContext(SolutionModifierContext.class,0);
}
public List datasetClause() {
return getRuleContexts(DatasetClauseContext.class);
}
public DatasetClauseContext datasetClause(int i) {
return getRuleContext(DatasetClauseContext.class,i);
}
public SelectQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterSelectQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitSelectQuery(this);
}
}
public final SelectQueryContext selectQuery() throws RecognitionException {
SelectQueryContext _localctx = new SelectQueryContext(_ctx, getState());
enterRule(_localctx, 12, RULE_selectQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(311);
selectClause();
setState(315);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FROM) {
{
{
setState(312);
datasetClause();
}
}
setState(317);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(318);
whereClause();
setState(319);
solutionModifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubSelectContext extends ParserRuleContext {
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public SolutionModifierContext solutionModifier() {
return getRuleContext(SolutionModifierContext.class,0);
}
public ValuesClauseContext valuesClause() {
return getRuleContext(ValuesClauseContext.class,0);
}
public SubSelectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subSelect; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterSubSelect(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitSubSelect(this);
}
}
public final SubSelectContext subSelect() throws RecognitionException {
SubSelectContext _localctx = new SubSelectContext(_ctx, getState());
enterRule(_localctx, 14, RULE_subSelect);
try {
enterOuterAlt(_localctx, 1);
{
setState(321);
selectClause();
setState(322);
whereClause();
setState(323);
solutionModifier();
setState(324);
valuesClause();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectClauseContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(Sp4rql11Parser.SELECT, 0); }
public TerminalNode ASTERISK() { return getToken(Sp4rql11Parser.ASTERISK, 0); }
public TerminalNode DISTINCT() { return getToken(Sp4rql11Parser.DISTINCT, 0); }
public TerminalNode REDUCED() { return getToken(Sp4rql11Parser.REDUCED, 0); }
public List var() {
return getRuleContexts(VarContext.class);
}
public VarContext var(int i) {
return getRuleContext(VarContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List AS() { return getTokens(Sp4rql11Parser.AS); }
public TerminalNode AS(int i) {
return getToken(Sp4rql11Parser.AS, i);
}
public List OPEN_BRACE() { return getTokens(Sp4rql11Parser.OPEN_BRACE); }
public TerminalNode OPEN_BRACE(int i) {
return getToken(Sp4rql11Parser.OPEN_BRACE, i);
}
public List CLOSE_BRACE() { return getTokens(Sp4rql11Parser.CLOSE_BRACE); }
public TerminalNode CLOSE_BRACE(int i) {
return getToken(Sp4rql11Parser.CLOSE_BRACE, i);
}
public SelectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterSelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitSelectClause(this);
}
}
public final SelectClauseContext selectClause() throws RecognitionException {
SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
enterRule(_localctx, 16, RULE_selectClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(326);
match(SELECT);
setState(328);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==REDUCED) {
{
setState(327);
_la = _input.LA(1);
if ( !(_la==DISTINCT || _la==REDUCED) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(346);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case TRUE:
case FALSE:
case SAMPLE:
case PLUS:
case DASH:
case NOT_SIGN:
case OPEN_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case UNQUOTED_IRIREF:
{
setState(341);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(341);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(330);
var();
}
break;
case 2:
{
{
setState(331);
expression();
setState(332);
match(AS);
setState(333);
var();
}
}
break;
case 3:
{
{
setState(335);
match(OPEN_BRACE);
setState(336);
expression();
setState(337);
match(AS);
setState(338);
var();
setState(339);
match(CLOSE_BRACE);
}
}
break;
}
}
setState(343);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (NOT - 49)) | (1L << (STR - 49)) | (1L << (LANG - 49)) | (1L << (LANGMATCHES - 49)) | (1L << (DATATYPE - 49)) | (1L << (BOUND - 49)) | (1L << (IRI - 49)) | (1L << (URI - 49)) | (1L << (BNODE - 49)) | (1L << (RAND - 49)) | (1L << (ABS - 49)) | (1L << (CEIL - 49)) | (1L << (FLOOR - 49)) | (1L << (ROUND - 49)) | (1L << (CONCAT - 49)) | (1L << (STRLEN - 49)) | (1L << (UCASE - 49)) | (1L << (LCASE - 49)) | (1L << (ENCODE_FOR_URI - 49)) | (1L << (CONTAINS - 49)) | (1L << (STRSTARTS - 49)) | (1L << (STRENDS - 49)) | (1L << (STRBEFORE - 49)) | (1L << (STRAFTER - 49)) | (1L << (YEAR - 49)) | (1L << (MONTH - 49)) | (1L << (DAY - 49)) | (1L << (HOURS - 49)) | (1L << (MINUTES - 49)) | (1L << (SECONDS - 49)) | (1L << (TIMEZONE - 49)) | (1L << (TZ - 49)) | (1L << (NOW - 49)) | (1L << (UUID - 49)) | (1L << (STRUUID - 49)) | (1L << (MD5 - 49)) | (1L << (SHA1 - 49)) | (1L << (SHA256 - 49)) | (1L << (SHA384 - 49)) | (1L << (SHA512 - 49)) | (1L << (COALESCE - 49)) | (1L << (IF - 49)) | (1L << (STRLANG - 49)) | (1L << (STRDT - 49)) | (1L << (SAMETERM - 49)) | (1L << (ISIRI - 49)) | (1L << (ISURI - 49)) | (1L << (ISBLANK - 49)) | (1L << (ISLITERAL - 49)) | (1L << (ISNUMERIC - 49)) | (1L << (REGEX - 49)) | (1L << (SUBSTR - 49)) | (1L << (REPLACE - 49)) | (1L << (EXISTS - 49)) | (1L << (COUNT - 49)) | (1L << (SUM - 49)) | (1L << (MIN - 49)) | (1L << (MAX - 49)) | (1L << (AVG - 49)) | (1L << (GROUP_CONCAT - 49)) | (1L << (TRUE - 49)) | (1L << (FALSE - 49)))) != 0) || ((((_la - 114)) & ~0x3f) == 0 && ((1L << (_la - 114)) & ((1L << (SAMPLE - 114)) | (1L << (PLUS - 114)) | (1L << (DASH - 114)) | (1L << (NOT_SIGN - 114)) | (1L << (OPEN_BRACE - 114)) | (1L << (IRIREF - 114)) | (1L << (PNAME_NS - 114)) | (1L << (PNAME_LN - 114)) | (1L << (VAR1 - 114)) | (1L << (VAR2 - 114)) | (1L << (INTEGER - 114)) | (1L << (DECIMAL - 114)) | (1L << (DOUBLE - 114)) | (1L << (INTEGER_POSITIVE - 114)) | (1L << (DECIMAL_POSITIVE - 114)) | (1L << (DOUBLE_POSITIVE - 114)) | (1L << (INTEGER_NEGATIVE - 114)) | (1L << (DECIMAL_NEGATIVE - 114)) | (1L << (DOUBLE_NEGATIVE - 114)) | (1L << (STRING_LITERAL1 - 114)) | (1L << (STRING_LITERAL2 - 114)) | (1L << (STRING_LITERAL_LONG1 - 114)) | (1L << (STRING_LITERAL_LONG2 - 114)) | (1L << (UNQUOTED_IRIREF - 114)))) != 0) );
}
break;
case ASTERISK:
{
setState(345);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructQueryContext extends ParserRuleContext {
public TerminalNode CONSTRUCT() { return getToken(Sp4rql11Parser.CONSTRUCT, 0); }
public ConstructTemplateContext constructTemplate() {
return getRuleContext(ConstructTemplateContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public SolutionModifierContext solutionModifier() {
return getRuleContext(SolutionModifierContext.class,0);
}
public TerminalNode WHERE() { return getToken(Sp4rql11Parser.WHERE, 0); }
public TerminalNode OPEN_CURLY_BRACE() { return getToken(Sp4rql11Parser.OPEN_CURLY_BRACE, 0); }
public TerminalNode CLOSE_CURLY_BRACE() { return getToken(Sp4rql11Parser.CLOSE_CURLY_BRACE, 0); }
public List datasetClause() {
return getRuleContexts(DatasetClauseContext.class);
}
public DatasetClauseContext datasetClause(int i) {
return getRuleContext(DatasetClauseContext.class,i);
}
public TriplesTemplateContext triplesTemplate() {
return getRuleContext(TriplesTemplateContext.class,0);
}
public ConstructQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterConstructQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitConstructQuery(this);
}
}
public final ConstructQueryContext constructQuery() throws RecognitionException {
ConstructQueryContext _localctx = new ConstructQueryContext(_ctx, getState());
enterRule(_localctx, 18, RULE_constructQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(348);
match(CONSTRUCT);
setState(372);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_CURLY_BRACE:
{
setState(349);
constructTemplate();
setState(353);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FROM) {
{
{
setState(350);
datasetClause();
}
}
setState(355);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(356);
whereClause();
setState(357);
solutionModifier();
}
break;
case WHERE:
case FROM:
{
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FROM) {
{
{
setState(359);
datasetClause();
}
}
setState(364);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(365);
match(WHERE);
setState(366);
match(OPEN_CURLY_BRACE);
setState(368);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(367);
triplesTemplate();
}
}
setState(370);
match(CLOSE_CURLY_BRACE);
setState(371);
solutionModifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DescribeQueryContext extends ParserRuleContext {
public TerminalNode DESCRIBE() { return getToken(Sp4rql11Parser.DESCRIBE, 0); }
public SolutionModifierContext solutionModifier() {
return getRuleContext(SolutionModifierContext.class,0);
}
public TerminalNode ASTERISK() { return getToken(Sp4rql11Parser.ASTERISK, 0); }
public List datasetClause() {
return getRuleContexts(DatasetClauseContext.class);
}
public DatasetClauseContext datasetClause(int i) {
return getRuleContext(DatasetClauseContext.class,i);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public List varOrIri() {
return getRuleContexts(VarOrIriContext.class);
}
public VarOrIriContext varOrIri(int i) {
return getRuleContext(VarOrIriContext.class,i);
}
public DescribeQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_describeQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDescribeQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDescribeQuery(this);
}
}
public final DescribeQueryContext describeQuery() throws RecognitionException {
DescribeQueryContext _localctx = new DescribeQueryContext(_ctx, getState());
enterRule(_localctx, 20, RULE_describeQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(374);
match(DESCRIBE);
setState(381);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case VAR1:
case VAR2:
case UNQUOTED_IRIREF:
{
setState(376);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(375);
varOrIri();
}
}
setState(378);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 142)) & ~0x3f) == 0 && ((1L << (_la - 142)) & ((1L << (IRIREF - 142)) | (1L << (PNAME_NS - 142)) | (1L << (PNAME_LN - 142)) | (1L << (VAR1 - 142)) | (1L << (VAR2 - 142)) | (1L << (UNQUOTED_IRIREF - 142)))) != 0) );
}
break;
case ASTERISK:
{
setState(380);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(386);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FROM) {
{
{
setState(383);
datasetClause();
}
}
setState(388);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(390);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE || _la==OPEN_CURLY_BRACE) {
{
setState(389);
whereClause();
}
}
setState(392);
solutionModifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AskQueryContext extends ParserRuleContext {
public TerminalNode ASK() { return getToken(Sp4rql11Parser.ASK, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public SolutionModifierContext solutionModifier() {
return getRuleContext(SolutionModifierContext.class,0);
}
public List datasetClause() {
return getRuleContexts(DatasetClauseContext.class);
}
public DatasetClauseContext datasetClause(int i) {
return getRuleContext(DatasetClauseContext.class,i);
}
public AskQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_askQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterAskQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitAskQuery(this);
}
}
public final AskQueryContext askQuery() throws RecognitionException {
AskQueryContext _localctx = new AskQueryContext(_ctx, getState());
enterRule(_localctx, 22, RULE_askQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(394);
match(ASK);
setState(398);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FROM) {
{
{
setState(395);
datasetClause();
}
}
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(401);
whereClause();
setState(402);
solutionModifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DatasetClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(Sp4rql11Parser.FROM, 0); }
public DefaultGraphClauseContext defaultGraphClause() {
return getRuleContext(DefaultGraphClauseContext.class,0);
}
public NamedGraphClauseContext namedGraphClause() {
return getRuleContext(NamedGraphClauseContext.class,0);
}
public DatasetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_datasetClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDatasetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDatasetClause(this);
}
}
public final DatasetClauseContext datasetClause() throws RecognitionException {
DatasetClauseContext _localctx = new DatasetClauseContext(_ctx, getState());
enterRule(_localctx, 24, RULE_datasetClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(404);
match(FROM);
setState(407);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEFAULT:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
{
setState(405);
defaultGraphClause();
}
break;
case NAMED:
{
setState(406);
namedGraphClause();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultGraphClauseContext extends ParserRuleContext {
public SourceSelectorContext sourceSelector() {
return getRuleContext(SourceSelectorContext.class,0);
}
public DefaultGraphClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultGraphClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDefaultGraphClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDefaultGraphClause(this);
}
}
public final DefaultGraphClauseContext defaultGraphClause() throws RecognitionException {
DefaultGraphClauseContext _localctx = new DefaultGraphClauseContext(_ctx, getState());
enterRule(_localctx, 26, RULE_defaultGraphClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(409);
sourceSelector();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamedGraphClauseContext extends ParserRuleContext {
public TerminalNode NAMED() { return getToken(Sp4rql11Parser.NAMED, 0); }
public SourceSelectorContext sourceSelector() {
return getRuleContext(SourceSelectorContext.class,0);
}
public NamedGraphClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namedGraphClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterNamedGraphClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitNamedGraphClause(this);
}
}
public final NamedGraphClauseContext namedGraphClause() throws RecognitionException {
NamedGraphClauseContext _localctx = new NamedGraphClauseContext(_ctx, getState());
enterRule(_localctx, 28, RULE_namedGraphClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(411);
match(NAMED);
setState(412);
sourceSelector();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SourceSelectorContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(Sp4rql11Parser.DEFAULT, 0); }
public SourceSelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sourceSelector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterSourceSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitSourceSelector(this);
}
}
public final SourceSelectorContext sourceSelector() throws RecognitionException {
SourceSelectorContext _localctx = new SourceSelectorContext(_ctx, getState());
enterRule(_localctx, 30, RULE_sourceSelector);
try {
setState(416);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(414);
iri();
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 2);
{
setState(415);
match(DEFAULT);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhereClauseContext extends ParserRuleContext {
public GroupGraphPatternContext groupGraphPattern() {
return getRuleContext(GroupGraphPatternContext.class,0);
}
public TerminalNode WHERE() { return getToken(Sp4rql11Parser.WHERE, 0); }
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitWhereClause(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 32, RULE_whereClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(419);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(418);
match(WHERE);
}
}
setState(421);
groupGraphPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SolutionModifierContext extends ParserRuleContext {
public GroupClauseContext groupClause() {
return getRuleContext(GroupClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public OrderClauseContext orderClause() {
return getRuleContext(OrderClauseContext.class,0);
}
public LimitOffsetClausesContext limitOffsetClauses() {
return getRuleContext(LimitOffsetClausesContext.class,0);
}
public SolutionModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_solutionModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterSolutionModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitSolutionModifier(this);
}
}
public final SolutionModifierContext solutionModifier() throws RecognitionException {
SolutionModifierContext _localctx = new SolutionModifierContext(_ctx, getState());
enterRule(_localctx, 34, RULE_solutionModifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(424);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(423);
groupClause();
}
}
setState(427);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(426);
havingClause();
}
}
setState(430);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(429);
orderClause();
}
}
setState(433);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT || _la==OFFSET) {
{
setState(432);
limitOffsetClauses();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupClauseContext extends ParserRuleContext {
public TerminalNode GROUP() { return getToken(Sp4rql11Parser.GROUP, 0); }
public TerminalNode BY() { return getToken(Sp4rql11Parser.BY, 0); }
public List groupCondition() {
return getRuleContexts(GroupConditionContext.class);
}
public GroupConditionContext groupCondition(int i) {
return getRuleContext(GroupConditionContext.class,i);
}
public GroupClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGroupClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGroupClause(this);
}
}
public final GroupClauseContext groupClause() throws RecognitionException {
GroupClauseContext _localctx = new GroupClauseContext(_ctx, getState());
enterRule(_localctx, 36, RULE_groupClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(435);
match(GROUP);
setState(436);
match(BY);
setState(438);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(437);
groupCondition();
}
}
setState(440);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (NOT - 49)) | (1L << (STR - 49)) | (1L << (LANG - 49)) | (1L << (LANGMATCHES - 49)) | (1L << (DATATYPE - 49)) | (1L << (BOUND - 49)) | (1L << (IRI - 49)) | (1L << (URI - 49)) | (1L << (BNODE - 49)) | (1L << (RAND - 49)) | (1L << (ABS - 49)) | (1L << (CEIL - 49)) | (1L << (FLOOR - 49)) | (1L << (ROUND - 49)) | (1L << (CONCAT - 49)) | (1L << (STRLEN - 49)) | (1L << (UCASE - 49)) | (1L << (LCASE - 49)) | (1L << (ENCODE_FOR_URI - 49)) | (1L << (CONTAINS - 49)) | (1L << (STRSTARTS - 49)) | (1L << (STRENDS - 49)) | (1L << (STRBEFORE - 49)) | (1L << (STRAFTER - 49)) | (1L << (YEAR - 49)) | (1L << (MONTH - 49)) | (1L << (DAY - 49)) | (1L << (HOURS - 49)) | (1L << (MINUTES - 49)) | (1L << (SECONDS - 49)) | (1L << (TIMEZONE - 49)) | (1L << (TZ - 49)) | (1L << (NOW - 49)) | (1L << (UUID - 49)) | (1L << (STRUUID - 49)) | (1L << (MD5 - 49)) | (1L << (SHA1 - 49)) | (1L << (SHA256 - 49)) | (1L << (SHA384 - 49)) | (1L << (SHA512 - 49)) | (1L << (COALESCE - 49)) | (1L << (IF - 49)) | (1L << (STRLANG - 49)) | (1L << (STRDT - 49)) | (1L << (SAMETERM - 49)) | (1L << (ISIRI - 49)) | (1L << (ISURI - 49)) | (1L << (ISBLANK - 49)) | (1L << (ISLITERAL - 49)) | (1L << (ISNUMERIC - 49)) | (1L << (REGEX - 49)) | (1L << (SUBSTR - 49)) | (1L << (REPLACE - 49)) | (1L << (EXISTS - 49)) | (1L << (COUNT - 49)) | (1L << (SUM - 49)) | (1L << (MIN - 49)) | (1L << (MAX - 49)) | (1L << (AVG - 49)) | (1L << (GROUP_CONCAT - 49)))) != 0) || ((((_la - 114)) & ~0x3f) == 0 && ((1L << (_la - 114)) & ((1L << (SAMPLE - 114)) | (1L << (OPEN_BRACE - 114)) | (1L << (IRIREF - 114)) | (1L << (PNAME_NS - 114)) | (1L << (PNAME_LN - 114)) | (1L << (VAR1 - 114)) | (1L << (VAR2 - 114)) | (1L << (UNQUOTED_IRIREF - 114)))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupConditionContext extends ParserRuleContext {
public BuiltInCallContext builtInCall() {
return getRuleContext(BuiltInCallContext.class,0);
}
public FunctionCallContext functionCall() {
return getRuleContext(FunctionCallContext.class,0);
}
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public TerminalNode AS() { return getToken(Sp4rql11Parser.AS, 0); }
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public GroupConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupCondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGroupCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGroupCondition(this);
}
}
public final GroupConditionContext groupCondition() throws RecognitionException {
GroupConditionContext _localctx = new GroupConditionContext(_ctx, getState());
enterRule(_localctx, 38, RULE_groupCondition);
int _la;
try {
setState(453);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case SAMPLE:
enterOuterAlt(_localctx, 1);
{
setState(442);
builtInCall();
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 2);
{
setState(443);
functionCall();
}
break;
case OPEN_BRACE:
enterOuterAlt(_localctx, 3);
{
setState(444);
match(OPEN_BRACE);
setState(445);
expression();
setState(448);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(446);
match(AS);
setState(447);
var();
}
}
setState(450);
match(CLOSE_BRACE);
}
break;
case VAR1:
case VAR2:
enterOuterAlt(_localctx, 4);
{
setState(452);
var();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavingClauseContext extends ParserRuleContext {
public TerminalNode HAVING() { return getToken(Sp4rql11Parser.HAVING, 0); }
public List havingCondition() {
return getRuleContexts(HavingConditionContext.class);
}
public HavingConditionContext havingCondition(int i) {
return getRuleContext(HavingConditionContext.class,i);
}
public HavingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterHavingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitHavingClause(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 40, RULE_havingClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(455);
match(HAVING);
setState(457);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(456);
havingCondition();
}
}
setState(459);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (NOT - 49)) | (1L << (STR - 49)) | (1L << (LANG - 49)) | (1L << (LANGMATCHES - 49)) | (1L << (DATATYPE - 49)) | (1L << (BOUND - 49)) | (1L << (IRI - 49)) | (1L << (URI - 49)) | (1L << (BNODE - 49)) | (1L << (RAND - 49)) | (1L << (ABS - 49)) | (1L << (CEIL - 49)) | (1L << (FLOOR - 49)) | (1L << (ROUND - 49)) | (1L << (CONCAT - 49)) | (1L << (STRLEN - 49)) | (1L << (UCASE - 49)) | (1L << (LCASE - 49)) | (1L << (ENCODE_FOR_URI - 49)) | (1L << (CONTAINS - 49)) | (1L << (STRSTARTS - 49)) | (1L << (STRENDS - 49)) | (1L << (STRBEFORE - 49)) | (1L << (STRAFTER - 49)) | (1L << (YEAR - 49)) | (1L << (MONTH - 49)) | (1L << (DAY - 49)) | (1L << (HOURS - 49)) | (1L << (MINUTES - 49)) | (1L << (SECONDS - 49)) | (1L << (TIMEZONE - 49)) | (1L << (TZ - 49)) | (1L << (NOW - 49)) | (1L << (UUID - 49)) | (1L << (STRUUID - 49)) | (1L << (MD5 - 49)) | (1L << (SHA1 - 49)) | (1L << (SHA256 - 49)) | (1L << (SHA384 - 49)) | (1L << (SHA512 - 49)) | (1L << (COALESCE - 49)) | (1L << (IF - 49)) | (1L << (STRLANG - 49)) | (1L << (STRDT - 49)) | (1L << (SAMETERM - 49)) | (1L << (ISIRI - 49)) | (1L << (ISURI - 49)) | (1L << (ISBLANK - 49)) | (1L << (ISLITERAL - 49)) | (1L << (ISNUMERIC - 49)) | (1L << (REGEX - 49)) | (1L << (SUBSTR - 49)) | (1L << (REPLACE - 49)) | (1L << (EXISTS - 49)) | (1L << (COUNT - 49)) | (1L << (SUM - 49)) | (1L << (MIN - 49)) | (1L << (MAX - 49)) | (1L << (AVG - 49)) | (1L << (GROUP_CONCAT - 49)))) != 0) || ((((_la - 114)) & ~0x3f) == 0 && ((1L << (_la - 114)) & ((1L << (SAMPLE - 114)) | (1L << (OPEN_BRACE - 114)) | (1L << (IRIREF - 114)) | (1L << (PNAME_NS - 114)) | (1L << (PNAME_LN - 114)) | (1L << (UNQUOTED_IRIREF - 114)))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavingConditionContext extends ParserRuleContext {
public ConstraintContext constraint() {
return getRuleContext(ConstraintContext.class,0);
}
public HavingConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingCondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterHavingCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitHavingCondition(this);
}
}
public final HavingConditionContext havingCondition() throws RecognitionException {
HavingConditionContext _localctx = new HavingConditionContext(_ctx, getState());
enterRule(_localctx, 42, RULE_havingCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(461);
constraint();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderClauseContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(Sp4rql11Parser.ORDER, 0); }
public TerminalNode BY() { return getToken(Sp4rql11Parser.BY, 0); }
public List orderCondition() {
return getRuleContexts(OrderConditionContext.class);
}
public OrderConditionContext orderCondition(int i) {
return getRuleContext(OrderConditionContext.class,i);
}
public OrderClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterOrderClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitOrderClause(this);
}
}
public final OrderClauseContext orderClause() throws RecognitionException {
OrderClauseContext _localctx = new OrderClauseContext(_ctx, getState());
enterRule(_localctx, 44, RULE_orderClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(463);
match(ORDER);
setState(464);
match(BY);
setState(466);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(465);
orderCondition();
}
}
setState(468);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASC) | (1L << DESC) | (1L << NOT) | (1L << STR) | (1L << LANG) | (1L << LANGMATCHES) | (1L << DATATYPE) | (1L << BOUND) | (1L << IRI) | (1L << URI) | (1L << BNODE) | (1L << RAND) | (1L << ABS) | (1L << CEIL) | (1L << FLOOR) | (1L << ROUND))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (CONCAT - 64)) | (1L << (STRLEN - 64)) | (1L << (UCASE - 64)) | (1L << (LCASE - 64)) | (1L << (ENCODE_FOR_URI - 64)) | (1L << (CONTAINS - 64)) | (1L << (STRSTARTS - 64)) | (1L << (STRENDS - 64)) | (1L << (STRBEFORE - 64)) | (1L << (STRAFTER - 64)) | (1L << (YEAR - 64)) | (1L << (MONTH - 64)) | (1L << (DAY - 64)) | (1L << (HOURS - 64)) | (1L << (MINUTES - 64)) | (1L << (SECONDS - 64)) | (1L << (TIMEZONE - 64)) | (1L << (TZ - 64)) | (1L << (NOW - 64)) | (1L << (UUID - 64)) | (1L << (STRUUID - 64)) | (1L << (MD5 - 64)) | (1L << (SHA1 - 64)) | (1L << (SHA256 - 64)) | (1L << (SHA384 - 64)) | (1L << (SHA512 - 64)) | (1L << (COALESCE - 64)) | (1L << (IF - 64)) | (1L << (STRLANG - 64)) | (1L << (STRDT - 64)) | (1L << (SAMETERM - 64)) | (1L << (ISIRI - 64)) | (1L << (ISURI - 64)) | (1L << (ISBLANK - 64)) | (1L << (ISLITERAL - 64)) | (1L << (ISNUMERIC - 64)) | (1L << (REGEX - 64)) | (1L << (SUBSTR - 64)) | (1L << (REPLACE - 64)) | (1L << (EXISTS - 64)) | (1L << (COUNT - 64)) | (1L << (SUM - 64)) | (1L << (MIN - 64)) | (1L << (MAX - 64)) | (1L << (AVG - 64)) | (1L << (GROUP_CONCAT - 64)) | (1L << (SAMPLE - 64)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (OPEN_BRACE - 131)) | (1L << (IRIREF - 131)) | (1L << (PNAME_NS - 131)) | (1L << (PNAME_LN - 131)) | (1L << (VAR1 - 131)) | (1L << (VAR2 - 131)) | (1L << (UNQUOTED_IRIREF - 131)))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderConditionContext extends ParserRuleContext {
public BrackettedExpressionContext brackettedExpression() {
return getRuleContext(BrackettedExpressionContext.class,0);
}
public TerminalNode ASC() { return getToken(Sp4rql11Parser.ASC, 0); }
public TerminalNode DESC() { return getToken(Sp4rql11Parser.DESC, 0); }
public ConstraintContext constraint() {
return getRuleContext(ConstraintContext.class,0);
}
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public OrderConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderCondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterOrderCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitOrderCondition(this);
}
}
public final OrderConditionContext orderCondition() throws RecognitionException {
OrderConditionContext _localctx = new OrderConditionContext(_ctx, getState());
enterRule(_localctx, 46, RULE_orderCondition);
int _la;
try {
setState(476);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASC:
case DESC:
enterOuterAlt(_localctx, 1);
{
{
setState(470);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(471);
brackettedExpression();
}
}
break;
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case SAMPLE:
case OPEN_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case VAR1:
case VAR2:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 2);
{
setState(474);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case SAMPLE:
case OPEN_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
{
setState(472);
constraint();
}
break;
case VAR1:
case VAR2:
{
setState(473);
var();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LimitOffsetClausesContext extends ParserRuleContext {
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public OffsetClauseContext offsetClause() {
return getRuleContext(OffsetClauseContext.class,0);
}
public LimitOffsetClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limitOffsetClauses; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterLimitOffsetClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitLimitOffsetClauses(this);
}
}
public final LimitOffsetClausesContext limitOffsetClauses() throws RecognitionException {
LimitOffsetClausesContext _localctx = new LimitOffsetClausesContext(_ctx, getState());
enterRule(_localctx, 48, RULE_limitOffsetClauses);
int _la;
try {
setState(486);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIMIT:
enterOuterAlt(_localctx, 1);
{
setState(478);
limitClause();
setState(480);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OFFSET) {
{
setState(479);
offsetClause();
}
}
}
break;
case OFFSET:
enterOuterAlt(_localctx, 2);
{
setState(482);
offsetClause();
setState(484);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT) {
{
setState(483);
limitClause();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LimitClauseContext extends ParserRuleContext {
public TerminalNode LIMIT() { return getToken(Sp4rql11Parser.LIMIT, 0); }
public TerminalNode INTEGER() { return getToken(Sp4rql11Parser.INTEGER, 0); }
public LimitClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limitClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterLimitClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitLimitClause(this);
}
}
public final LimitClauseContext limitClause() throws RecognitionException {
LimitClauseContext _localctx = new LimitClauseContext(_ctx, getState());
enterRule(_localctx, 50, RULE_limitClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(488);
match(LIMIT);
setState(489);
match(INTEGER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OffsetClauseContext extends ParserRuleContext {
public TerminalNode OFFSET() { return getToken(Sp4rql11Parser.OFFSET, 0); }
public TerminalNode INTEGER() { return getToken(Sp4rql11Parser.INTEGER, 0); }
public OffsetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_offsetClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterOffsetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitOffsetClause(this);
}
}
public final OffsetClauseContext offsetClause() throws RecognitionException {
OffsetClauseContext _localctx = new OffsetClauseContext(_ctx, getState());
enterRule(_localctx, 52, RULE_offsetClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(491);
match(OFFSET);
setState(492);
match(INTEGER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValuesClauseContext extends ParserRuleContext {
public TerminalNode VALUES() { return getToken(Sp4rql11Parser.VALUES, 0); }
public DataBlockContext dataBlock() {
return getRuleContext(DataBlockContext.class,0);
}
public ValuesClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valuesClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterValuesClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitValuesClause(this);
}
}
public final ValuesClauseContext valuesClause() throws RecognitionException {
ValuesClauseContext _localctx = new ValuesClauseContext(_ctx, getState());
enterRule(_localctx, 54, RULE_valuesClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(496);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==VALUES) {
{
setState(494);
match(VALUES);
setState(495);
dataBlock();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateContext extends ParserRuleContext {
public PrologueContext prologue() {
return getRuleContext(PrologueContext.class,0);
}
public Update1Context update1() {
return getRuleContext(Update1Context.class,0);
}
public TerminalNode SEMICOLON() { return getToken(Sp4rql11Parser.SEMICOLON, 0); }
public UpdateContext update() {
return getRuleContext(UpdateContext.class,0);
}
public UpdateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_update; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterUpdate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitUpdate(this);
}
}
public final UpdateContext update() throws RecognitionException {
UpdateContext _localctx = new UpdateContext(_ctx, getState());
enterRule(_localctx, 56, RULE_update);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(498);
prologue();
setState(504);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LOAD) | (1L << CLEAR) | (1L << DROP) | (1L << CREATE) | (1L << ADD) | (1L << MOVE) | (1L << COPY) | (1L << INSERT) | (1L << DELETE) | (1L << WITH))) != 0)) {
{
setState(499);
update1();
setState(502);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(500);
match(SEMICOLON);
setState(501);
update();
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Update1Context extends ParserRuleContext {
public LoadContext load() {
return getRuleContext(LoadContext.class,0);
}
public ClearContext clear() {
return getRuleContext(ClearContext.class,0);
}
public DropContext drop() {
return getRuleContext(DropContext.class,0);
}
public AddContext add() {
return getRuleContext(AddContext.class,0);
}
public MoveContext move() {
return getRuleContext(MoveContext.class,0);
}
public CopyContext copy() {
return getRuleContext(CopyContext.class,0);
}
public CreateContext create() {
return getRuleContext(CreateContext.class,0);
}
public InsertDataContext insertData() {
return getRuleContext(InsertDataContext.class,0);
}
public DeleteDataContext deleteData() {
return getRuleContext(DeleteDataContext.class,0);
}
public DeleteWhereContext deleteWhere() {
return getRuleContext(DeleteWhereContext.class,0);
}
public ModifyContext modify() {
return getRuleContext(ModifyContext.class,0);
}
public Update1Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_update1; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterUpdate1(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitUpdate1(this);
}
}
public final Update1Context update1() throws RecognitionException {
Update1Context _localctx = new Update1Context(_ctx, getState());
enterRule(_localctx, 58, RULE_update1);
try {
setState(517);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(506);
load();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(507);
clear();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(508);
drop();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(509);
add();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(510);
move();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(511);
copy();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(512);
create();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(513);
insertData();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(514);
deleteData();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(515);
deleteWhere();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(516);
modify();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LoadContext extends ParserRuleContext {
public TerminalNode LOAD() { return getToken(Sp4rql11Parser.LOAD, 0); }
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public TerminalNode SILENT() { return getToken(Sp4rql11Parser.SILENT, 0); }
public TerminalNode INTO() { return getToken(Sp4rql11Parser.INTO, 0); }
public GraphRefContext graphRef() {
return getRuleContext(GraphRefContext.class,0);
}
public LoadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_load; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitLoad(this);
}
}
public final LoadContext load() throws RecognitionException {
LoadContext _localctx = new LoadContext(_ctx, getState());
enterRule(_localctx, 60, RULE_load);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(519);
match(LOAD);
setState(521);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SILENT) {
{
setState(520);
match(SILENT);
}
}
setState(523);
iri();
setState(526);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTO) {
{
setState(524);
match(INTO);
setState(525);
graphRef();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClearContext extends ParserRuleContext {
public TerminalNode CLEAR() { return getToken(Sp4rql11Parser.CLEAR, 0); }
public GraphRefAllContext graphRefAll() {
return getRuleContext(GraphRefAllContext.class,0);
}
public TerminalNode SILENT() { return getToken(Sp4rql11Parser.SILENT, 0); }
public ClearContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_clear; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterClear(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitClear(this);
}
}
public final ClearContext clear() throws RecognitionException {
ClearContext _localctx = new ClearContext(_ctx, getState());
enterRule(_localctx, 62, RULE_clear);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(528);
match(CLEAR);
setState(530);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SILENT) {
{
setState(529);
match(SILENT);
}
}
setState(532);
graphRefAll();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DropContext extends ParserRuleContext {
public TerminalNode DROP() { return getToken(Sp4rql11Parser.DROP, 0); }
public GraphRefAllContext graphRefAll() {
return getRuleContext(GraphRefAllContext.class,0);
}
public TerminalNode SILENT() { return getToken(Sp4rql11Parser.SILENT, 0); }
public DropContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDrop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDrop(this);
}
}
public final DropContext drop() throws RecognitionException {
DropContext _localctx = new DropContext(_ctx, getState());
enterRule(_localctx, 64, RULE_drop);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(534);
match(DROP);
setState(536);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SILENT) {
{
setState(535);
match(SILENT);
}
}
setState(538);
graphRefAll();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateContext extends ParserRuleContext {
public TerminalNode CREATE() { return getToken(Sp4rql11Parser.CREATE, 0); }
public GraphRefContext graphRef() {
return getRuleContext(GraphRefContext.class,0);
}
public TerminalNode SILENT() { return getToken(Sp4rql11Parser.SILENT, 0); }
public CreateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterCreate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitCreate(this);
}
}
public final CreateContext create() throws RecognitionException {
CreateContext _localctx = new CreateContext(_ctx, getState());
enterRule(_localctx, 66, RULE_create);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(540);
match(CREATE);
setState(542);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SILENT) {
{
setState(541);
match(SILENT);
}
}
setState(544);
graphRef();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AddContext extends ParserRuleContext {
public TerminalNode ADD() { return getToken(Sp4rql11Parser.ADD, 0); }
public List graphOrDefault() {
return getRuleContexts(GraphOrDefaultContext.class);
}
public GraphOrDefaultContext graphOrDefault(int i) {
return getRuleContext(GraphOrDefaultContext.class,i);
}
public TerminalNode TO() { return getToken(Sp4rql11Parser.TO, 0); }
public TerminalNode SILENT() { return getToken(Sp4rql11Parser.SILENT, 0); }
public AddContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_add; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterAdd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitAdd(this);
}
}
public final AddContext add() throws RecognitionException {
AddContext _localctx = new AddContext(_ctx, getState());
enterRule(_localctx, 68, RULE_add);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(546);
match(ADD);
setState(548);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SILENT) {
{
setState(547);
match(SILENT);
}
}
setState(550);
graphOrDefault();
setState(551);
match(TO);
setState(552);
graphOrDefault();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MoveContext extends ParserRuleContext {
public TerminalNode MOVE() { return getToken(Sp4rql11Parser.MOVE, 0); }
public List graphOrDefault() {
return getRuleContexts(GraphOrDefaultContext.class);
}
public GraphOrDefaultContext graphOrDefault(int i) {
return getRuleContext(GraphOrDefaultContext.class,i);
}
public TerminalNode TO() { return getToken(Sp4rql11Parser.TO, 0); }
public TerminalNode SILENT() { return getToken(Sp4rql11Parser.SILENT, 0); }
public MoveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_move; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterMove(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitMove(this);
}
}
public final MoveContext move() throws RecognitionException {
MoveContext _localctx = new MoveContext(_ctx, getState());
enterRule(_localctx, 70, RULE_move);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(554);
match(MOVE);
setState(556);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SILENT) {
{
setState(555);
match(SILENT);
}
}
setState(558);
graphOrDefault();
setState(559);
match(TO);
setState(560);
graphOrDefault();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyContext extends ParserRuleContext {
public TerminalNode COPY() { return getToken(Sp4rql11Parser.COPY, 0); }
public List graphOrDefault() {
return getRuleContexts(GraphOrDefaultContext.class);
}
public GraphOrDefaultContext graphOrDefault(int i) {
return getRuleContext(GraphOrDefaultContext.class,i);
}
public TerminalNode TO() { return getToken(Sp4rql11Parser.TO, 0); }
public TerminalNode SILENT() { return getToken(Sp4rql11Parser.SILENT, 0); }
public CopyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copy; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterCopy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitCopy(this);
}
}
public final CopyContext copy() throws RecognitionException {
CopyContext _localctx = new CopyContext(_ctx, getState());
enterRule(_localctx, 72, RULE_copy);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(562);
match(COPY);
setState(564);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SILENT) {
{
setState(563);
match(SILENT);
}
}
setState(566);
graphOrDefault();
setState(567);
match(TO);
setState(568);
graphOrDefault();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertDataContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(Sp4rql11Parser.INSERT, 0); }
public TerminalNode DATA() { return getToken(Sp4rql11Parser.DATA, 0); }
public QuadDataContext quadData() {
return getRuleContext(QuadDataContext.class,0);
}
public InsertDataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertData; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterInsertData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitInsertData(this);
}
}
public final InsertDataContext insertData() throws RecognitionException {
InsertDataContext _localctx = new InsertDataContext(_ctx, getState());
enterRule(_localctx, 74, RULE_insertData);
try {
enterOuterAlt(_localctx, 1);
{
setState(570);
match(INSERT);
setState(571);
match(DATA);
setState(572);
quadData();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeleteDataContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(Sp4rql11Parser.DELETE, 0); }
public TerminalNode DATA() { return getToken(Sp4rql11Parser.DATA, 0); }
public QuadDataContext quadData() {
return getRuleContext(QuadDataContext.class,0);
}
public DeleteDataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteData; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDeleteData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDeleteData(this);
}
}
public final DeleteDataContext deleteData() throws RecognitionException {
DeleteDataContext _localctx = new DeleteDataContext(_ctx, getState());
enterRule(_localctx, 76, RULE_deleteData);
try {
enterOuterAlt(_localctx, 1);
{
setState(574);
match(DELETE);
setState(575);
match(DATA);
setState(576);
quadData();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeleteWhereContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(Sp4rql11Parser.DELETE, 0); }
public TerminalNode WHERE() { return getToken(Sp4rql11Parser.WHERE, 0); }
public QuadPatternContext quadPattern() {
return getRuleContext(QuadPatternContext.class,0);
}
public DeleteWhereContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteWhere; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDeleteWhere(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDeleteWhere(this);
}
}
public final DeleteWhereContext deleteWhere() throws RecognitionException {
DeleteWhereContext _localctx = new DeleteWhereContext(_ctx, getState());
enterRule(_localctx, 78, RULE_deleteWhere);
try {
enterOuterAlt(_localctx, 1);
{
setState(578);
match(DELETE);
setState(579);
match(WHERE);
setState(580);
quadPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModifyContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(Sp4rql11Parser.WHERE, 0); }
public GroupGraphPatternContext groupGraphPattern() {
return getRuleContext(GroupGraphPatternContext.class,0);
}
public DeleteClauseContext deleteClause() {
return getRuleContext(DeleteClauseContext.class,0);
}
public InsertClauseContext insertClause() {
return getRuleContext(InsertClauseContext.class,0);
}
public TerminalNode WITH() { return getToken(Sp4rql11Parser.WITH, 0); }
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public List usingClause() {
return getRuleContexts(UsingClauseContext.class);
}
public UsingClauseContext usingClause(int i) {
return getRuleContext(UsingClauseContext.class,i);
}
public ModifyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_modify; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterModify(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitModify(this);
}
}
public final ModifyContext modify() throws RecognitionException {
ModifyContext _localctx = new ModifyContext(_ctx, getState());
enterRule(_localctx, 80, RULE_modify);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(584);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(582);
match(WITH);
setState(583);
iri();
}
}
setState(591);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DELETE:
{
setState(586);
deleteClause();
setState(588);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INSERT) {
{
setState(587);
insertClause();
}
}
}
break;
case INSERT:
{
setState(590);
insertClause();
}
break;
default:
throw new NoViableAltException(this);
}
setState(596);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==USING) {
{
{
setState(593);
usingClause();
}
}
setState(598);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(599);
match(WHERE);
setState(600);
groupGraphPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeleteClauseContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(Sp4rql11Parser.DELETE, 0); }
public QuadPatternContext quadPattern() {
return getRuleContext(QuadPatternContext.class,0);
}
public DeleteClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDeleteClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDeleteClause(this);
}
}
public final DeleteClauseContext deleteClause() throws RecognitionException {
DeleteClauseContext _localctx = new DeleteClauseContext(_ctx, getState());
enterRule(_localctx, 82, RULE_deleteClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(602);
match(DELETE);
setState(603);
quadPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertClauseContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(Sp4rql11Parser.INSERT, 0); }
public QuadPatternContext quadPattern() {
return getRuleContext(QuadPatternContext.class,0);
}
public InsertClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterInsertClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitInsertClause(this);
}
}
public final InsertClauseContext insertClause() throws RecognitionException {
InsertClauseContext _localctx = new InsertClauseContext(_ctx, getState());
enterRule(_localctx, 84, RULE_insertClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(605);
match(INSERT);
setState(606);
quadPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UsingClauseContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(Sp4rql11Parser.USING, 0); }
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public TerminalNode NAMED() { return getToken(Sp4rql11Parser.NAMED, 0); }
public UsingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_usingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterUsingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitUsingClause(this);
}
}
public final UsingClauseContext usingClause() throws RecognitionException {
UsingClauseContext _localctx = new UsingClauseContext(_ctx, getState());
enterRule(_localctx, 86, RULE_usingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(608);
match(USING);
setState(612);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
{
setState(609);
iri();
}
break;
case NAMED:
{
setState(610);
match(NAMED);
setState(611);
iri();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GraphOrDefaultContext extends ParserRuleContext {
public TerminalNode DEFAULT() { return getToken(Sp4rql11Parser.DEFAULT, 0); }
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public TerminalNode GRAPH() { return getToken(Sp4rql11Parser.GRAPH, 0); }
public GraphOrDefaultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphOrDefault; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGraphOrDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGraphOrDefault(this);
}
}
public final GraphOrDefaultContext graphOrDefault() throws RecognitionException {
GraphOrDefaultContext _localctx = new GraphOrDefaultContext(_ctx, getState());
enterRule(_localctx, 88, RULE_graphOrDefault);
int _la;
try {
setState(619);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEFAULT:
enterOuterAlt(_localctx, 1);
{
setState(614);
match(DEFAULT);
}
break;
case GRAPH:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 2);
{
setState(616);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GRAPH) {
{
setState(615);
match(GRAPH);
}
}
setState(618);
iri();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GraphRefContext extends ParserRuleContext {
public TerminalNode GRAPH() { return getToken(Sp4rql11Parser.GRAPH, 0); }
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public GraphRefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphRef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGraphRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGraphRef(this);
}
}
public final GraphRefContext graphRef() throws RecognitionException {
GraphRefContext _localctx = new GraphRefContext(_ctx, getState());
enterRule(_localctx, 90, RULE_graphRef);
try {
enterOuterAlt(_localctx, 1);
{
setState(621);
match(GRAPH);
setState(622);
iri();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GraphRefAllContext extends ParserRuleContext {
public GraphRefContext graphRef() {
return getRuleContext(GraphRefContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(Sp4rql11Parser.DEFAULT, 0); }
public TerminalNode NAMED() { return getToken(Sp4rql11Parser.NAMED, 0); }
public TerminalNode ALL() { return getToken(Sp4rql11Parser.ALL, 0); }
public GraphRefAllContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphRefAll; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGraphRefAll(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGraphRefAll(this);
}
}
public final GraphRefAllContext graphRefAll() throws RecognitionException {
GraphRefAllContext _localctx = new GraphRefAllContext(_ctx, getState());
enterRule(_localctx, 92, RULE_graphRefAll);
try {
setState(628);
_errHandler.sync(this);
switch (_input.LA(1)) {
case GRAPH:
enterOuterAlt(_localctx, 1);
{
setState(624);
graphRef();
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 2);
{
setState(625);
match(DEFAULT);
}
break;
case NAMED:
enterOuterAlt(_localctx, 3);
{
setState(626);
match(NAMED);
}
break;
case ALL:
enterOuterAlt(_localctx, 4);
{
setState(627);
match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuadPatternContext extends ParserRuleContext {
public TerminalNode OPEN_CURLY_BRACE() { return getToken(Sp4rql11Parser.OPEN_CURLY_BRACE, 0); }
public QuadsContext quads() {
return getRuleContext(QuadsContext.class,0);
}
public TerminalNode CLOSE_CURLY_BRACE() { return getToken(Sp4rql11Parser.CLOSE_CURLY_BRACE, 0); }
public QuadPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quadPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterQuadPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitQuadPattern(this);
}
}
public final QuadPatternContext quadPattern() throws RecognitionException {
QuadPatternContext _localctx = new QuadPatternContext(_ctx, getState());
enterRule(_localctx, 94, RULE_quadPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(630);
match(OPEN_CURLY_BRACE);
setState(631);
quads();
setState(632);
match(CLOSE_CURLY_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuadDataContext extends ParserRuleContext {
public TerminalNode OPEN_CURLY_BRACE() { return getToken(Sp4rql11Parser.OPEN_CURLY_BRACE, 0); }
public QuadsContext quads() {
return getRuleContext(QuadsContext.class,0);
}
public TerminalNode CLOSE_CURLY_BRACE() { return getToken(Sp4rql11Parser.CLOSE_CURLY_BRACE, 0); }
public QuadDataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quadData; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterQuadData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitQuadData(this);
}
}
public final QuadDataContext quadData() throws RecognitionException {
QuadDataContext _localctx = new QuadDataContext(_ctx, getState());
enterRule(_localctx, 96, RULE_quadData);
try {
enterOuterAlt(_localctx, 1);
{
setState(634);
match(OPEN_CURLY_BRACE);
setState(635);
quads();
setState(636);
match(CLOSE_CURLY_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuadsContext extends ParserRuleContext {
public List triplesTemplate() {
return getRuleContexts(TriplesTemplateContext.class);
}
public TriplesTemplateContext triplesTemplate(int i) {
return getRuleContext(TriplesTemplateContext.class,i);
}
public List quadsNotTriples() {
return getRuleContexts(QuadsNotTriplesContext.class);
}
public QuadsNotTriplesContext quadsNotTriples(int i) {
return getRuleContext(QuadsNotTriplesContext.class,i);
}
public List DOT() { return getTokens(Sp4rql11Parser.DOT); }
public TerminalNode DOT(int i) {
return getToken(Sp4rql11Parser.DOT, i);
}
public QuadsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quads; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterQuads(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitQuads(this);
}
}
public final QuadsContext quads() throws RecognitionException {
QuadsContext _localctx = new QuadsContext(_ctx, getState());
enterRule(_localctx, 98, RULE_quads);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(639);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(638);
triplesTemplate();
}
}
setState(650);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==GRAPH) {
{
{
setState(641);
quadsNotTriples();
setState(643);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(642);
match(DOT);
}
}
setState(646);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(645);
triplesTemplate();
}
}
}
}
setState(652);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuadsNotTriplesContext extends ParserRuleContext {
public TerminalNode GRAPH() { return getToken(Sp4rql11Parser.GRAPH, 0); }
public VarOrIriContext varOrIri() {
return getRuleContext(VarOrIriContext.class,0);
}
public TerminalNode OPEN_CURLY_BRACE() { return getToken(Sp4rql11Parser.OPEN_CURLY_BRACE, 0); }
public TerminalNode CLOSE_CURLY_BRACE() { return getToken(Sp4rql11Parser.CLOSE_CURLY_BRACE, 0); }
public TriplesTemplateContext triplesTemplate() {
return getRuleContext(TriplesTemplateContext.class,0);
}
public QuadsNotTriplesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quadsNotTriples; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterQuadsNotTriples(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitQuadsNotTriples(this);
}
}
public final QuadsNotTriplesContext quadsNotTriples() throws RecognitionException {
QuadsNotTriplesContext _localctx = new QuadsNotTriplesContext(_ctx, getState());
enterRule(_localctx, 100, RULE_quadsNotTriples);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(653);
match(GRAPH);
setState(654);
varOrIri();
setState(655);
match(OPEN_CURLY_BRACE);
setState(657);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(656);
triplesTemplate();
}
}
setState(659);
match(CLOSE_CURLY_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TriplesTemplateContext extends ParserRuleContext {
public TriplesSameSubjectContext triplesSameSubject() {
return getRuleContext(TriplesSameSubjectContext.class,0);
}
public TerminalNode DOT() { return getToken(Sp4rql11Parser.DOT, 0); }
public TriplesTemplateContext triplesTemplate() {
return getRuleContext(TriplesTemplateContext.class,0);
}
public TriplesTemplateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_triplesTemplate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterTriplesTemplate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitTriplesTemplate(this);
}
}
public final TriplesTemplateContext triplesTemplate() throws RecognitionException {
TriplesTemplateContext _localctx = new TriplesTemplateContext(_ctx, getState());
enterRule(_localctx, 102, RULE_triplesTemplate);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(661);
triplesSameSubject();
setState(666);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(662);
match(DOT);
setState(664);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(663);
triplesTemplate();
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupGraphPatternContext extends ParserRuleContext {
public TerminalNode OPEN_CURLY_BRACE() { return getToken(Sp4rql11Parser.OPEN_CURLY_BRACE, 0); }
public TerminalNode CLOSE_CURLY_BRACE() { return getToken(Sp4rql11Parser.CLOSE_CURLY_BRACE, 0); }
public SubSelectContext subSelect() {
return getRuleContext(SubSelectContext.class,0);
}
public GroupGraphPatternSubContext groupGraphPatternSub() {
return getRuleContext(GroupGraphPatternSubContext.class,0);
}
public GroupGraphPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupGraphPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGroupGraphPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGroupGraphPattern(this);
}
}
public final GroupGraphPatternContext groupGraphPattern() throws RecognitionException {
GroupGraphPatternContext _localctx = new GroupGraphPatternContext(_ctx, getState());
enterRule(_localctx, 104, RULE_groupGraphPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(668);
match(OPEN_CURLY_BRACE);
setState(671);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
{
setState(669);
subSelect();
}
break;
case T__0:
case GRAPH:
case OPTIONAL:
case SERVICE:
case BIND:
case MINUS:
case FILTER:
case TRUE:
case FALSE:
case VALUES:
case OPEN_CURLY_BRACE:
case CLOSE_CURLY_BRACE:
case OPEN_BRACE:
case OPEN_SQUARE_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case NIL:
case ANON:
case UNQUOTED_IRIREF:
{
setState(670);
groupGraphPatternSub();
}
break;
default:
throw new NoViableAltException(this);
}
setState(673);
match(CLOSE_CURLY_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupGraphPatternSubContext extends ParserRuleContext {
public List triplesBlock() {
return getRuleContexts(TriplesBlockContext.class);
}
public TriplesBlockContext triplesBlock(int i) {
return getRuleContext(TriplesBlockContext.class,i);
}
public List graphPatternNotTriples() {
return getRuleContexts(GraphPatternNotTriplesContext.class);
}
public GraphPatternNotTriplesContext graphPatternNotTriples(int i) {
return getRuleContext(GraphPatternNotTriplesContext.class,i);
}
public List DOT() { return getTokens(Sp4rql11Parser.DOT); }
public TerminalNode DOT(int i) {
return getToken(Sp4rql11Parser.DOT, i);
}
public GroupGraphPatternSubContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupGraphPatternSub; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGroupGraphPatternSub(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGroupGraphPatternSub(this);
}
}
public final GroupGraphPatternSubContext groupGraphPatternSub() throws RecognitionException {
GroupGraphPatternSubContext _localctx = new GroupGraphPatternSubContext(_ctx, getState());
enterRule(_localctx, 106, RULE_groupGraphPatternSub);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(676);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(675);
triplesBlock();
}
}
setState(687);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GRAPH) | (1L << OPTIONAL) | (1L << SERVICE) | (1L << BIND) | (1L << MINUS) | (1L << FILTER))) != 0) || _la==VALUES || _la==OPEN_CURLY_BRACE) {
{
{
setState(678);
graphPatternNotTriples();
setState(680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(679);
match(DOT);
}
}
setState(683);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(682);
triplesBlock();
}
}
}
}
setState(689);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TriplesBlockContext extends ParserRuleContext {
public TriplesSameSubjectPathContext triplesSameSubjectPath() {
return getRuleContext(TriplesSameSubjectPathContext.class,0);
}
public TerminalNode DOT() { return getToken(Sp4rql11Parser.DOT, 0); }
public TriplesBlockContext triplesBlock() {
return getRuleContext(TriplesBlockContext.class,0);
}
public TriplesBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_triplesBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterTriplesBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitTriplesBlock(this);
}
}
public final TriplesBlockContext triplesBlock() throws RecognitionException {
TriplesBlockContext _localctx = new TriplesBlockContext(_ctx, getState());
enterRule(_localctx, 108, RULE_triplesBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(690);
triplesSameSubjectPath();
setState(695);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(691);
match(DOT);
setState(693);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(692);
triplesBlock();
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GraphPatternNotTriplesContext extends ParserRuleContext {
public GroupOrUnionGraphPatternContext groupOrUnionGraphPattern() {
return getRuleContext(GroupOrUnionGraphPatternContext.class,0);
}
public OptionalGraphPatternContext optionalGraphPattern() {
return getRuleContext(OptionalGraphPatternContext.class,0);
}
public MinusGraphPatternContext minusGraphPattern() {
return getRuleContext(MinusGraphPatternContext.class,0);
}
public GraphGraphPatternContext graphGraphPattern() {
return getRuleContext(GraphGraphPatternContext.class,0);
}
public ServiceGraphPatternContext serviceGraphPattern() {
return getRuleContext(ServiceGraphPatternContext.class,0);
}
public FilterContext filter() {
return getRuleContext(FilterContext.class,0);
}
public BindContext bind() {
return getRuleContext(BindContext.class,0);
}
public InlineDataContext inlineData() {
return getRuleContext(InlineDataContext.class,0);
}
public GraphPatternNotTriplesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphPatternNotTriples; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGraphPatternNotTriples(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGraphPatternNotTriples(this);
}
}
public final GraphPatternNotTriplesContext graphPatternNotTriples() throws RecognitionException {
GraphPatternNotTriplesContext _localctx = new GraphPatternNotTriplesContext(_ctx, getState());
enterRule(_localctx, 110, RULE_graphPatternNotTriples);
try {
setState(705);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_CURLY_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(697);
groupOrUnionGraphPattern();
}
break;
case OPTIONAL:
enterOuterAlt(_localctx, 2);
{
setState(698);
optionalGraphPattern();
}
break;
case MINUS:
enterOuterAlt(_localctx, 3);
{
setState(699);
minusGraphPattern();
}
break;
case GRAPH:
enterOuterAlt(_localctx, 4);
{
setState(700);
graphGraphPattern();
}
break;
case SERVICE:
enterOuterAlt(_localctx, 5);
{
setState(701);
serviceGraphPattern();
}
break;
case FILTER:
enterOuterAlt(_localctx, 6);
{
setState(702);
filter();
}
break;
case BIND:
enterOuterAlt(_localctx, 7);
{
setState(703);
bind();
}
break;
case VALUES:
enterOuterAlt(_localctx, 8);
{
setState(704);
inlineData();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptionalGraphPatternContext extends ParserRuleContext {
public TerminalNode OPTIONAL() { return getToken(Sp4rql11Parser.OPTIONAL, 0); }
public GroupGraphPatternContext groupGraphPattern() {
return getRuleContext(GroupGraphPatternContext.class,0);
}
public OptionalGraphPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionalGraphPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterOptionalGraphPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitOptionalGraphPattern(this);
}
}
public final OptionalGraphPatternContext optionalGraphPattern() throws RecognitionException {
OptionalGraphPatternContext _localctx = new OptionalGraphPatternContext(_ctx, getState());
enterRule(_localctx, 112, RULE_optionalGraphPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(707);
match(OPTIONAL);
setState(708);
groupGraphPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GraphGraphPatternContext extends ParserRuleContext {
public TerminalNode GRAPH() { return getToken(Sp4rql11Parser.GRAPH, 0); }
public VarOrIriContext varOrIri() {
return getRuleContext(VarOrIriContext.class,0);
}
public GroupGraphPatternContext groupGraphPattern() {
return getRuleContext(GroupGraphPatternContext.class,0);
}
public GraphGraphPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphGraphPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGraphGraphPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGraphGraphPattern(this);
}
}
public final GraphGraphPatternContext graphGraphPattern() throws RecognitionException {
GraphGraphPatternContext _localctx = new GraphGraphPatternContext(_ctx, getState());
enterRule(_localctx, 114, RULE_graphGraphPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(710);
match(GRAPH);
setState(711);
varOrIri();
setState(712);
groupGraphPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ServiceGraphPatternContext extends ParserRuleContext {
public TerminalNode SERVICE() { return getToken(Sp4rql11Parser.SERVICE, 0); }
public VarOrIriContext varOrIri() {
return getRuleContext(VarOrIriContext.class,0);
}
public GroupGraphPatternContext groupGraphPattern() {
return getRuleContext(GroupGraphPatternContext.class,0);
}
public TerminalNode SILENT() { return getToken(Sp4rql11Parser.SILENT, 0); }
public ServiceGraphPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_serviceGraphPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterServiceGraphPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitServiceGraphPattern(this);
}
}
public final ServiceGraphPatternContext serviceGraphPattern() throws RecognitionException {
ServiceGraphPatternContext _localctx = new ServiceGraphPatternContext(_ctx, getState());
enterRule(_localctx, 116, RULE_serviceGraphPattern);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(714);
match(SERVICE);
setState(716);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SILENT) {
{
setState(715);
match(SILENT);
}
}
setState(718);
varOrIri();
setState(719);
groupGraphPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BindContext extends ParserRuleContext {
public TerminalNode BIND() { return getToken(Sp4rql11Parser.BIND, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public ExpressionOrEmbTPContext expressionOrEmbTP() {
return getRuleContext(ExpressionOrEmbTPContext.class,0);
}
public TerminalNode AS() { return getToken(Sp4rql11Parser.AS, 0); }
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public BindContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bind; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterBind(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitBind(this);
}
}
public final BindContext bind() throws RecognitionException {
BindContext _localctx = new BindContext(_ctx, getState());
enterRule(_localctx, 118, RULE_bind);
try {
enterOuterAlt(_localctx, 1);
{
setState(721);
match(BIND);
setState(722);
match(OPEN_BRACE);
setState(723);
expressionOrEmbTP();
setState(724);
match(AS);
setState(725);
var();
setState(726);
match(CLOSE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InlineDataContext extends ParserRuleContext {
public TerminalNode VALUES() { return getToken(Sp4rql11Parser.VALUES, 0); }
public DataBlockContext dataBlock() {
return getRuleContext(DataBlockContext.class,0);
}
public InlineDataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inlineData; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterInlineData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitInlineData(this);
}
}
public final InlineDataContext inlineData() throws RecognitionException {
InlineDataContext _localctx = new InlineDataContext(_ctx, getState());
enterRule(_localctx, 120, RULE_inlineData);
try {
enterOuterAlt(_localctx, 1);
{
setState(728);
match(VALUES);
setState(729);
dataBlock();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataBlockContext extends ParserRuleContext {
public InlineDataOneVarContext inlineDataOneVar() {
return getRuleContext(InlineDataOneVarContext.class,0);
}
public InlineDataFullContext inlineDataFull() {
return getRuleContext(InlineDataFullContext.class,0);
}
public DataBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDataBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDataBlock(this);
}
}
public final DataBlockContext dataBlock() throws RecognitionException {
DataBlockContext _localctx = new DataBlockContext(_ctx, getState());
enterRule(_localctx, 122, RULE_dataBlock);
try {
setState(733);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR1:
case VAR2:
enterOuterAlt(_localctx, 1);
{
setState(731);
inlineDataOneVar();
}
break;
case OPEN_BRACE:
case NIL:
enterOuterAlt(_localctx, 2);
{
setState(732);
inlineDataFull();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InlineDataOneVarContext extends ParserRuleContext {
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public TerminalNode OPEN_CURLY_BRACE() { return getToken(Sp4rql11Parser.OPEN_CURLY_BRACE, 0); }
public TerminalNode CLOSE_CURLY_BRACE() { return getToken(Sp4rql11Parser.CLOSE_CURLY_BRACE, 0); }
public List dataBlockValue() {
return getRuleContexts(DataBlockValueContext.class);
}
public DataBlockValueContext dataBlockValue(int i) {
return getRuleContext(DataBlockValueContext.class,i);
}
public InlineDataOneVarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inlineDataOneVar; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterInlineDataOneVar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitInlineDataOneVar(this);
}
}
public final InlineDataOneVarContext inlineDataOneVar() throws RecognitionException {
InlineDataOneVarContext _localctx = new InlineDataOneVarContext(_ctx, getState());
enterRule(_localctx, 124, RULE_inlineDataOneVar);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(735);
var();
setState(736);
match(OPEN_CURLY_BRACE);
setState(740);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==UNDEF || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
{
setState(737);
dataBlockValue();
}
}
setState(742);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(743);
match(CLOSE_CURLY_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InlineDataFullContext extends ParserRuleContext {
public TerminalNode OPEN_CURLY_BRACE() { return getToken(Sp4rql11Parser.OPEN_CURLY_BRACE, 0); }
public TerminalNode CLOSE_CURLY_BRACE() { return getToken(Sp4rql11Parser.CLOSE_CURLY_BRACE, 0); }
public List NIL() { return getTokens(Sp4rql11Parser.NIL); }
public TerminalNode NIL(int i) {
return getToken(Sp4rql11Parser.NIL, i);
}
public List OPEN_BRACE() { return getTokens(Sp4rql11Parser.OPEN_BRACE); }
public TerminalNode OPEN_BRACE(int i) {
return getToken(Sp4rql11Parser.OPEN_BRACE, i);
}
public List CLOSE_BRACE() { return getTokens(Sp4rql11Parser.CLOSE_BRACE); }
public TerminalNode CLOSE_BRACE(int i) {
return getToken(Sp4rql11Parser.CLOSE_BRACE, i);
}
public List var() {
return getRuleContexts(VarContext.class);
}
public VarContext var(int i) {
return getRuleContext(VarContext.class,i);
}
public List dataBlockValue() {
return getRuleContexts(DataBlockValueContext.class);
}
public DataBlockValueContext dataBlockValue(int i) {
return getRuleContext(DataBlockValueContext.class,i);
}
public InlineDataFullContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inlineDataFull; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterInlineDataFull(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitInlineDataFull(this);
}
}
public final InlineDataFullContext inlineDataFull() throws RecognitionException {
InlineDataFullContext _localctx = new InlineDataFullContext(_ctx, getState());
enterRule(_localctx, 126, RULE_inlineDataFull);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(754);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NIL:
{
setState(745);
match(NIL);
}
break;
case OPEN_BRACE:
{
setState(746);
match(OPEN_BRACE);
setState(750);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==VAR1 || _la==VAR2) {
{
{
setState(747);
var();
}
}
setState(752);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(753);
match(CLOSE_BRACE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(756);
match(OPEN_CURLY_BRACE);
setState(768);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OPEN_BRACE || _la==NIL) {
{
setState(766);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_BRACE:
{
setState(757);
match(OPEN_BRACE);
setState(761);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==UNDEF || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
{
setState(758);
dataBlockValue();
}
}
setState(763);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(764);
match(CLOSE_BRACE);
}
break;
case NIL:
{
setState(765);
match(NIL);
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(770);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(771);
match(CLOSE_CURLY_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataBlockValueContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public RDFLiteralContext rDFLiteral() {
return getRuleContext(RDFLiteralContext.class,0);
}
public NumericLiteralContext numericLiteral() {
return getRuleContext(NumericLiteralContext.class,0);
}
public BooleanLiteralContext booleanLiteral() {
return getRuleContext(BooleanLiteralContext.class,0);
}
public TerminalNode UNDEF() { return getToken(Sp4rql11Parser.UNDEF, 0); }
public DataBlockValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataBlockValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterDataBlockValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitDataBlockValue(this);
}
}
public final DataBlockValueContext dataBlockValue() throws RecognitionException {
DataBlockValueContext _localctx = new DataBlockValueContext(_ctx, getState());
enterRule(_localctx, 128, RULE_dataBlockValue);
try {
setState(778);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(773);
iri();
}
break;
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
enterOuterAlt(_localctx, 2);
{
setState(774);
rDFLiteral();
}
break;
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
enterOuterAlt(_localctx, 3);
{
setState(775);
numericLiteral();
}
break;
case TRUE:
case FALSE:
enterOuterAlt(_localctx, 4);
{
setState(776);
booleanLiteral();
}
break;
case UNDEF:
enterOuterAlt(_localctx, 5);
{
setState(777);
match(UNDEF);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MinusGraphPatternContext extends ParserRuleContext {
public TerminalNode MINUS() { return getToken(Sp4rql11Parser.MINUS, 0); }
public GroupGraphPatternContext groupGraphPattern() {
return getRuleContext(GroupGraphPatternContext.class,0);
}
public MinusGraphPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_minusGraphPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterMinusGraphPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitMinusGraphPattern(this);
}
}
public final MinusGraphPatternContext minusGraphPattern() throws RecognitionException {
MinusGraphPatternContext _localctx = new MinusGraphPatternContext(_ctx, getState());
enterRule(_localctx, 130, RULE_minusGraphPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(780);
match(MINUS);
setState(781);
groupGraphPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupOrUnionGraphPatternContext extends ParserRuleContext {
public List groupGraphPattern() {
return getRuleContexts(GroupGraphPatternContext.class);
}
public GroupGraphPatternContext groupGraphPattern(int i) {
return getRuleContext(GroupGraphPatternContext.class,i);
}
public List UNION() { return getTokens(Sp4rql11Parser.UNION); }
public TerminalNode UNION(int i) {
return getToken(Sp4rql11Parser.UNION, i);
}
public GroupOrUnionGraphPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupOrUnionGraphPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGroupOrUnionGraphPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGroupOrUnionGraphPattern(this);
}
}
public final GroupOrUnionGraphPatternContext groupOrUnionGraphPattern() throws RecognitionException {
GroupOrUnionGraphPatternContext _localctx = new GroupOrUnionGraphPatternContext(_ctx, getState());
enterRule(_localctx, 132, RULE_groupOrUnionGraphPattern);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(783);
groupGraphPattern();
setState(788);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==UNION) {
{
{
setState(784);
match(UNION);
setState(785);
groupGraphPattern();
}
}
setState(790);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FilterContext extends ParserRuleContext {
public TerminalNode FILTER() { return getToken(Sp4rql11Parser.FILTER, 0); }
public ConstraintContext constraint() {
return getRuleContext(ConstraintContext.class,0);
}
public FilterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_filter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterFilter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitFilter(this);
}
}
public final FilterContext filter() throws RecognitionException {
FilterContext _localctx = new FilterContext(_ctx, getState());
enterRule(_localctx, 134, RULE_filter);
try {
enterOuterAlt(_localctx, 1);
{
setState(791);
match(FILTER);
setState(792);
constraint();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstraintContext extends ParserRuleContext {
public BrackettedExpressionContext brackettedExpression() {
return getRuleContext(BrackettedExpressionContext.class,0);
}
public BuiltInCallContext builtInCall() {
return getRuleContext(BuiltInCallContext.class,0);
}
public FunctionCallContext functionCall() {
return getRuleContext(FunctionCallContext.class,0);
}
public ConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitConstraint(this);
}
}
public final ConstraintContext constraint() throws RecognitionException {
ConstraintContext _localctx = new ConstraintContext(_ctx, getState());
enterRule(_localctx, 136, RULE_constraint);
try {
setState(797);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(794);
brackettedExpression();
}
break;
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case SAMPLE:
enterOuterAlt(_localctx, 2);
{
setState(795);
builtInCall();
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 3);
{
setState(796);
functionCall();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionCallContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public ArgListContext argList() {
return getRuleContext(ArgListContext.class,0);
}
public FunctionCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitFunctionCall(this);
}
}
public final FunctionCallContext functionCall() throws RecognitionException {
FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState());
enterRule(_localctx, 138, RULE_functionCall);
try {
enterOuterAlt(_localctx, 1);
{
setState(799);
iri();
setState(800);
argList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgListContext extends ParserRuleContext {
public TerminalNode NIL() { return getToken(Sp4rql11Parser.NIL, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public TerminalNode DISTINCT() { return getToken(Sp4rql11Parser.DISTINCT, 0); }
public List COMMA() { return getTokens(Sp4rql11Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Sp4rql11Parser.COMMA, i);
}
public ArgListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterArgList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitArgList(this);
}
}
public final ArgListContext argList() throws RecognitionException {
ArgListContext _localctx = new ArgListContext(_ctx, getState());
enterRule(_localctx, 140, RULE_argList);
int _la;
try {
setState(817);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NIL:
enterOuterAlt(_localctx, 1);
{
setState(802);
match(NIL);
}
break;
case OPEN_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(803);
match(OPEN_BRACE);
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(804);
match(DISTINCT);
}
}
setState(807);
expression();
setState(812);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(808);
match(COMMA);
setState(809);
expression();
}
}
setState(814);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(815);
match(CLOSE_BRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionListContext extends ParserRuleContext {
public TerminalNode NIL() { return getToken(Sp4rql11Parser.NIL, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public List COMMA() { return getTokens(Sp4rql11Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Sp4rql11Parser.COMMA, i);
}
public ExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitExpressionList(this);
}
}
public final ExpressionListContext expressionList() throws RecognitionException {
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
enterRule(_localctx, 142, RULE_expressionList);
int _la;
try {
setState(831);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NIL:
enterOuterAlt(_localctx, 1);
{
setState(819);
match(NIL);
}
break;
case OPEN_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(820);
match(OPEN_BRACE);
setState(821);
expression();
setState(826);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(822);
match(COMMA);
setState(823);
expression();
}
}
setState(828);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(829);
match(CLOSE_BRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructTemplateContext extends ParserRuleContext {
public TerminalNode OPEN_CURLY_BRACE() { return getToken(Sp4rql11Parser.OPEN_CURLY_BRACE, 0); }
public TerminalNode CLOSE_CURLY_BRACE() { return getToken(Sp4rql11Parser.CLOSE_CURLY_BRACE, 0); }
public ConstructTriplesContext constructTriples() {
return getRuleContext(ConstructTriplesContext.class,0);
}
public ConstructTemplateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructTemplate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterConstructTemplate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitConstructTemplate(this);
}
}
public final ConstructTemplateContext constructTemplate() throws RecognitionException {
ConstructTemplateContext _localctx = new ConstructTemplateContext(_ctx, getState());
enterRule(_localctx, 144, RULE_constructTemplate);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(833);
match(OPEN_CURLY_BRACE);
setState(835);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(834);
constructTriples();
}
}
setState(837);
match(CLOSE_CURLY_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructTriplesContext extends ParserRuleContext {
public TriplesSameSubjectContext triplesSameSubject() {
return getRuleContext(TriplesSameSubjectContext.class,0);
}
public TerminalNode DOT() { return getToken(Sp4rql11Parser.DOT, 0); }
public ConstructTriplesContext constructTriples() {
return getRuleContext(ConstructTriplesContext.class,0);
}
public ConstructTriplesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructTriples; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterConstructTriples(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitConstructTriples(this);
}
}
public final ConstructTriplesContext constructTriples() throws RecognitionException {
ConstructTriplesContext _localctx = new ConstructTriplesContext(_ctx, getState());
enterRule(_localctx, 146, RULE_constructTriples);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(839);
triplesSameSubject();
setState(844);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(840);
match(DOT);
setState(842);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0)) {
{
setState(841);
constructTriples();
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TriplesSameSubjectContext extends ParserRuleContext {
public VarOrTermOrEmbTPContext varOrTermOrEmbTP() {
return getRuleContext(VarOrTermOrEmbTPContext.class,0);
}
public PropertyListNotEmptyContext propertyListNotEmpty() {
return getRuleContext(PropertyListNotEmptyContext.class,0);
}
public TriplesNodeContext triplesNode() {
return getRuleContext(TriplesNodeContext.class,0);
}
public PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.class,0);
}
public TriplesSameSubjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_triplesSameSubject; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterTriplesSameSubject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitTriplesSameSubject(this);
}
}
public final TriplesSameSubjectContext triplesSameSubject() throws RecognitionException {
TriplesSameSubjectContext _localctx = new TriplesSameSubjectContext(_ctx, getState());
enterRule(_localctx, 148, RULE_triplesSameSubject);
try {
setState(852);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case TRUE:
case FALSE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case NIL:
case ANON:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(846);
varOrTermOrEmbTP();
setState(847);
propertyListNotEmpty();
}
break;
case OPEN_BRACE:
case OPEN_SQUARE_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(849);
triplesNode();
setState(850);
propertyList();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyListContext extends ParserRuleContext {
public PropertyListNotEmptyContext propertyListNotEmpty() {
return getRuleContext(PropertyListNotEmptyContext.class,0);
}
public PropertyListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPropertyList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPropertyList(this);
}
}
public final PropertyListContext propertyList() throws RecognitionException {
PropertyListContext _localctx = new PropertyListContext(_ctx, getState());
enterRule(_localctx, 150, RULE_propertyList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(855);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==A || ((((_la - 142)) & ~0x3f) == 0 && ((1L << (_la - 142)) & ((1L << (IRIREF - 142)) | (1L << (PNAME_NS - 142)) | (1L << (PNAME_LN - 142)) | (1L << (VAR1 - 142)) | (1L << (VAR2 - 142)) | (1L << (UNQUOTED_IRIREF - 142)))) != 0)) {
{
setState(854);
propertyListNotEmpty();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyListNotEmptyContext extends ParserRuleContext {
public List verb() {
return getRuleContexts(VerbContext.class);
}
public VerbContext verb(int i) {
return getRuleContext(VerbContext.class,i);
}
public List objectList() {
return getRuleContexts(ObjectListContext.class);
}
public ObjectListContext objectList(int i) {
return getRuleContext(ObjectListContext.class,i);
}
public List SEMICOLON() { return getTokens(Sp4rql11Parser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(Sp4rql11Parser.SEMICOLON, i);
}
public PropertyListNotEmptyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyListNotEmpty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPropertyListNotEmpty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPropertyListNotEmpty(this);
}
}
public final PropertyListNotEmptyContext propertyListNotEmpty() throws RecognitionException {
PropertyListNotEmptyContext _localctx = new PropertyListNotEmptyContext(_ctx, getState());
enterRule(_localctx, 152, RULE_propertyListNotEmpty);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(857);
verb();
setState(858);
objectList();
setState(867);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SEMICOLON) {
{
{
setState(859);
match(SEMICOLON);
setState(863);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==A || ((((_la - 142)) & ~0x3f) == 0 && ((1L << (_la - 142)) & ((1L << (IRIREF - 142)) | (1L << (PNAME_NS - 142)) | (1L << (PNAME_LN - 142)) | (1L << (VAR1 - 142)) | (1L << (VAR2 - 142)) | (1L << (UNQUOTED_IRIREF - 142)))) != 0)) {
{
setState(860);
verb();
setState(861);
objectList();
}
}
}
}
setState(869);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VerbContext extends ParserRuleContext {
public VarOrIriContext varOrIri() {
return getRuleContext(VarOrIriContext.class,0);
}
public TerminalNode A() { return getToken(Sp4rql11Parser.A, 0); }
public VerbContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_verb; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterVerb(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitVerb(this);
}
}
public final VerbContext verb() throws RecognitionException {
VerbContext _localctx = new VerbContext(_ctx, getState());
enterRule(_localctx, 154, RULE_verb);
try {
setState(872);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case VAR1:
case VAR2:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(870);
varOrIri();
}
break;
case A:
enterOuterAlt(_localctx, 2);
{
setState(871);
match(A);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectListContext extends ParserRuleContext {
public List object() {
return getRuleContexts(ObjectContext.class);
}
public ObjectContext object(int i) {
return getRuleContext(ObjectContext.class,i);
}
public List COMMA() { return getTokens(Sp4rql11Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Sp4rql11Parser.COMMA, i);
}
public ObjectListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterObjectList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitObjectList(this);
}
}
public final ObjectListContext objectList() throws RecognitionException {
ObjectListContext _localctx = new ObjectListContext(_ctx, getState());
enterRule(_localctx, 156, RULE_objectList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(874);
object();
setState(879);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(875);
match(COMMA);
setState(876);
object();
}
}
setState(881);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectContext extends ParserRuleContext {
public GraphNodeContext graphNode() {
return getRuleContext(GraphNodeContext.class,0);
}
public EmbTPContext embTP() {
return getRuleContext(EmbTPContext.class,0);
}
public ObjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_object; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitObject(this);
}
}
public final ObjectContext object() throws RecognitionException {
ObjectContext _localctx = new ObjectContext(_ctx, getState());
enterRule(_localctx, 158, RULE_object);
try {
setState(884);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TRUE:
case FALSE:
case OPEN_BRACE:
case OPEN_SQUARE_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case NIL:
case ANON:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(882);
graphNode();
}
break;
case T__0:
enterOuterAlt(_localctx, 2);
{
setState(883);
embTP();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TriplesSameSubjectPathContext extends ParserRuleContext {
public SingleTermQuadContext singleTermQuad() {
return getRuleContext(SingleTermQuadContext.class,0);
}
public EmbTPContext embTP() {
return getRuleContext(EmbTPContext.class,0);
}
public PropertyListPathNotEmptyContext propertyListPathNotEmpty() {
return getRuleContext(PropertyListPathNotEmptyContext.class,0);
}
public List varOrTerm() {
return getRuleContexts(VarOrTermContext.class);
}
public VarOrTermContext varOrTerm(int i) {
return getRuleContext(VarOrTermContext.class,i);
}
public TriplesNodePathContext triplesNodePath() {
return getRuleContext(TriplesNodePathContext.class,0);
}
public PropertyListPathContext propertyListPath() {
return getRuleContext(PropertyListPathContext.class,0);
}
public TriplesSameSubjectPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_triplesSameSubjectPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterTriplesSameSubjectPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitTriplesSameSubjectPath(this);
}
}
public final TriplesSameSubjectPathContext triplesSameSubjectPath() throws RecognitionException {
TriplesSameSubjectPathContext _localctx = new TriplesSameSubjectPathContext(_ctx, getState());
enterRule(_localctx, 160, RULE_triplesSameSubjectPath);
try {
setState(899);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(886);
singleTermQuad();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(887);
embTP();
setState(888);
propertyListPathNotEmpty();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(891);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(890);
varOrTerm();
}
break;
}
setState(893);
varOrTerm();
setState(894);
propertyListPathNotEmpty();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(896);
triplesNodePath();
setState(897);
propertyListPath();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleTermQuadContext extends ParserRuleContext {
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public SingleTermQuadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleTermQuad; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterSingleTermQuad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitSingleTermQuad(this);
}
}
public final SingleTermQuadContext singleTermQuad() throws RecognitionException {
SingleTermQuadContext _localctx = new SingleTermQuadContext(_ctx, getState());
enterRule(_localctx, 162, RULE_singleTermQuad);
try {
enterOuterAlt(_localctx, 1);
{
setState(901);
var();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyListPathContext extends ParserRuleContext {
public PropertyListPathNotEmptyContext propertyListPathNotEmpty() {
return getRuleContext(PropertyListPathNotEmptyContext.class,0);
}
public PropertyListPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyListPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPropertyListPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPropertyListPath(this);
}
}
public final PropertyListPathContext propertyListPath() throws RecognitionException {
PropertyListPathContext _localctx = new PropertyListPathContext(_ctx, getState());
enterRule(_localctx, 164, RULE_propertyListPath);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(904);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==A || ((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & ((1L << (NOT_SIGN - 126)) | (1L << (OPEN_BRACE - 126)) | (1L << (CARET - 126)) | (1L << (IRIREF - 126)) | (1L << (PNAME_NS - 126)) | (1L << (PNAME_LN - 126)) | (1L << (VAR1 - 126)) | (1L << (VAR2 - 126)) | (1L << (NIL - 126)) | (1L << (UNQUOTED_IRIREF - 126)))) != 0)) {
{
setState(903);
propertyListPathNotEmpty();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyListPathNotEmptyContext extends ParserRuleContext {
public ObjectListPathContext objectListPath() {
return getRuleContext(ObjectListPathContext.class,0);
}
public List verbPath() {
return getRuleContexts(VerbPathContext.class);
}
public VerbPathContext verbPath(int i) {
return getRuleContext(VerbPathContext.class,i);
}
public List verbSimple() {
return getRuleContexts(VerbSimpleContext.class);
}
public VerbSimpleContext verbSimple(int i) {
return getRuleContext(VerbSimpleContext.class,i);
}
public List SEMICOLON() { return getTokens(Sp4rql11Parser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(Sp4rql11Parser.SEMICOLON, i);
}
public List objectList() {
return getRuleContexts(ObjectListContext.class);
}
public ObjectListContext objectList(int i) {
return getRuleContext(ObjectListContext.class,i);
}
public PropertyListPathNotEmptyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyListPathNotEmpty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPropertyListPathNotEmpty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPropertyListPathNotEmpty(this);
}
}
public final PropertyListPathNotEmptyContext propertyListPathNotEmpty() throws RecognitionException {
PropertyListPathNotEmptyContext _localctx = new PropertyListPathNotEmptyContext(_ctx, getState());
enterRule(_localctx, 166, RULE_propertyListPathNotEmpty);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(908);
_errHandler.sync(this);
switch (_input.LA(1)) {
case A:
case NOT_SIGN:
case OPEN_BRACE:
case CARET:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
{
setState(906);
verbPath();
}
break;
case VAR1:
case VAR2:
case NIL:
{
setState(907);
verbSimple();
}
break;
default:
throw new NoViableAltException(this);
}
setState(910);
objectListPath();
setState(922);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SEMICOLON) {
{
{
setState(911);
match(SEMICOLON);
setState(918);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==A || ((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & ((1L << (NOT_SIGN - 126)) | (1L << (OPEN_BRACE - 126)) | (1L << (CARET - 126)) | (1L << (IRIREF - 126)) | (1L << (PNAME_NS - 126)) | (1L << (PNAME_LN - 126)) | (1L << (VAR1 - 126)) | (1L << (VAR2 - 126)) | (1L << (NIL - 126)) | (1L << (UNQUOTED_IRIREF - 126)))) != 0)) {
{
setState(914);
_errHandler.sync(this);
switch (_input.LA(1)) {
case A:
case NOT_SIGN:
case OPEN_BRACE:
case CARET:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
{
setState(912);
verbPath();
}
break;
case VAR1:
case VAR2:
case NIL:
{
setState(913);
verbSimple();
}
break;
default:
throw new NoViableAltException(this);
}
setState(916);
objectList();
}
}
}
}
setState(924);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VerbPathContext extends ParserRuleContext {
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public VerbPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_verbPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterVerbPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitVerbPath(this);
}
}
public final VerbPathContext verbPath() throws RecognitionException {
VerbPathContext _localctx = new VerbPathContext(_ctx, getState());
enterRule(_localctx, 168, RULE_verbPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(925);
path();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VerbSimpleContext extends ParserRuleContext {
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public TerminalNode NIL() { return getToken(Sp4rql11Parser.NIL, 0); }
public VerbSimpleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_verbSimple; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterVerbSimple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitVerbSimple(this);
}
}
public final VerbSimpleContext verbSimple() throws RecognitionException {
VerbSimpleContext _localctx = new VerbSimpleContext(_ctx, getState());
enterRule(_localctx, 170, RULE_verbSimple);
try {
setState(929);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR1:
case VAR2:
enterOuterAlt(_localctx, 1);
{
setState(927);
var();
}
break;
case NIL:
enterOuterAlt(_localctx, 2);
{
setState(928);
match(NIL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectListPathContext extends ParserRuleContext {
public List objectPath() {
return getRuleContexts(ObjectPathContext.class);
}
public ObjectPathContext objectPath(int i) {
return getRuleContext(ObjectPathContext.class,i);
}
public List COMMA() { return getTokens(Sp4rql11Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Sp4rql11Parser.COMMA, i);
}
public ObjectListPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectListPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterObjectListPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitObjectListPath(this);
}
}
public final ObjectListPathContext objectListPath() throws RecognitionException {
ObjectListPathContext _localctx = new ObjectListPathContext(_ctx, getState());
enterRule(_localctx, 172, RULE_objectListPath);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(931);
objectPath();
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(932);
match(COMMA);
setState(933);
objectPath();
}
}
setState(938);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectPathContext extends ParserRuleContext {
public GraphNodePathContext graphNodePath() {
return getRuleContext(GraphNodePathContext.class,0);
}
public ObjectPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterObjectPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitObjectPath(this);
}
}
public final ObjectPathContext objectPath() throws RecognitionException {
ObjectPathContext _localctx = new ObjectPathContext(_ctx, getState());
enterRule(_localctx, 174, RULE_objectPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(939);
graphNodePath();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathContext extends ParserRuleContext {
public PathAlternativeContext pathAlternative() {
return getRuleContext(PathAlternativeContext.class,0);
}
public PathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_path; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPath(this);
}
}
public final PathContext path() throws RecognitionException {
PathContext _localctx = new PathContext(_ctx, getState());
enterRule(_localctx, 176, RULE_path);
try {
enterOuterAlt(_localctx, 1);
{
setState(941);
pathAlternative();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathAlternativeContext extends ParserRuleContext {
public List pathSequence() {
return getRuleContexts(PathSequenceContext.class);
}
public PathSequenceContext pathSequence(int i) {
return getRuleContext(PathSequenceContext.class,i);
}
public List BAR() { return getTokens(Sp4rql11Parser.BAR); }
public TerminalNode BAR(int i) {
return getToken(Sp4rql11Parser.BAR, i);
}
public PathAlternativeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathAlternative; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPathAlternative(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPathAlternative(this);
}
}
public final PathAlternativeContext pathAlternative() throws RecognitionException {
PathAlternativeContext _localctx = new PathAlternativeContext(_ctx, getState());
enterRule(_localctx, 178, RULE_pathAlternative);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(943);
pathSequence();
setState(948);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(944);
match(BAR);
setState(945);
pathSequence();
}
}
setState(950);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathSequenceContext extends ParserRuleContext {
public List pathEltOrInverse() {
return getRuleContexts(PathEltOrInverseContext.class);
}
public PathEltOrInverseContext pathEltOrInverse(int i) {
return getRuleContext(PathEltOrInverseContext.class,i);
}
public List DIVIDE() { return getTokens(Sp4rql11Parser.DIVIDE); }
public TerminalNode DIVIDE(int i) {
return getToken(Sp4rql11Parser.DIVIDE, i);
}
public PathSequenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathSequence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPathSequence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPathSequence(this);
}
}
public final PathSequenceContext pathSequence() throws RecognitionException {
PathSequenceContext _localctx = new PathSequenceContext(_ctx, getState());
enterRule(_localctx, 180, RULE_pathSequence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(951);
pathEltOrInverse();
setState(956);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DIVIDE) {
{
{
setState(952);
match(DIVIDE);
setState(953);
pathEltOrInverse();
}
}
setState(958);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathEltContext extends ParserRuleContext {
public PathPrimaryContext pathPrimary() {
return getRuleContext(PathPrimaryContext.class,0);
}
public PathModContext pathMod() {
return getRuleContext(PathModContext.class,0);
}
public PathEltContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathElt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPathElt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPathElt(this);
}
}
public final PathEltContext pathElt() throws RecognitionException {
PathEltContext _localctx = new PathEltContext(_ctx, getState());
enterRule(_localctx, 182, RULE_pathElt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(959);
pathPrimary();
setState(961);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & ((1L << (PLUS - 122)) | (1L << (ASTERISK - 122)) | (1L << (QUESTION - 122)))) != 0)) {
{
setState(960);
pathMod();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathEltOrInverseContext extends ParserRuleContext {
public PathEltContext pathElt() {
return getRuleContext(PathEltContext.class,0);
}
public TerminalNode CARET() { return getToken(Sp4rql11Parser.CARET, 0); }
public PathEltOrInverseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathEltOrInverse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPathEltOrInverse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPathEltOrInverse(this);
}
}
public final PathEltOrInverseContext pathEltOrInverse() throws RecognitionException {
PathEltOrInverseContext _localctx = new PathEltOrInverseContext(_ctx, getState());
enterRule(_localctx, 184, RULE_pathEltOrInverse);
try {
setState(966);
_errHandler.sync(this);
switch (_input.LA(1)) {
case A:
case NOT_SIGN:
case OPEN_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(963);
pathElt();
}
break;
case CARET:
enterOuterAlt(_localctx, 2);
{
setState(964);
match(CARET);
setState(965);
pathElt();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathModContext extends ParserRuleContext {
public TerminalNode QUESTION() { return getToken(Sp4rql11Parser.QUESTION, 0); }
public TerminalNode ASTERISK() { return getToken(Sp4rql11Parser.ASTERISK, 0); }
public TerminalNode PLUS() { return getToken(Sp4rql11Parser.PLUS, 0); }
public PathModContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathMod; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPathMod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPathMod(this);
}
}
public final PathModContext pathMod() throws RecognitionException {
PathModContext _localctx = new PathModContext(_ctx, getState());
enterRule(_localctx, 186, RULE_pathMod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(968);
_la = _input.LA(1);
if ( !(((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & ((1L << (PLUS - 122)) | (1L << (ASTERISK - 122)) | (1L << (QUESTION - 122)))) != 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 class PathPrimaryContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public TerminalNode A() { return getToken(Sp4rql11Parser.A, 0); }
public TerminalNode NOT_SIGN() { return getToken(Sp4rql11Parser.NOT_SIGN, 0); }
public PathNegatedPropertySetContext pathNegatedPropertySet() {
return getRuleContext(PathNegatedPropertySetContext.class,0);
}
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public PathPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathPrimary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPathPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPathPrimary(this);
}
}
public final PathPrimaryContext pathPrimary() throws RecognitionException {
PathPrimaryContext _localctx = new PathPrimaryContext(_ctx, getState());
enterRule(_localctx, 188, RULE_pathPrimary);
try {
setState(978);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(970);
iri();
}
break;
case A:
enterOuterAlt(_localctx, 2);
{
setState(971);
match(A);
}
break;
case NOT_SIGN:
enterOuterAlt(_localctx, 3);
{
setState(972);
match(NOT_SIGN);
setState(973);
pathNegatedPropertySet();
}
break;
case OPEN_BRACE:
enterOuterAlt(_localctx, 4);
{
setState(974);
match(OPEN_BRACE);
setState(975);
path();
setState(976);
match(CLOSE_BRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathNegatedPropertySetContext extends ParserRuleContext {
public List pathOneInPropertySet() {
return getRuleContexts(PathOneInPropertySetContext.class);
}
public PathOneInPropertySetContext pathOneInPropertySet(int i) {
return getRuleContext(PathOneInPropertySetContext.class,i);
}
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public List BAR() { return getTokens(Sp4rql11Parser.BAR); }
public TerminalNode BAR(int i) {
return getToken(Sp4rql11Parser.BAR, i);
}
public PathNegatedPropertySetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathNegatedPropertySet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPathNegatedPropertySet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPathNegatedPropertySet(this);
}
}
public final PathNegatedPropertySetContext pathNegatedPropertySet() throws RecognitionException {
PathNegatedPropertySetContext _localctx = new PathNegatedPropertySetContext(_ctx, getState());
enterRule(_localctx, 190, RULE_pathNegatedPropertySet);
int _la;
try {
setState(993);
_errHandler.sync(this);
switch (_input.LA(1)) {
case A:
case CARET:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(980);
pathOneInPropertySet();
}
break;
case OPEN_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(981);
match(OPEN_BRACE);
setState(990);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==A || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & ((1L << (CARET - 139)) | (1L << (IRIREF - 139)) | (1L << (PNAME_NS - 139)) | (1L << (PNAME_LN - 139)) | (1L << (UNQUOTED_IRIREF - 139)))) != 0)) {
{
setState(982);
pathOneInPropertySet();
setState(987);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(983);
match(BAR);
setState(984);
pathOneInPropertySet();
}
}
setState(989);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(992);
match(CLOSE_BRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathOneInPropertySetContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public TerminalNode A() { return getToken(Sp4rql11Parser.A, 0); }
public TerminalNode CARET() { return getToken(Sp4rql11Parser.CARET, 0); }
public PathOneInPropertySetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathOneInPropertySet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPathOneInPropertySet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPathOneInPropertySet(this);
}
}
public final PathOneInPropertySetContext pathOneInPropertySet() throws RecognitionException {
PathOneInPropertySetContext _localctx = new PathOneInPropertySetContext(_ctx, getState());
enterRule(_localctx, 192, RULE_pathOneInPropertySet);
try {
setState(1002);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(995);
iri();
}
break;
case A:
enterOuterAlt(_localctx, 2);
{
setState(996);
match(A);
}
break;
case CARET:
enterOuterAlt(_localctx, 3);
{
setState(997);
match(CARET);
setState(1000);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
{
setState(998);
iri();
}
break;
case A:
{
setState(999);
match(A);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntegerContext extends ParserRuleContext {
public TerminalNode INTEGER() { return getToken(Sp4rql11Parser.INTEGER, 0); }
public IntegerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_integer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterInteger(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitInteger(this);
}
}
public final IntegerContext integer() throws RecognitionException {
IntegerContext _localctx = new IntegerContext(_ctx, getState());
enterRule(_localctx, 194, RULE_integer);
try {
enterOuterAlt(_localctx, 1);
{
setState(1004);
match(INTEGER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TriplesNodeContext extends ParserRuleContext {
public CollectionContext collection() {
return getRuleContext(CollectionContext.class,0);
}
public BlankNodePropertyListContext blankNodePropertyList() {
return getRuleContext(BlankNodePropertyListContext.class,0);
}
public TriplesNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_triplesNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterTriplesNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitTriplesNode(this);
}
}
public final TriplesNodeContext triplesNode() throws RecognitionException {
TriplesNodeContext _localctx = new TriplesNodeContext(_ctx, getState());
enterRule(_localctx, 196, RULE_triplesNode);
try {
setState(1008);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(1006);
collection();
}
break;
case OPEN_SQUARE_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(1007);
blankNodePropertyList();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlankNodePropertyListContext extends ParserRuleContext {
public TerminalNode OPEN_SQUARE_BRACE() { return getToken(Sp4rql11Parser.OPEN_SQUARE_BRACE, 0); }
public PropertyListNotEmptyContext propertyListNotEmpty() {
return getRuleContext(PropertyListNotEmptyContext.class,0);
}
public TerminalNode CLOSE_SQUARE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_SQUARE_BRACE, 0); }
public BlankNodePropertyListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blankNodePropertyList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterBlankNodePropertyList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitBlankNodePropertyList(this);
}
}
public final BlankNodePropertyListContext blankNodePropertyList() throws RecognitionException {
BlankNodePropertyListContext _localctx = new BlankNodePropertyListContext(_ctx, getState());
enterRule(_localctx, 198, RULE_blankNodePropertyList);
try {
enterOuterAlt(_localctx, 1);
{
setState(1010);
match(OPEN_SQUARE_BRACE);
setState(1011);
propertyListNotEmpty();
setState(1012);
match(CLOSE_SQUARE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TriplesNodePathContext extends ParserRuleContext {
public CollectionPathContext collectionPath() {
return getRuleContext(CollectionPathContext.class,0);
}
public BlankNodePropertyListPathContext blankNodePropertyListPath() {
return getRuleContext(BlankNodePropertyListPathContext.class,0);
}
public TriplesNodePathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_triplesNodePath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterTriplesNodePath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitTriplesNodePath(this);
}
}
public final TriplesNodePathContext triplesNodePath() throws RecognitionException {
TriplesNodePathContext _localctx = new TriplesNodePathContext(_ctx, getState());
enterRule(_localctx, 200, RULE_triplesNodePath);
try {
setState(1016);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(1014);
collectionPath();
}
break;
case OPEN_SQUARE_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(1015);
blankNodePropertyListPath();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlankNodePropertyListPathContext extends ParserRuleContext {
public TerminalNode OPEN_SQUARE_BRACE() { return getToken(Sp4rql11Parser.OPEN_SQUARE_BRACE, 0); }
public PropertyListPathNotEmptyContext propertyListPathNotEmpty() {
return getRuleContext(PropertyListPathNotEmptyContext.class,0);
}
public TerminalNode CLOSE_SQUARE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_SQUARE_BRACE, 0); }
public BlankNodePropertyListPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blankNodePropertyListPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterBlankNodePropertyListPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitBlankNodePropertyListPath(this);
}
}
public final BlankNodePropertyListPathContext blankNodePropertyListPath() throws RecognitionException {
BlankNodePropertyListPathContext _localctx = new BlankNodePropertyListPathContext(_ctx, getState());
enterRule(_localctx, 202, RULE_blankNodePropertyListPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(1018);
match(OPEN_SQUARE_BRACE);
setState(1019);
propertyListPathNotEmpty();
setState(1020);
match(CLOSE_SQUARE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CollectionContext extends ParserRuleContext {
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public List graphNode() {
return getRuleContexts(GraphNodeContext.class);
}
public GraphNodeContext graphNode(int i) {
return getRuleContext(GraphNodeContext.class,i);
}
public CollectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_collection; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterCollection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitCollection(this);
}
}
public final CollectionContext collection() throws RecognitionException {
CollectionContext _localctx = new CollectionContext(_ctx, getState());
enterRule(_localctx, 204, RULE_collection);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1022);
match(OPEN_BRACE);
setState(1024);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1023);
graphNode();
}
}
setState(1026);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0) );
setState(1028);
match(CLOSE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CollectionPathContext extends ParserRuleContext {
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public List graphNodePath() {
return getRuleContexts(GraphNodePathContext.class);
}
public GraphNodePathContext graphNodePath(int i) {
return getRuleContext(GraphNodePathContext.class,i);
}
public CollectionPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_collectionPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterCollectionPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitCollectionPath(this);
}
}
public final CollectionPathContext collectionPath() throws RecognitionException {
CollectionPathContext _localctx = new CollectionPathContext(_ctx, getState());
enterRule(_localctx, 206, RULE_collectionPath);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1030);
match(OPEN_BRACE);
setState(1032);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1031);
graphNodePath();
}
}
setState(1034);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__0 || ((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (TRUE - 111)) | (1L << (FALSE - 111)) | (1L << (OPEN_BRACE - 111)) | (1L << (OPEN_SQUARE_BRACE - 111)) | (1L << (IRIREF - 111)) | (1L << (PNAME_NS - 111)) | (1L << (PNAME_LN - 111)) | (1L << (BLANK_NODE_LABEL - 111)) | (1L << (VAR1 - 111)) | (1L << (VAR2 - 111)) | (1L << (INTEGER - 111)) | (1L << (DECIMAL - 111)) | (1L << (DOUBLE - 111)) | (1L << (INTEGER_POSITIVE - 111)) | (1L << (DECIMAL_POSITIVE - 111)) | (1L << (DOUBLE_POSITIVE - 111)) | (1L << (INTEGER_NEGATIVE - 111)) | (1L << (DECIMAL_NEGATIVE - 111)) | (1L << (DOUBLE_NEGATIVE - 111)) | (1L << (STRING_LITERAL1 - 111)) | (1L << (STRING_LITERAL2 - 111)) | (1L << (STRING_LITERAL_LONG1 - 111)) | (1L << (STRING_LITERAL_LONG2 - 111)) | (1L << (NIL - 111)) | (1L << (ANON - 111)) | (1L << (UNQUOTED_IRIREF - 111)))) != 0) );
setState(1036);
match(CLOSE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GraphNodeContext extends ParserRuleContext {
public VarOrTermContext varOrTerm() {
return getRuleContext(VarOrTermContext.class,0);
}
public TriplesNodeContext triplesNode() {
return getRuleContext(TriplesNodeContext.class,0);
}
public GraphNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGraphNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGraphNode(this);
}
}
public final GraphNodeContext graphNode() throws RecognitionException {
GraphNodeContext _localctx = new GraphNodeContext(_ctx, getState());
enterRule(_localctx, 208, RULE_graphNode);
try {
setState(1040);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TRUE:
case FALSE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case NIL:
case ANON:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(1038);
varOrTerm();
}
break;
case OPEN_BRACE:
case OPEN_SQUARE_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(1039);
triplesNode();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GraphNodePathContext extends ParserRuleContext {
public VarOrTermOrEmbTPContext varOrTermOrEmbTP() {
return getRuleContext(VarOrTermOrEmbTPContext.class,0);
}
public TriplesNodePathContext triplesNodePath() {
return getRuleContext(TriplesNodePathContext.class,0);
}
public GraphNodePathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphNodePath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGraphNodePath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGraphNodePath(this);
}
}
public final GraphNodePathContext graphNodePath() throws RecognitionException {
GraphNodePathContext _localctx = new GraphNodePathContext(_ctx, getState());
enterRule(_localctx, 210, RULE_graphNodePath);
try {
setState(1044);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case TRUE:
case FALSE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case NIL:
case ANON:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(1042);
varOrTermOrEmbTP();
}
break;
case OPEN_BRACE:
case OPEN_SQUARE_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(1043);
triplesNodePath();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarOrTermContext extends ParserRuleContext {
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public GraphTermContext graphTerm() {
return getRuleContext(GraphTermContext.class,0);
}
public VarOrTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varOrTerm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterVarOrTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitVarOrTerm(this);
}
}
public final VarOrTermContext varOrTerm() throws RecognitionException {
VarOrTermContext _localctx = new VarOrTermContext(_ctx, getState());
enterRule(_localctx, 212, RULE_varOrTerm);
try {
setState(1048);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR1:
case VAR2:
enterOuterAlt(_localctx, 1);
{
setState(1046);
var();
}
break;
case TRUE:
case FALSE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case NIL:
case ANON:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 2);
{
setState(1047);
graphTerm();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarOrTermOrEmbTPContext extends ParserRuleContext {
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public GraphTermContext graphTerm() {
return getRuleContext(GraphTermContext.class,0);
}
public EmbTPContext embTP() {
return getRuleContext(EmbTPContext.class,0);
}
public VarOrTermOrEmbTPContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varOrTermOrEmbTP; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterVarOrTermOrEmbTP(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitVarOrTermOrEmbTP(this);
}
}
public final VarOrTermOrEmbTPContext varOrTermOrEmbTP() throws RecognitionException {
VarOrTermOrEmbTPContext _localctx = new VarOrTermOrEmbTPContext(_ctx, getState());
enterRule(_localctx, 214, RULE_varOrTermOrEmbTP);
try {
setState(1053);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR1:
case VAR2:
enterOuterAlt(_localctx, 1);
{
setState(1050);
var();
}
break;
case TRUE:
case FALSE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case NIL:
case ANON:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 2);
{
setState(1051);
graphTerm();
}
break;
case T__0:
enterOuterAlt(_localctx, 3);
{
setState(1052);
embTP();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarOrIriContext extends ParserRuleContext {
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public VarOrIriContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varOrIri; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterVarOrIri(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitVarOrIri(this);
}
}
public final VarOrIriContext varOrIri() throws RecognitionException {
VarOrIriContext _localctx = new VarOrIriContext(_ctx, getState());
enterRule(_localctx, 216, RULE_varOrIri);
try {
setState(1057);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR1:
case VAR2:
enterOuterAlt(_localctx, 1);
{
setState(1055);
var();
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 2);
{
setState(1056);
iri();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarContext extends ParserRuleContext {
public TerminalNode VAR1() { return getToken(Sp4rql11Parser.VAR1, 0); }
public TerminalNode VAR2() { return getToken(Sp4rql11Parser.VAR2, 0); }
public VarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterVar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitVar(this);
}
}
public final VarContext var() throws RecognitionException {
VarContext _localctx = new VarContext(_ctx, getState());
enterRule(_localctx, 218, RULE_var);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1059);
_la = _input.LA(1);
if ( !(_la==VAR1 || _la==VAR2) ) {
_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 class EmbTPContext extends ParserRuleContext {
public List varOrTermOrEmbTP() {
return getRuleContexts(VarOrTermOrEmbTPContext.class);
}
public VarOrTermOrEmbTPContext varOrTermOrEmbTP(int i) {
return getRuleContext(VarOrTermOrEmbTPContext.class,i);
}
public VerbContext verb() {
return getRuleContext(VerbContext.class,0);
}
public EmbTPContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_embTP; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterEmbTP(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitEmbTP(this);
}
}
public final EmbTPContext embTP() throws RecognitionException {
EmbTPContext _localctx = new EmbTPContext(_ctx, getState());
enterRule(_localctx, 220, RULE_embTP);
try {
enterOuterAlt(_localctx, 1);
{
setState(1061);
match(T__0);
setState(1062);
varOrTermOrEmbTP();
setState(1063);
verb();
setState(1064);
varOrTermOrEmbTP();
setState(1065);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GraphTermContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public RDFLiteralContext rDFLiteral() {
return getRuleContext(RDFLiteralContext.class,0);
}
public NumericLiteralContext numericLiteral() {
return getRuleContext(NumericLiteralContext.class,0);
}
public BooleanLiteralContext booleanLiteral() {
return getRuleContext(BooleanLiteralContext.class,0);
}
public BlankNodeContext blankNode() {
return getRuleContext(BlankNodeContext.class,0);
}
public TerminalNode NIL() { return getToken(Sp4rql11Parser.NIL, 0); }
public GraphTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphTerm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterGraphTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitGraphTerm(this);
}
}
public final GraphTermContext graphTerm() throws RecognitionException {
GraphTermContext _localctx = new GraphTermContext(_ctx, getState());
enterRule(_localctx, 222, RULE_graphTerm);
try {
setState(1073);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(1067);
iri();
}
break;
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
enterOuterAlt(_localctx, 2);
{
setState(1068);
rDFLiteral();
}
break;
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
enterOuterAlt(_localctx, 3);
{
setState(1069);
numericLiteral();
}
break;
case TRUE:
case FALSE:
enterOuterAlt(_localctx, 4);
{
setState(1070);
booleanLiteral();
}
break;
case BLANK_NODE_LABEL:
case ANON:
enterOuterAlt(_localctx, 5);
{
setState(1071);
blankNode();
}
break;
case NIL:
enterOuterAlt(_localctx, 6);
{
setState(1072);
match(NIL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public ConditionalOrExpressionContext conditionalOrExpression() {
return getRuleContext(ConditionalOrExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 224, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1075);
conditionalOrExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionOrEmbTPContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public EmbTPContext embTP() {
return getRuleContext(EmbTPContext.class,0);
}
public ExpressionOrEmbTPContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionOrEmbTP; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterExpressionOrEmbTP(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitExpressionOrEmbTP(this);
}
}
public final ExpressionOrEmbTPContext expressionOrEmbTP() throws RecognitionException {
ExpressionOrEmbTPContext _localctx = new ExpressionOrEmbTPContext(_ctx, getState());
enterRule(_localctx, 226, RULE_expressionOrEmbTP);
try {
setState(1079);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case TRUE:
case FALSE:
case SAMPLE:
case PLUS:
case DASH:
case NOT_SIGN:
case OPEN_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(1077);
expression();
}
break;
case T__0:
enterOuterAlt(_localctx, 2);
{
setState(1078);
embTP();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalOrExpressionContext extends ParserRuleContext {
public List conditionalAndExpression() {
return getRuleContexts(ConditionalAndExpressionContext.class);
}
public ConditionalAndExpressionContext conditionalAndExpression(int i) {
return getRuleContext(ConditionalAndExpressionContext.class,i);
}
public List OR() { return getTokens(Sp4rql11Parser.OR); }
public TerminalNode OR(int i) {
return getToken(Sp4rql11Parser.OR, i);
}
public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterConditionalOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitConditionalOrExpression(this);
}
}
public final ConditionalOrExpressionContext conditionalOrExpression() throws RecognitionException {
ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(_ctx, getState());
enterRule(_localctx, 228, RULE_conditionalOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1081);
conditionalAndExpression();
setState(1086);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR) {
{
{
setState(1082);
match(OR);
setState(1083);
conditionalAndExpression();
}
}
setState(1088);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalAndExpressionContext extends ParserRuleContext {
public List valueLogical() {
return getRuleContexts(ValueLogicalContext.class);
}
public ValueLogicalContext valueLogical(int i) {
return getRuleContext(ValueLogicalContext.class,i);
}
public List AND() { return getTokens(Sp4rql11Parser.AND); }
public TerminalNode AND(int i) {
return getToken(Sp4rql11Parser.AND, i);
}
public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalAndExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterConditionalAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitConditionalAndExpression(this);
}
}
public final ConditionalAndExpressionContext conditionalAndExpression() throws RecognitionException {
ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(_ctx, getState());
enterRule(_localctx, 230, RULE_conditionalAndExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1089);
valueLogical();
setState(1094);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND) {
{
{
setState(1090);
match(AND);
setState(1091);
valueLogical();
}
}
setState(1096);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueLogicalContext extends ParserRuleContext {
public RelationalExpressionContext relationalExpression() {
return getRuleContext(RelationalExpressionContext.class,0);
}
public ValueLogicalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueLogical; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterValueLogical(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitValueLogical(this);
}
}
public final ValueLogicalContext valueLogical() throws RecognitionException {
ValueLogicalContext _localctx = new ValueLogicalContext(_ctx, getState());
enterRule(_localctx, 232, RULE_valueLogical);
try {
enterOuterAlt(_localctx, 1);
{
setState(1097);
relationalExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationalExpressionContext extends ParserRuleContext {
public List numericExpression() {
return getRuleContexts(NumericExpressionContext.class);
}
public NumericExpressionContext numericExpression(int i) {
return getRuleContext(NumericExpressionContext.class,i);
}
public TerminalNode EQUAL() { return getToken(Sp4rql11Parser.EQUAL, 0); }
public TerminalNode NOT_EQUAL() { return getToken(Sp4rql11Parser.NOT_EQUAL, 0); }
public TerminalNode LESS() { return getToken(Sp4rql11Parser.LESS, 0); }
public TerminalNode GREATER() { return getToken(Sp4rql11Parser.GREATER, 0); }
public TerminalNode LESS_EQUAL() { return getToken(Sp4rql11Parser.LESS_EQUAL, 0); }
public TerminalNode GREATER_EQUAL() { return getToken(Sp4rql11Parser.GREATER_EQUAL, 0); }
public TerminalNode IN() { return getToken(Sp4rql11Parser.IN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public TerminalNode NOT() { return getToken(Sp4rql11Parser.NOT, 0); }
public RelationalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterRelationalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitRelationalExpression(this);
}
}
public final RelationalExpressionContext relationalExpression() throws RecognitionException {
RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, getState());
enterRule(_localctx, 234, RULE_relationalExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1099);
numericExpression();
setState(1117);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EQUAL:
{
setState(1100);
match(EQUAL);
setState(1101);
numericExpression();
}
break;
case NOT_EQUAL:
{
setState(1102);
match(NOT_EQUAL);
setState(1103);
numericExpression();
}
break;
case LESS:
{
setState(1104);
match(LESS);
setState(1105);
numericExpression();
}
break;
case GREATER:
{
setState(1106);
match(GREATER);
setState(1107);
numericExpression();
}
break;
case LESS_EQUAL:
{
setState(1108);
match(LESS_EQUAL);
setState(1109);
numericExpression();
}
break;
case GREATER_EQUAL:
{
setState(1110);
match(GREATER_EQUAL);
setState(1111);
numericExpression();
}
break;
case IN:
{
setState(1112);
match(IN);
setState(1113);
expressionList();
}
break;
case NOT:
{
setState(1114);
match(NOT);
setState(1115);
match(IN);
setState(1116);
expressionList();
}
break;
case AS:
case AND:
case OR:
case SEMICOLON:
case COMMA:
case CLOSE_BRACE:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumericExpressionContext extends ParserRuleContext {
public AdditiveExpressionContext additiveExpression() {
return getRuleContext(AdditiveExpressionContext.class,0);
}
public NumericExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterNumericExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitNumericExpression(this);
}
}
public final NumericExpressionContext numericExpression() throws RecognitionException {
NumericExpressionContext _localctx = new NumericExpressionContext(_ctx, getState());
enterRule(_localctx, 236, RULE_numericExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1119);
additiveExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AdditiveExpressionContext extends ParserRuleContext {
public List multiplicativeExpression() {
return getRuleContexts(MultiplicativeExpressionContext.class);
}
public MultiplicativeExpressionContext multiplicativeExpression(int i) {
return getRuleContext(MultiplicativeExpressionContext.class,i);
}
public List PLUS() { return getTokens(Sp4rql11Parser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(Sp4rql11Parser.PLUS, i);
}
public List DASH() { return getTokens(Sp4rql11Parser.DASH); }
public TerminalNode DASH(int i) {
return getToken(Sp4rql11Parser.DASH, i);
}
public List numericLiteralPositive() {
return getRuleContexts(NumericLiteralPositiveContext.class);
}
public NumericLiteralPositiveContext numericLiteralPositive(int i) {
return getRuleContext(NumericLiteralPositiveContext.class,i);
}
public List numericLiteralNegative() {
return getRuleContexts(NumericLiteralNegativeContext.class);
}
public NumericLiteralNegativeContext numericLiteralNegative(int i) {
return getRuleContext(NumericLiteralNegativeContext.class,i);
}
public List ASTERISK() { return getTokens(Sp4rql11Parser.ASTERISK); }
public TerminalNode ASTERISK(int i) {
return getToken(Sp4rql11Parser.ASTERISK, i);
}
public List unaryExpression() {
return getRuleContexts(UnaryExpressionContext.class);
}
public UnaryExpressionContext unaryExpression(int i) {
return getRuleContext(UnaryExpressionContext.class,i);
}
public List DIVIDE() { return getTokens(Sp4rql11Parser.DIVIDE); }
public TerminalNode DIVIDE(int i) {
return getToken(Sp4rql11Parser.DIVIDE, i);
}
public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitAdditiveExpression(this);
}
}
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState());
enterRule(_localctx, 238, RULE_additiveExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1121);
multiplicativeExpression();
setState(1141);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & ((1L << (PLUS - 122)) | (1L << (DASH - 122)) | (1L << (INTEGER_POSITIVE - 122)) | (1L << (DECIMAL_POSITIVE - 122)) | (1L << (DOUBLE_POSITIVE - 122)) | (1L << (INTEGER_NEGATIVE - 122)) | (1L << (DECIMAL_NEGATIVE - 122)) | (1L << (DOUBLE_NEGATIVE - 122)))) != 0)) {
{
setState(1139);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
{
setState(1122);
match(PLUS);
setState(1123);
multiplicativeExpression();
}
break;
case DASH:
{
setState(1124);
match(DASH);
setState(1125);
multiplicativeExpression();
}
break;
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
{
setState(1128);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
{
setState(1126);
numericLiteralPositive();
}
break;
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
{
setState(1127);
numericLiteralNegative();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1136);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ASTERISK || _la==DIVIDE) {
{
setState(1134);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASTERISK:
{
{
setState(1130);
match(ASTERISK);
setState(1131);
unaryExpression();
}
}
break;
case DIVIDE:
{
{
setState(1132);
match(DIVIDE);
setState(1133);
unaryExpression();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(1138);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(1143);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultiplicativeExpressionContext extends ParserRuleContext {
public List unaryExpression() {
return getRuleContexts(UnaryExpressionContext.class);
}
public UnaryExpressionContext unaryExpression(int i) {
return getRuleContext(UnaryExpressionContext.class,i);
}
public List ASTERISK() { return getTokens(Sp4rql11Parser.ASTERISK); }
public TerminalNode ASTERISK(int i) {
return getToken(Sp4rql11Parser.ASTERISK, i);
}
public List DIVIDE() { return getTokens(Sp4rql11Parser.DIVIDE); }
public TerminalNode DIVIDE(int i) {
return getToken(Sp4rql11Parser.DIVIDE, i);
}
public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterMultiplicativeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitMultiplicativeExpression(this);
}
}
public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, getState());
enterRule(_localctx, 240, RULE_multiplicativeExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1144);
unaryExpression();
setState(1151);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ASTERISK || _la==DIVIDE) {
{
setState(1149);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASTERISK:
{
setState(1145);
match(ASTERISK);
setState(1146);
unaryExpression();
}
break;
case DIVIDE:
{
setState(1147);
match(DIVIDE);
setState(1148);
unaryExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(1153);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryExpressionContext extends ParserRuleContext {
public TerminalNode NOT_SIGN() { return getToken(Sp4rql11Parser.NOT_SIGN, 0); }
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public TerminalNode PLUS() { return getToken(Sp4rql11Parser.PLUS, 0); }
public TerminalNode DASH() { return getToken(Sp4rql11Parser.DASH, 0); }
public UnaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterUnaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitUnaryExpression(this);
}
}
public final UnaryExpressionContext unaryExpression() throws RecognitionException {
UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
enterRule(_localctx, 242, RULE_unaryExpression);
try {
setState(1161);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT_SIGN:
enterOuterAlt(_localctx, 1);
{
setState(1154);
match(NOT_SIGN);
setState(1155);
primaryExpression();
}
break;
case PLUS:
enterOuterAlt(_localctx, 2);
{
setState(1156);
match(PLUS);
setState(1157);
primaryExpression();
}
break;
case DASH:
enterOuterAlt(_localctx, 3);
{
setState(1158);
match(DASH);
setState(1159);
primaryExpression();
}
break;
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case TRUE:
case FALSE:
case SAMPLE:
case OPEN_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 4);
{
setState(1160);
primaryExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryExpressionContext extends ParserRuleContext {
public BrackettedExpressionContext brackettedExpression() {
return getRuleContext(BrackettedExpressionContext.class,0);
}
public BuiltInCallContext builtInCall() {
return getRuleContext(BuiltInCallContext.class,0);
}
public IriOrFunctionContext iriOrFunction() {
return getRuleContext(IriOrFunctionContext.class,0);
}
public RDFLiteralContext rDFLiteral() {
return getRuleContext(RDFLiteralContext.class,0);
}
public NumericLiteralContext numericLiteral() {
return getRuleContext(NumericLiteralContext.class,0);
}
public BooleanLiteralContext booleanLiteral() {
return getRuleContext(BooleanLiteralContext.class,0);
}
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPrimaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPrimaryExpression(this);
}
}
public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState());
enterRule(_localctx, 244, RULE_primaryExpression);
try {
setState(1170);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(1163);
brackettedExpression();
}
break;
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case SAMPLE:
enterOuterAlt(_localctx, 2);
{
setState(1164);
builtInCall();
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 3);
{
setState(1165);
iriOrFunction();
}
break;
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
enterOuterAlt(_localctx, 4);
{
setState(1166);
rDFLiteral();
}
break;
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
enterOuterAlt(_localctx, 5);
{
setState(1167);
numericLiteral();
}
break;
case TRUE:
case FALSE:
enterOuterAlt(_localctx, 6);
{
setState(1168);
booleanLiteral();
}
break;
case VAR1:
case VAR2:
enterOuterAlt(_localctx, 7);
{
setState(1169);
var();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BrackettedExpressionContext extends ParserRuleContext {
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public BrackettedExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_brackettedExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterBrackettedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitBrackettedExpression(this);
}
}
public final BrackettedExpressionContext brackettedExpression() throws RecognitionException {
BrackettedExpressionContext _localctx = new BrackettedExpressionContext(_ctx, getState());
enterRule(_localctx, 246, RULE_brackettedExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1172);
match(OPEN_BRACE);
setState(1173);
expression();
setState(1174);
match(CLOSE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BuiltInCallContext extends ParserRuleContext {
public AggregateContext aggregate() {
return getRuleContext(AggregateContext.class,0);
}
public TerminalNode STR() { return getToken(Sp4rql11Parser.STR, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public TerminalNode LANG() { return getToken(Sp4rql11Parser.LANG, 0); }
public TerminalNode LANGMATCHES() { return getToken(Sp4rql11Parser.LANGMATCHES, 0); }
public List COMMA() { return getTokens(Sp4rql11Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Sp4rql11Parser.COMMA, i);
}
public TerminalNode DATATYPE() { return getToken(Sp4rql11Parser.DATATYPE, 0); }
public TerminalNode BOUND() { return getToken(Sp4rql11Parser.BOUND, 0); }
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public TerminalNode IRI() { return getToken(Sp4rql11Parser.IRI, 0); }
public TerminalNode URI() { return getToken(Sp4rql11Parser.URI, 0); }
public TerminalNode BNODE() { return getToken(Sp4rql11Parser.BNODE, 0); }
public TerminalNode NIL() { return getToken(Sp4rql11Parser.NIL, 0); }
public TerminalNode RAND() { return getToken(Sp4rql11Parser.RAND, 0); }
public TerminalNode ABS() { return getToken(Sp4rql11Parser.ABS, 0); }
public TerminalNode CEIL() { return getToken(Sp4rql11Parser.CEIL, 0); }
public TerminalNode FLOOR() { return getToken(Sp4rql11Parser.FLOOR, 0); }
public TerminalNode ROUND() { return getToken(Sp4rql11Parser.ROUND, 0); }
public TerminalNode CONCAT() { return getToken(Sp4rql11Parser.CONCAT, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public SubstringExpressionContext substringExpression() {
return getRuleContext(SubstringExpressionContext.class,0);
}
public TerminalNode STRLEN() { return getToken(Sp4rql11Parser.STRLEN, 0); }
public StrReplaceExpressionContext strReplaceExpression() {
return getRuleContext(StrReplaceExpressionContext.class,0);
}
public TerminalNode UCASE() { return getToken(Sp4rql11Parser.UCASE, 0); }
public TerminalNode LCASE() { return getToken(Sp4rql11Parser.LCASE, 0); }
public TerminalNode ENCODE_FOR_URI() { return getToken(Sp4rql11Parser.ENCODE_FOR_URI, 0); }
public TerminalNode CONTAINS() { return getToken(Sp4rql11Parser.CONTAINS, 0); }
public TerminalNode STRSTARTS() { return getToken(Sp4rql11Parser.STRSTARTS, 0); }
public TerminalNode STRENDS() { return getToken(Sp4rql11Parser.STRENDS, 0); }
public TerminalNode STRBEFORE() { return getToken(Sp4rql11Parser.STRBEFORE, 0); }
public TerminalNode STRAFTER() { return getToken(Sp4rql11Parser.STRAFTER, 0); }
public TerminalNode YEAR() { return getToken(Sp4rql11Parser.YEAR, 0); }
public TerminalNode MONTH() { return getToken(Sp4rql11Parser.MONTH, 0); }
public TerminalNode DAY() { return getToken(Sp4rql11Parser.DAY, 0); }
public TerminalNode HOURS() { return getToken(Sp4rql11Parser.HOURS, 0); }
public TerminalNode MINUTES() { return getToken(Sp4rql11Parser.MINUTES, 0); }
public TerminalNode SECONDS() { return getToken(Sp4rql11Parser.SECONDS, 0); }
public TerminalNode TIMEZONE() { return getToken(Sp4rql11Parser.TIMEZONE, 0); }
public TerminalNode TZ() { return getToken(Sp4rql11Parser.TZ, 0); }
public TerminalNode NOW() { return getToken(Sp4rql11Parser.NOW, 0); }
public TerminalNode UUID() { return getToken(Sp4rql11Parser.UUID, 0); }
public TerminalNode STRUUID() { return getToken(Sp4rql11Parser.STRUUID, 0); }
public TerminalNode MD5() { return getToken(Sp4rql11Parser.MD5, 0); }
public TerminalNode SHA1() { return getToken(Sp4rql11Parser.SHA1, 0); }
public TerminalNode SHA256() { return getToken(Sp4rql11Parser.SHA256, 0); }
public TerminalNode SHA384() { return getToken(Sp4rql11Parser.SHA384, 0); }
public TerminalNode SHA512() { return getToken(Sp4rql11Parser.SHA512, 0); }
public TerminalNode COALESCE() { return getToken(Sp4rql11Parser.COALESCE, 0); }
public TerminalNode IF() { return getToken(Sp4rql11Parser.IF, 0); }
public TerminalNode STRLANG() { return getToken(Sp4rql11Parser.STRLANG, 0); }
public TerminalNode STRDT() { return getToken(Sp4rql11Parser.STRDT, 0); }
public TerminalNode SAMETERM() { return getToken(Sp4rql11Parser.SAMETERM, 0); }
public TerminalNode ISIRI() { return getToken(Sp4rql11Parser.ISIRI, 0); }
public TerminalNode ISURI() { return getToken(Sp4rql11Parser.ISURI, 0); }
public TerminalNode ISBLANK() { return getToken(Sp4rql11Parser.ISBLANK, 0); }
public TerminalNode ISLITERAL() { return getToken(Sp4rql11Parser.ISLITERAL, 0); }
public TerminalNode ISNUMERIC() { return getToken(Sp4rql11Parser.ISNUMERIC, 0); }
public RegexExpressionContext regexExpression() {
return getRuleContext(RegexExpressionContext.class,0);
}
public ExistsFuncContext existsFunc() {
return getRuleContext(ExistsFuncContext.class,0);
}
public NotExistsFuncContext notExistsFunc() {
return getRuleContext(NotExistsFuncContext.class,0);
}
public BuiltInCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_builtInCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterBuiltInCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitBuiltInCall(this);
}
}
public final BuiltInCallContext builtInCall() throws RecognitionException {
BuiltInCallContext _localctx = new BuiltInCallContext(_ctx, getState());
enterRule(_localctx, 248, RULE_builtInCall);
try {
setState(1434);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case SAMPLE:
enterOuterAlt(_localctx, 1);
{
setState(1176);
aggregate();
}
break;
case STR:
enterOuterAlt(_localctx, 2);
{
setState(1177);
match(STR);
setState(1178);
match(OPEN_BRACE);
setState(1179);
expression();
setState(1180);
match(CLOSE_BRACE);
}
break;
case LANG:
enterOuterAlt(_localctx, 3);
{
setState(1182);
match(LANG);
setState(1183);
match(OPEN_BRACE);
setState(1184);
expression();
setState(1185);
match(CLOSE_BRACE);
}
break;
case LANGMATCHES:
enterOuterAlt(_localctx, 4);
{
setState(1187);
match(LANGMATCHES);
setState(1188);
match(OPEN_BRACE);
setState(1189);
expression();
setState(1190);
match(COMMA);
setState(1191);
expression();
setState(1192);
match(CLOSE_BRACE);
}
break;
case DATATYPE:
enterOuterAlt(_localctx, 5);
{
setState(1194);
match(DATATYPE);
setState(1195);
match(OPEN_BRACE);
setState(1196);
expression();
setState(1197);
match(CLOSE_BRACE);
}
break;
case BOUND:
enterOuterAlt(_localctx, 6);
{
setState(1199);
match(BOUND);
setState(1200);
match(OPEN_BRACE);
setState(1201);
var();
setState(1202);
match(CLOSE_BRACE);
}
break;
case IRI:
enterOuterAlt(_localctx, 7);
{
setState(1204);
match(IRI);
setState(1205);
match(OPEN_BRACE);
setState(1206);
expression();
setState(1207);
match(CLOSE_BRACE);
}
break;
case URI:
enterOuterAlt(_localctx, 8);
{
setState(1209);
match(URI);
setState(1210);
match(OPEN_BRACE);
setState(1211);
expression();
setState(1212);
match(CLOSE_BRACE);
}
break;
case BNODE:
enterOuterAlt(_localctx, 9);
{
setState(1214);
match(BNODE);
setState(1220);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_BRACE:
{
setState(1215);
match(OPEN_BRACE);
setState(1216);
expression();
setState(1217);
match(CLOSE_BRACE);
}
break;
case NIL:
{
setState(1219);
match(NIL);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case RAND:
enterOuterAlt(_localctx, 10);
{
setState(1222);
match(RAND);
setState(1223);
match(NIL);
}
break;
case ABS:
enterOuterAlt(_localctx, 11);
{
setState(1224);
match(ABS);
setState(1225);
match(OPEN_BRACE);
setState(1226);
expression();
setState(1227);
match(CLOSE_BRACE);
}
break;
case CEIL:
enterOuterAlt(_localctx, 12);
{
setState(1229);
match(CEIL);
setState(1230);
match(OPEN_BRACE);
setState(1231);
expression();
setState(1232);
match(CLOSE_BRACE);
}
break;
case FLOOR:
enterOuterAlt(_localctx, 13);
{
setState(1234);
match(FLOOR);
setState(1235);
match(OPEN_BRACE);
setState(1236);
expression();
setState(1237);
match(CLOSE_BRACE);
}
break;
case ROUND:
enterOuterAlt(_localctx, 14);
{
setState(1239);
match(ROUND);
setState(1240);
match(OPEN_BRACE);
setState(1241);
expression();
setState(1242);
match(CLOSE_BRACE);
}
break;
case CONCAT:
enterOuterAlt(_localctx, 15);
{
setState(1244);
match(CONCAT);
setState(1245);
expressionList();
}
break;
case SUBSTR:
enterOuterAlt(_localctx, 16);
{
setState(1246);
substringExpression();
}
break;
case STRLEN:
enterOuterAlt(_localctx, 17);
{
setState(1247);
match(STRLEN);
setState(1248);
match(OPEN_BRACE);
setState(1249);
expression();
setState(1250);
match(CLOSE_BRACE);
}
break;
case REPLACE:
enterOuterAlt(_localctx, 18);
{
setState(1252);
strReplaceExpression();
}
break;
case UCASE:
enterOuterAlt(_localctx, 19);
{
setState(1253);
match(UCASE);
setState(1254);
match(OPEN_BRACE);
setState(1255);
expression();
setState(1256);
match(CLOSE_BRACE);
}
break;
case LCASE:
enterOuterAlt(_localctx, 20);
{
setState(1258);
match(LCASE);
setState(1259);
match(OPEN_BRACE);
setState(1260);
expression();
setState(1261);
match(CLOSE_BRACE);
}
break;
case ENCODE_FOR_URI:
enterOuterAlt(_localctx, 21);
{
setState(1263);
match(ENCODE_FOR_URI);
setState(1264);
match(OPEN_BRACE);
setState(1265);
expression();
setState(1266);
match(CLOSE_BRACE);
}
break;
case CONTAINS:
enterOuterAlt(_localctx, 22);
{
setState(1268);
match(CONTAINS);
setState(1269);
match(OPEN_BRACE);
setState(1270);
expression();
setState(1271);
match(COMMA);
setState(1272);
expression();
setState(1273);
match(CLOSE_BRACE);
}
break;
case STRSTARTS:
enterOuterAlt(_localctx, 23);
{
setState(1275);
match(STRSTARTS);
setState(1276);
match(OPEN_BRACE);
setState(1277);
expression();
setState(1278);
match(COMMA);
setState(1279);
expression();
setState(1280);
match(CLOSE_BRACE);
}
break;
case STRENDS:
enterOuterAlt(_localctx, 24);
{
setState(1282);
match(STRENDS);
setState(1283);
match(OPEN_BRACE);
setState(1284);
expression();
setState(1285);
match(COMMA);
setState(1286);
expression();
setState(1287);
match(CLOSE_BRACE);
}
break;
case STRBEFORE:
enterOuterAlt(_localctx, 25);
{
setState(1289);
match(STRBEFORE);
setState(1290);
match(OPEN_BRACE);
setState(1291);
expression();
setState(1292);
match(COMMA);
setState(1293);
expression();
setState(1294);
match(CLOSE_BRACE);
}
break;
case STRAFTER:
enterOuterAlt(_localctx, 26);
{
setState(1296);
match(STRAFTER);
setState(1297);
match(OPEN_BRACE);
setState(1298);
expression();
setState(1299);
match(COMMA);
setState(1300);
expression();
setState(1301);
match(CLOSE_BRACE);
}
break;
case YEAR:
enterOuterAlt(_localctx, 27);
{
setState(1303);
match(YEAR);
setState(1304);
match(OPEN_BRACE);
setState(1305);
expression();
setState(1306);
match(CLOSE_BRACE);
}
break;
case MONTH:
enterOuterAlt(_localctx, 28);
{
setState(1308);
match(MONTH);
setState(1309);
match(OPEN_BRACE);
setState(1310);
expression();
setState(1311);
match(CLOSE_BRACE);
}
break;
case DAY:
enterOuterAlt(_localctx, 29);
{
setState(1313);
match(DAY);
setState(1314);
match(OPEN_BRACE);
setState(1315);
expression();
setState(1316);
match(CLOSE_BRACE);
}
break;
case HOURS:
enterOuterAlt(_localctx, 30);
{
setState(1318);
match(HOURS);
setState(1319);
match(OPEN_BRACE);
setState(1320);
expression();
setState(1321);
match(CLOSE_BRACE);
}
break;
case MINUTES:
enterOuterAlt(_localctx, 31);
{
setState(1323);
match(MINUTES);
setState(1324);
match(OPEN_BRACE);
setState(1325);
expression();
setState(1326);
match(CLOSE_BRACE);
}
break;
case SECONDS:
enterOuterAlt(_localctx, 32);
{
setState(1328);
match(SECONDS);
setState(1329);
match(OPEN_BRACE);
setState(1330);
expression();
setState(1331);
match(CLOSE_BRACE);
}
break;
case TIMEZONE:
enterOuterAlt(_localctx, 33);
{
setState(1333);
match(TIMEZONE);
setState(1334);
match(OPEN_BRACE);
setState(1335);
expression();
setState(1336);
match(CLOSE_BRACE);
}
break;
case TZ:
enterOuterAlt(_localctx, 34);
{
setState(1338);
match(TZ);
setState(1339);
match(OPEN_BRACE);
setState(1340);
expression();
setState(1341);
match(CLOSE_BRACE);
}
break;
case NOW:
enterOuterAlt(_localctx, 35);
{
setState(1343);
match(NOW);
setState(1344);
match(NIL);
}
break;
case UUID:
enterOuterAlt(_localctx, 36);
{
setState(1345);
match(UUID);
setState(1346);
match(NIL);
}
break;
case STRUUID:
enterOuterAlt(_localctx, 37);
{
setState(1347);
match(STRUUID);
setState(1348);
match(NIL);
}
break;
case MD5:
enterOuterAlt(_localctx, 38);
{
setState(1349);
match(MD5);
setState(1350);
match(OPEN_BRACE);
setState(1351);
expression();
setState(1352);
match(CLOSE_BRACE);
}
break;
case SHA1:
enterOuterAlt(_localctx, 39);
{
setState(1354);
match(SHA1);
setState(1355);
match(OPEN_BRACE);
setState(1356);
expression();
setState(1357);
match(CLOSE_BRACE);
}
break;
case SHA256:
enterOuterAlt(_localctx, 40);
{
setState(1359);
match(SHA256);
setState(1360);
match(OPEN_BRACE);
setState(1361);
expression();
setState(1362);
match(CLOSE_BRACE);
}
break;
case SHA384:
enterOuterAlt(_localctx, 41);
{
setState(1364);
match(SHA384);
setState(1365);
match(OPEN_BRACE);
setState(1366);
expression();
setState(1367);
match(CLOSE_BRACE);
}
break;
case SHA512:
enterOuterAlt(_localctx, 42);
{
setState(1369);
match(SHA512);
setState(1370);
match(OPEN_BRACE);
setState(1371);
expression();
setState(1372);
match(CLOSE_BRACE);
}
break;
case COALESCE:
enterOuterAlt(_localctx, 43);
{
setState(1374);
match(COALESCE);
setState(1375);
expressionList();
}
break;
case IF:
enterOuterAlt(_localctx, 44);
{
setState(1376);
match(IF);
setState(1377);
match(OPEN_BRACE);
setState(1378);
expression();
setState(1379);
match(COMMA);
setState(1380);
expression();
setState(1381);
match(COMMA);
setState(1382);
expression();
setState(1383);
match(CLOSE_BRACE);
}
break;
case STRLANG:
enterOuterAlt(_localctx, 45);
{
setState(1385);
match(STRLANG);
setState(1386);
match(OPEN_BRACE);
setState(1387);
expression();
setState(1388);
match(COMMA);
setState(1389);
expression();
setState(1390);
match(CLOSE_BRACE);
}
break;
case STRDT:
enterOuterAlt(_localctx, 46);
{
setState(1392);
match(STRDT);
setState(1393);
match(OPEN_BRACE);
setState(1394);
expression();
setState(1395);
match(COMMA);
setState(1396);
expression();
setState(1397);
match(CLOSE_BRACE);
}
break;
case SAMETERM:
enterOuterAlt(_localctx, 47);
{
setState(1399);
match(SAMETERM);
setState(1400);
match(OPEN_BRACE);
setState(1401);
expression();
setState(1402);
match(COMMA);
setState(1403);
expression();
setState(1404);
match(CLOSE_BRACE);
}
break;
case ISIRI:
enterOuterAlt(_localctx, 48);
{
setState(1406);
match(ISIRI);
setState(1407);
match(OPEN_BRACE);
setState(1408);
expression();
setState(1409);
match(CLOSE_BRACE);
}
break;
case ISURI:
enterOuterAlt(_localctx, 49);
{
setState(1411);
match(ISURI);
setState(1412);
match(OPEN_BRACE);
setState(1413);
expression();
setState(1414);
match(CLOSE_BRACE);
}
break;
case ISBLANK:
enterOuterAlt(_localctx, 50);
{
setState(1416);
match(ISBLANK);
setState(1417);
match(OPEN_BRACE);
setState(1418);
expression();
setState(1419);
match(CLOSE_BRACE);
}
break;
case ISLITERAL:
enterOuterAlt(_localctx, 51);
{
setState(1421);
match(ISLITERAL);
setState(1422);
match(OPEN_BRACE);
setState(1423);
expression();
setState(1424);
match(CLOSE_BRACE);
}
break;
case ISNUMERIC:
enterOuterAlt(_localctx, 52);
{
setState(1426);
match(ISNUMERIC);
setState(1427);
match(OPEN_BRACE);
setState(1428);
expression();
setState(1429);
match(CLOSE_BRACE);
}
break;
case REGEX:
enterOuterAlt(_localctx, 53);
{
setState(1431);
regexExpression();
}
break;
case EXISTS:
enterOuterAlt(_localctx, 54);
{
setState(1432);
existsFunc();
}
break;
case NOT:
enterOuterAlt(_localctx, 55);
{
setState(1433);
notExistsFunc();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegexExpressionContext extends ParserRuleContext {
public TerminalNode REGEX() { return getToken(Sp4rql11Parser.REGEX, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(Sp4rql11Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Sp4rql11Parser.COMMA, i);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public RegexExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regexExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterRegexExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitRegexExpression(this);
}
}
public final RegexExpressionContext regexExpression() throws RecognitionException {
RegexExpressionContext _localctx = new RegexExpressionContext(_ctx, getState());
enterRule(_localctx, 250, RULE_regexExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1436);
match(REGEX);
setState(1437);
match(OPEN_BRACE);
setState(1438);
expression();
setState(1439);
match(COMMA);
setState(1440);
expression();
setState(1443);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1441);
match(COMMA);
setState(1442);
expression();
}
}
setState(1445);
match(CLOSE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubstringExpressionContext extends ParserRuleContext {
public TerminalNode SUBSTR() { return getToken(Sp4rql11Parser.SUBSTR, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(Sp4rql11Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Sp4rql11Parser.COMMA, i);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public SubstringExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_substringExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterSubstringExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitSubstringExpression(this);
}
}
public final SubstringExpressionContext substringExpression() throws RecognitionException {
SubstringExpressionContext _localctx = new SubstringExpressionContext(_ctx, getState());
enterRule(_localctx, 252, RULE_substringExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1447);
match(SUBSTR);
setState(1448);
match(OPEN_BRACE);
setState(1449);
expression();
setState(1450);
match(COMMA);
setState(1451);
expression();
setState(1454);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1452);
match(COMMA);
setState(1453);
expression();
}
}
setState(1456);
match(CLOSE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrReplaceExpressionContext extends ParserRuleContext {
public TerminalNode REPLACE() { return getToken(Sp4rql11Parser.REPLACE, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(Sp4rql11Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Sp4rql11Parser.COMMA, i);
}
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public StrReplaceExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strReplaceExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterStrReplaceExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitStrReplaceExpression(this);
}
}
public final StrReplaceExpressionContext strReplaceExpression() throws RecognitionException {
StrReplaceExpressionContext _localctx = new StrReplaceExpressionContext(_ctx, getState());
enterRule(_localctx, 254, RULE_strReplaceExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1458);
match(REPLACE);
setState(1459);
match(OPEN_BRACE);
setState(1460);
expression();
setState(1461);
match(COMMA);
setState(1462);
expression();
setState(1463);
match(COMMA);
setState(1464);
expression();
setState(1467);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1465);
match(COMMA);
setState(1466);
expression();
}
}
setState(1469);
match(CLOSE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExistsFuncContext extends ParserRuleContext {
public TerminalNode EXISTS() { return getToken(Sp4rql11Parser.EXISTS, 0); }
public GroupGraphPatternContext groupGraphPattern() {
return getRuleContext(GroupGraphPatternContext.class,0);
}
public ExistsFuncContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_existsFunc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterExistsFunc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitExistsFunc(this);
}
}
public final ExistsFuncContext existsFunc() throws RecognitionException {
ExistsFuncContext _localctx = new ExistsFuncContext(_ctx, getState());
enterRule(_localctx, 256, RULE_existsFunc);
try {
enterOuterAlt(_localctx, 1);
{
setState(1471);
match(EXISTS);
setState(1472);
groupGraphPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NotExistsFuncContext extends ParserRuleContext {
public TerminalNode NOT() { return getToken(Sp4rql11Parser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(Sp4rql11Parser.EXISTS, 0); }
public GroupGraphPatternContext groupGraphPattern() {
return getRuleContext(GroupGraphPatternContext.class,0);
}
public NotExistsFuncContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notExistsFunc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterNotExistsFunc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitNotExistsFunc(this);
}
}
public final NotExistsFuncContext notExistsFunc() throws RecognitionException {
NotExistsFuncContext _localctx = new NotExistsFuncContext(_ctx, getState());
enterRule(_localctx, 258, RULE_notExistsFunc);
try {
enterOuterAlt(_localctx, 1);
{
setState(1474);
match(NOT);
setState(1475);
match(EXISTS);
setState(1476);
groupGraphPattern();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AggregateContext extends ParserRuleContext {
public TerminalNode COUNT() { return getToken(Sp4rql11Parser.COUNT, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Sp4rql11Parser.OPEN_BRACE, 0); }
public TerminalNode CLOSE_BRACE() { return getToken(Sp4rql11Parser.CLOSE_BRACE, 0); }
public TerminalNode ASTERISK() { return getToken(Sp4rql11Parser.ASTERISK, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DISTINCT() { return getToken(Sp4rql11Parser.DISTINCT, 0); }
public TerminalNode SUM() { return getToken(Sp4rql11Parser.SUM, 0); }
public TerminalNode MIN() { return getToken(Sp4rql11Parser.MIN, 0); }
public TerminalNode MAX() { return getToken(Sp4rql11Parser.MAX, 0); }
public TerminalNode AVG() { return getToken(Sp4rql11Parser.AVG, 0); }
public TerminalNode SAMPLE() { return getToken(Sp4rql11Parser.SAMPLE, 0); }
public TerminalNode GROUP_CONCAT() { return getToken(Sp4rql11Parser.GROUP_CONCAT, 0); }
public TerminalNode SEMICOLON() { return getToken(Sp4rql11Parser.SEMICOLON, 0); }
public TerminalNode SEPARATOR() { return getToken(Sp4rql11Parser.SEPARATOR, 0); }
public TerminalNode EQUAL() { return getToken(Sp4rql11Parser.EQUAL, 0); }
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public AggregateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aggregate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterAggregate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitAggregate(this);
}
}
public final AggregateContext aggregate() throws RecognitionException {
AggregateContext _localctx = new AggregateContext(_ctx, getState());
enterRule(_localctx, 260, RULE_aggregate);
int _la;
try {
setState(1542);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COUNT:
enterOuterAlt(_localctx, 1);
{
setState(1478);
match(COUNT);
setState(1479);
match(OPEN_BRACE);
setState(1481);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1480);
match(DISTINCT);
}
}
setState(1485);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ASTERISK:
{
setState(1483);
match(ASTERISK);
}
break;
case NOT:
case STR:
case LANG:
case LANGMATCHES:
case DATATYPE:
case BOUND:
case IRI:
case URI:
case BNODE:
case RAND:
case ABS:
case CEIL:
case FLOOR:
case ROUND:
case CONCAT:
case STRLEN:
case UCASE:
case LCASE:
case ENCODE_FOR_URI:
case CONTAINS:
case STRSTARTS:
case STRENDS:
case STRBEFORE:
case STRAFTER:
case YEAR:
case MONTH:
case DAY:
case HOURS:
case MINUTES:
case SECONDS:
case TIMEZONE:
case TZ:
case NOW:
case UUID:
case STRUUID:
case MD5:
case SHA1:
case SHA256:
case SHA384:
case SHA512:
case COALESCE:
case IF:
case STRLANG:
case STRDT:
case SAMETERM:
case ISIRI:
case ISURI:
case ISBLANK:
case ISLITERAL:
case ISNUMERIC:
case REGEX:
case SUBSTR:
case REPLACE:
case EXISTS:
case COUNT:
case SUM:
case MIN:
case MAX:
case AVG:
case GROUP_CONCAT:
case TRUE:
case FALSE:
case SAMPLE:
case PLUS:
case DASH:
case NOT_SIGN:
case OPEN_BRACE:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case UNQUOTED_IRIREF:
{
setState(1484);
expression();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1487);
match(CLOSE_BRACE);
}
break;
case SUM:
enterOuterAlt(_localctx, 2);
{
setState(1488);
match(SUM);
setState(1489);
match(OPEN_BRACE);
setState(1491);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1490);
match(DISTINCT);
}
}
setState(1493);
expression();
setState(1494);
match(CLOSE_BRACE);
}
break;
case MIN:
enterOuterAlt(_localctx, 3);
{
setState(1496);
match(MIN);
setState(1497);
match(OPEN_BRACE);
setState(1499);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1498);
match(DISTINCT);
}
}
setState(1501);
expression();
setState(1502);
match(CLOSE_BRACE);
}
break;
case MAX:
enterOuterAlt(_localctx, 4);
{
setState(1504);
match(MAX);
setState(1505);
match(OPEN_BRACE);
setState(1507);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1506);
match(DISTINCT);
}
}
setState(1509);
expression();
setState(1510);
match(CLOSE_BRACE);
}
break;
case AVG:
enterOuterAlt(_localctx, 5);
{
setState(1512);
match(AVG);
setState(1513);
match(OPEN_BRACE);
setState(1515);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1514);
match(DISTINCT);
}
}
setState(1517);
expression();
setState(1518);
match(CLOSE_BRACE);
}
break;
case SAMPLE:
enterOuterAlt(_localctx, 6);
{
setState(1520);
match(SAMPLE);
setState(1521);
match(OPEN_BRACE);
setState(1523);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1522);
match(DISTINCT);
}
}
setState(1525);
expression();
setState(1526);
match(CLOSE_BRACE);
}
break;
case GROUP_CONCAT:
enterOuterAlt(_localctx, 7);
{
setState(1528);
match(GROUP_CONCAT);
setState(1529);
match(OPEN_BRACE);
setState(1531);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT) {
{
setState(1530);
match(DISTINCT);
}
}
setState(1533);
expression();
setState(1538);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(1534);
match(SEMICOLON);
setState(1535);
match(SEPARATOR);
setState(1536);
match(EQUAL);
setState(1537);
string();
}
}
setState(1540);
match(CLOSE_BRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IriOrFunctionContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public ArgListContext argList() {
return getRuleContext(ArgListContext.class,0);
}
public IriOrFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iriOrFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterIriOrFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitIriOrFunction(this);
}
}
public final IriOrFunctionContext iriOrFunction() throws RecognitionException {
IriOrFunctionContext _localctx = new IriOrFunctionContext(_ctx, getState());
enterRule(_localctx, 262, RULE_iriOrFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1544);
iri();
setState(1546);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_BRACE || _la==NIL) {
{
setState(1545);
argList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RDFLiteralContext extends ParserRuleContext {
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public TerminalNode LANGTAG() { return getToken(Sp4rql11Parser.LANGTAG, 0); }
public TerminalNode REFERENCE() { return getToken(Sp4rql11Parser.REFERENCE, 0); }
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public RDFLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rDFLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterRDFLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitRDFLiteral(this);
}
}
public final RDFLiteralContext rDFLiteral() throws RecognitionException {
RDFLiteralContext _localctx = new RDFLiteralContext(_ctx, getState());
enterRule(_localctx, 264, RULE_rDFLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1548);
string();
setState(1552);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LANGTAG:
{
setState(1549);
match(LANGTAG);
}
break;
case REFERENCE:
{
{
setState(1550);
match(REFERENCE);
setState(1551);
iri();
}
}
break;
case T__0:
case T__1:
case GRAPH:
case OPTIONAL:
case SERVICE:
case BIND:
case AS:
case UNDEF:
case MINUS:
case FILTER:
case A:
case NOT:
case IN:
case TRUE:
case FALSE:
case VALUES:
case AND:
case OR:
case OPEN_CURLY_BRACE:
case CLOSE_CURLY_BRACE:
case SEMICOLON:
case DOT:
case PLUS:
case DASH:
case ASTERISK:
case COMMA:
case NOT_SIGN:
case DIVIDE:
case EQUAL:
case LESS:
case GREATER:
case OPEN_BRACE:
case CLOSE_BRACE:
case LESS_EQUAL:
case GREATER_EQUAL:
case NOT_EQUAL:
case OPEN_SQUARE_BRACE:
case CLOSE_SQUARE_BRACE:
case CARET:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case VAR1:
case VAR2:
case INTEGER:
case DECIMAL:
case DOUBLE:
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
case STRING_LITERAL1:
case STRING_LITERAL2:
case STRING_LITERAL_LONG1:
case STRING_LITERAL_LONG2:
case NIL:
case ANON:
case UNQUOTED_IRIREF:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumericLiteralContext extends ParserRuleContext {
public NumericLiteralUnsignedContext numericLiteralUnsigned() {
return getRuleContext(NumericLiteralUnsignedContext.class,0);
}
public NumericLiteralPositiveContext numericLiteralPositive() {
return getRuleContext(NumericLiteralPositiveContext.class,0);
}
public NumericLiteralNegativeContext numericLiteralNegative() {
return getRuleContext(NumericLiteralNegativeContext.class,0);
}
public NumericLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitNumericLiteral(this);
}
}
public final NumericLiteralContext numericLiteral() throws RecognitionException {
NumericLiteralContext _localctx = new NumericLiteralContext(_ctx, getState());
enterRule(_localctx, 266, RULE_numericLiteral);
try {
setState(1557);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER:
case DECIMAL:
case DOUBLE:
enterOuterAlt(_localctx, 1);
{
setState(1554);
numericLiteralUnsigned();
}
break;
case INTEGER_POSITIVE:
case DECIMAL_POSITIVE:
case DOUBLE_POSITIVE:
enterOuterAlt(_localctx, 2);
{
setState(1555);
numericLiteralPositive();
}
break;
case INTEGER_NEGATIVE:
case DECIMAL_NEGATIVE:
case DOUBLE_NEGATIVE:
enterOuterAlt(_localctx, 3);
{
setState(1556);
numericLiteralNegative();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumericLiteralUnsignedContext extends ParserRuleContext {
public TerminalNode INTEGER() { return getToken(Sp4rql11Parser.INTEGER, 0); }
public TerminalNode DECIMAL() { return getToken(Sp4rql11Parser.DECIMAL, 0); }
public TerminalNode DOUBLE() { return getToken(Sp4rql11Parser.DOUBLE, 0); }
public NumericLiteralUnsignedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericLiteralUnsigned; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterNumericLiteralUnsigned(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitNumericLiteralUnsigned(this);
}
}
public final NumericLiteralUnsignedContext numericLiteralUnsigned() throws RecognitionException {
NumericLiteralUnsignedContext _localctx = new NumericLiteralUnsignedContext(_ctx, getState());
enterRule(_localctx, 268, RULE_numericLiteralUnsigned);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1559);
_la = _input.LA(1);
if ( !(((((_la - 149)) & ~0x3f) == 0 && ((1L << (_la - 149)) & ((1L << (INTEGER - 149)) | (1L << (DECIMAL - 149)) | (1L << (DOUBLE - 149)))) != 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 class NumericLiteralPositiveContext extends ParserRuleContext {
public TerminalNode INTEGER_POSITIVE() { return getToken(Sp4rql11Parser.INTEGER_POSITIVE, 0); }
public TerminalNode DECIMAL_POSITIVE() { return getToken(Sp4rql11Parser.DECIMAL_POSITIVE, 0); }
public TerminalNode DOUBLE_POSITIVE() { return getToken(Sp4rql11Parser.DOUBLE_POSITIVE, 0); }
public NumericLiteralPositiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericLiteralPositive; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterNumericLiteralPositive(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitNumericLiteralPositive(this);
}
}
public final NumericLiteralPositiveContext numericLiteralPositive() throws RecognitionException {
NumericLiteralPositiveContext _localctx = new NumericLiteralPositiveContext(_ctx, getState());
enterRule(_localctx, 270, RULE_numericLiteralPositive);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1561);
_la = _input.LA(1);
if ( !(((((_la - 152)) & ~0x3f) == 0 && ((1L << (_la - 152)) & ((1L << (INTEGER_POSITIVE - 152)) | (1L << (DECIMAL_POSITIVE - 152)) | (1L << (DOUBLE_POSITIVE - 152)))) != 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 class NumericLiteralNegativeContext extends ParserRuleContext {
public TerminalNode INTEGER_NEGATIVE() { return getToken(Sp4rql11Parser.INTEGER_NEGATIVE, 0); }
public TerminalNode DECIMAL_NEGATIVE() { return getToken(Sp4rql11Parser.DECIMAL_NEGATIVE, 0); }
public TerminalNode DOUBLE_NEGATIVE() { return getToken(Sp4rql11Parser.DOUBLE_NEGATIVE, 0); }
public NumericLiteralNegativeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericLiteralNegative; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterNumericLiteralNegative(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitNumericLiteralNegative(this);
}
}
public final NumericLiteralNegativeContext numericLiteralNegative() throws RecognitionException {
NumericLiteralNegativeContext _localctx = new NumericLiteralNegativeContext(_ctx, getState());
enterRule(_localctx, 272, RULE_numericLiteralNegative);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1563);
_la = _input.LA(1);
if ( !(((((_la - 155)) & ~0x3f) == 0 && ((1L << (_la - 155)) & ((1L << (INTEGER_NEGATIVE - 155)) | (1L << (DECIMAL_NEGATIVE - 155)) | (1L << (DOUBLE_NEGATIVE - 155)))) != 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 class BooleanLiteralContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(Sp4rql11Parser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(Sp4rql11Parser.FALSE, 0); }
public BooleanLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitBooleanLiteral(this);
}
}
public final BooleanLiteralContext booleanLiteral() throws RecognitionException {
BooleanLiteralContext _localctx = new BooleanLiteralContext(_ctx, getState());
enterRule(_localctx, 274, RULE_booleanLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1565);
_la = _input.LA(1);
if ( !(_la==TRUE || _la==FALSE) ) {
_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 class StringContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL1() { return getToken(Sp4rql11Parser.STRING_LITERAL1, 0); }
public TerminalNode STRING_LITERAL2() { return getToken(Sp4rql11Parser.STRING_LITERAL2, 0); }
public TerminalNode STRING_LITERAL_LONG1() { return getToken(Sp4rql11Parser.STRING_LITERAL_LONG1, 0); }
public TerminalNode STRING_LITERAL_LONG2() { return getToken(Sp4rql11Parser.STRING_LITERAL_LONG2, 0); }
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitString(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 276, RULE_string);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1567);
_la = _input.LA(1);
if ( !(((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & ((1L << (STRING_LITERAL1 - 158)) | (1L << (STRING_LITERAL2 - 158)) | (1L << (STRING_LITERAL_LONG1 - 158)) | (1L << (STRING_LITERAL_LONG2 - 158)))) != 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 class IriContext extends ParserRuleContext {
public TerminalNode IRIREF() { return getToken(Sp4rql11Parser.IRIREF, 0); }
public PrefixedNameContext prefixedName() {
return getRuleContext(PrefixedNameContext.class,0);
}
public TerminalNode UNQUOTED_IRIREF() { return getToken(Sp4rql11Parser.UNQUOTED_IRIREF, 0); }
public IriContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iri; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterIri(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitIri(this);
}
}
public final IriContext iri() throws RecognitionException {
IriContext _localctx = new IriContext(_ctx, getState());
enterRule(_localctx, 278, RULE_iri);
try {
setState(1572);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(1569);
match(IRIREF);
}
break;
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 2);
{
setState(1570);
prefixedName();
}
break;
case UNQUOTED_IRIREF:
enterOuterAlt(_localctx, 3);
{
setState(1571);
match(UNQUOTED_IRIREF);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrefixedNameContext extends ParserRuleContext {
public TerminalNode PNAME_LN() { return getToken(Sp4rql11Parser.PNAME_LN, 0); }
public TerminalNode PNAME_NS() { return getToken(Sp4rql11Parser.PNAME_NS, 0); }
public PrefixedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefixedName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterPrefixedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitPrefixedName(this);
}
}
public final PrefixedNameContext prefixedName() throws RecognitionException {
PrefixedNameContext _localctx = new PrefixedNameContext(_ctx, getState());
enterRule(_localctx, 280, RULE_prefixedName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1574);
_la = _input.LA(1);
if ( !(_la==PNAME_NS || _la==PNAME_LN) ) {
_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 class BlankNodeContext extends ParserRuleContext {
public TerminalNode BLANK_NODE_LABEL() { return getToken(Sp4rql11Parser.BLANK_NODE_LABEL, 0); }
public TerminalNode ANON() { return getToken(Sp4rql11Parser.ANON, 0); }
public BlankNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blankNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).enterBlankNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Sp4rql11Listener ) ((Sp4rql11Listener)listener).exitBlankNode(this);
}
}
public final BlankNodeContext blankNode() throws RecognitionException {
BlankNodeContext _localctx = new BlankNodeContext(_ctx, getState());
enterRule(_localctx, 282, RULE_blankNode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1576);
_la = _input.LA(1);
if ( !(_la==BLANK_NODE_LABEL || _la==ANON) ) {
_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 =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00aa\u062d\4\2\t"+
"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
"\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
"\t\u008e\4\u008f\t\u008f\3\2\3\2\3\3\3\3\3\3\3\3\3\3\5\3\u0126\n\3\3\3"+
"\3\3\3\4\3\4\3\5\3\5\7\5\u012e\n\5\f\5\16\5\u0131\13\5\3\6\3\6\3\6\3\7"+
"\3\7\3\7\3\7\3\b\3\b\7\b\u013c\n\b\f\b\16\b\u013f\13\b\3\b\3\b\3\b\3\t"+
"\3\t\3\t\3\t\3\t\3\n\3\n\5\n\u014b\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n"+
"\3\n\3\n\3\n\6\n\u0158\n\n\r\n\16\n\u0159\3\n\5\n\u015d\n\n\3\13\3\13"+
"\3\13\7\13\u0162\n\13\f\13\16\13\u0165\13\13\3\13\3\13\3\13\3\13\7\13"+
"\u016b\n\13\f\13\16\13\u016e\13\13\3\13\3\13\3\13\5\13\u0173\n\13\3\13"+
"\3\13\5\13\u0177\n\13\3\f\3\f\6\f\u017b\n\f\r\f\16\f\u017c\3\f\5\f\u0180"+
"\n\f\3\f\7\f\u0183\n\f\f\f\16\f\u0186\13\f\3\f\5\f\u0189\n\f\3\f\3\f\3"+
"\r\3\r\7\r\u018f\n\r\f\r\16\r\u0192\13\r\3\r\3\r\3\r\3\16\3\16\3\16\5"+
"\16\u019a\n\16\3\17\3\17\3\20\3\20\3\20\3\21\3\21\5\21\u01a3\n\21\3\22"+
"\5\22\u01a6\n\22\3\22\3\22\3\23\5\23\u01ab\n\23\3\23\5\23\u01ae\n\23\3"+
"\23\5\23\u01b1\n\23\3\23\5\23\u01b4\n\23\3\24\3\24\3\24\6\24\u01b9\n\24"+
"\r\24\16\24\u01ba\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u01c3\n\25\3\25\3"+
"\25\3\25\5\25\u01c8\n\25\3\26\3\26\6\26\u01cc\n\26\r\26\16\26\u01cd\3"+
"\27\3\27\3\30\3\30\3\30\6\30\u01d5\n\30\r\30\16\30\u01d6\3\31\3\31\3\31"+
"\3\31\5\31\u01dd\n\31\5\31\u01df\n\31\3\32\3\32\5\32\u01e3\n\32\3\32\3"+
"\32\5\32\u01e7\n\32\5\32\u01e9\n\32\3\33\3\33\3\33\3\34\3\34\3\34\3\35"+
"\3\35\5\35\u01f3\n\35\3\36\3\36\3\36\3\36\5\36\u01f9\n\36\5\36\u01fb\n"+
"\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u0208"+
"\n\37\3 \3 \5 \u020c\n \3 \3 \3 \5 \u0211\n \3!\3!\5!\u0215\n!\3!\3!\3"+
"\"\3\"\5\"\u021b\n\"\3\"\3\"\3#\3#\5#\u0221\n#\3#\3#\3$\3$\5$\u0227\n"+
"$\3$\3$\3$\3$\3%\3%\5%\u022f\n%\3%\3%\3%\3%\3&\3&\5&\u0237\n&\3&\3&\3"+
"&\3&\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3)\3)\3)\3)\3*\3*\5*\u024b\n*\3*\3*\5"+
"*\u024f\n*\3*\5*\u0252\n*\3*\7*\u0255\n*\f*\16*\u0258\13*\3*\3*\3*\3+"+
"\3+\3+\3,\3,\3,\3-\3-\3-\3-\5-\u0267\n-\3.\3.\5.\u026b\n.\3.\5.\u026e"+
"\n.\3/\3/\3/\3\60\3\60\3\60\3\60\5\60\u0277\n\60\3\61\3\61\3\61\3\61\3"+
"\62\3\62\3\62\3\62\3\63\5\63\u0282\n\63\3\63\3\63\5\63\u0286\n\63\3\63"+
"\5\63\u0289\n\63\7\63\u028b\n\63\f\63\16\63\u028e\13\63\3\64\3\64\3\64"+
"\3\64\5\64\u0294\n\64\3\64\3\64\3\65\3\65\3\65\5\65\u029b\n\65\5\65\u029d"+
"\n\65\3\66\3\66\3\66\5\66\u02a2\n\66\3\66\3\66\3\67\5\67\u02a7\n\67\3"+
"\67\3\67\5\67\u02ab\n\67\3\67\5\67\u02ae\n\67\7\67\u02b0\n\67\f\67\16"+
"\67\u02b3\13\67\38\38\38\58\u02b8\n8\58\u02ba\n8\39\39\39\39\39\39\39"+
"\39\59\u02c4\n9\3:\3:\3:\3;\3;\3;\3;\3<\3<\5<\u02cf\n<\3<\3<\3<\3=\3="+
"\3=\3=\3=\3=\3=\3>\3>\3>\3?\3?\5?\u02e0\n?\3@\3@\3@\7@\u02e5\n@\f@\16"+
"@\u02e8\13@\3@\3@\3A\3A\3A\7A\u02ef\nA\fA\16A\u02f2\13A\3A\5A\u02f5\n"+
"A\3A\3A\3A\7A\u02fa\nA\fA\16A\u02fd\13A\3A\3A\7A\u0301\nA\fA\16A\u0304"+
"\13A\3A\3A\3B\3B\3B\3B\3B\5B\u030d\nB\3C\3C\3C\3D\3D\3D\7D\u0315\nD\f"+
"D\16D\u0318\13D\3E\3E\3E\3F\3F\3F\5F\u0320\nF\3G\3G\3G\3H\3H\3H\5H\u0328"+
"\nH\3H\3H\3H\7H\u032d\nH\fH\16H\u0330\13H\3H\3H\5H\u0334\nH\3I\3I\3I\3"+
"I\3I\7I\u033b\nI\fI\16I\u033e\13I\3I\3I\5I\u0342\nI\3J\3J\5J\u0346\nJ"+
"\3J\3J\3K\3K\3K\5K\u034d\nK\5K\u034f\nK\3L\3L\3L\3L\3L\3L\5L\u0357\nL"+
"\3M\5M\u035a\nM\3N\3N\3N\3N\3N\3N\5N\u0362\nN\7N\u0364\nN\fN\16N\u0367"+
"\13N\3O\3O\5O\u036b\nO\3P\3P\3P\7P\u0370\nP\fP\16P\u0373\13P\3Q\3Q\5Q"+
"\u0377\nQ\3R\3R\3R\3R\3R\5R\u037e\nR\3R\3R\3R\3R\3R\3R\5R\u0386\nR\3S"+
"\3S\3T\5T\u038b\nT\3U\3U\5U\u038f\nU\3U\3U\3U\3U\5U\u0395\nU\3U\3U\5U"+
"\u0399\nU\7U\u039b\nU\fU\16U\u039e\13U\3V\3V\3W\3W\5W\u03a4\nW\3X\3X\3"+
"X\7X\u03a9\nX\fX\16X\u03ac\13X\3Y\3Y\3Z\3Z\3[\3[\3[\7[\u03b5\n[\f[\16"+
"[\u03b8\13[\3\\\3\\\3\\\7\\\u03bd\n\\\f\\\16\\\u03c0\13\\\3]\3]\5]\u03c4"+
"\n]\3^\3^\3^\5^\u03c9\n^\3_\3_\3`\3`\3`\3`\3`\3`\3`\3`\5`\u03d5\n`\3a"+
"\3a\3a\3a\3a\7a\u03dc\na\fa\16a\u03df\13a\5a\u03e1\na\3a\5a\u03e4\na\3"+
"b\3b\3b\3b\3b\5b\u03eb\nb\5b\u03ed\nb\3c\3c\3d\3d\5d\u03f3\nd\3e\3e\3"+
"e\3e\3f\3f\5f\u03fb\nf\3g\3g\3g\3g\3h\3h\6h\u0403\nh\rh\16h\u0404\3h\3"+
"h\3i\3i\6i\u040b\ni\ri\16i\u040c\3i\3i\3j\3j\5j\u0413\nj\3k\3k\5k\u0417"+
"\nk\3l\3l\5l\u041b\nl\3m\3m\3m\5m\u0420\nm\3n\3n\5n\u0424\nn\3o\3o\3p"+
"\3p\3p\3p\3p\3p\3q\3q\3q\3q\3q\3q\5q\u0434\nq\3r\3r\3s\3s\5s\u043a\ns"+
"\3t\3t\3t\7t\u043f\nt\ft\16t\u0442\13t\3u\3u\3u\7u\u0447\nu\fu\16u\u044a"+
"\13u\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\5w\u0460"+
"\nw\3x\3x\3y\3y\3y\3y\3y\3y\3y\5y\u046b\ny\3y\3y\3y\3y\7y\u0471\ny\fy"+
"\16y\u0474\13y\7y\u0476\ny\fy\16y\u0479\13y\3z\3z\3z\3z\3z\7z\u0480\n"+
"z\fz\16z\u0483\13z\3{\3{\3{\3{\3{\3{\3{\5{\u048c\n{\3|\3|\3|\3|\3|\3|"+
"\3|\5|\u0495\n|\3}\3}\3}\3}\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\5~\u04c7\n~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~"+
"\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\5~\u059d\n~\3\177\3\177"+
"\3\177\3\177\3\177\3\177\3\177\5\177\u05a6\n\177\3\177\3\177\3\u0080\3"+
"\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\5\u0080\u05b1\n\u0080\3"+
"\u0080\3\u0080\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081"+
"\3\u0081\3\u0081\5\u0081\u05be\n\u0081\3\u0081\3\u0081\3\u0082\3\u0082"+
"\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084\5\u0084"+
"\u05cc\n\u0084\3\u0084\3\u0084\5\u0084\u05d0\n\u0084\3\u0084\3\u0084\3"+
"\u0084\3\u0084\5\u0084\u05d6\n\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3"+
"\u0084\3\u0084\5\u0084\u05de\n\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3"+
"\u0084\3\u0084\5\u0084\u05e6\n\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3"+
"\u0084\3\u0084\5\u0084\u05ee\n\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3"+
"\u0084\3\u0084\5\u0084\u05f6\n\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3"+
"\u0084\3\u0084\5\u0084\u05fe\n\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3"+
"\u0084\5\u0084\u0605\n\u0084\3\u0084\3\u0084\5\u0084\u0609\n\u0084\3\u0085"+
"\3\u0085\5\u0085\u060d\n\u0085\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086"+
"\u0613\n\u0086\3\u0087\3\u0087\3\u0087\5\u0087\u0618\n\u0087\3\u0088\3"+
"\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b\3\u008b\3\u008c\3\u008c"+
"\3\u008d\3\u008d\3\u008d\5\u008d\u0627\n\u008d\3\u008e\3\u008e\3\u008f"+
"\3\u008f\3\u008f\2\2\u0090\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$"+
"&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+
"\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c"+
"\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4"+
"\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc"+
"\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4"+
"\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc"+
"\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114"+
"\u0116\u0118\u011a\u011c\2\16\4\2\u0090\u0090\u00aa\u00aa\3\2\b\t\3\2"+
"\24\25\5\2||~~\u008e\u008e\3\2\u0094\u0095\3\2\u0097\u0099\3\2\u009a\u009c"+
"\3\2\u009d\u009f\3\2qr\3\2\u00a0\u00a3\3\2\u0091\u0092\4\2\u0093\u0093"+
"\u00a6\u00a6\2\u06aa\2\u011e\3\2\2\2\4\u0120\3\2\2\2\6\u0129\3\2\2\2\b"+
"\u012f\3\2\2\2\n\u0132\3\2\2\2\f\u0135\3\2\2\2\16\u0139\3\2\2\2\20\u0143"+
"\3\2\2\2\22\u0148\3\2\2\2\24\u015e\3\2\2\2\26\u0178\3\2\2\2\30\u018c\3"+
"\2\2\2\32\u0196\3\2\2\2\34\u019b\3\2\2\2\36\u019d\3\2\2\2 \u01a2\3\2\2"+
"\2\"\u01a5\3\2\2\2$\u01aa\3\2\2\2&\u01b5\3\2\2\2(\u01c7\3\2\2\2*\u01c9"+
"\3\2\2\2,\u01cf\3\2\2\2.\u01d1\3\2\2\2\60\u01de\3\2\2\2\62\u01e8\3\2\2"+
"\2\64\u01ea\3\2\2\2\66\u01ed\3\2\2\28\u01f2\3\2\2\2:\u01f4\3\2\2\2<\u0207"+
"\3\2\2\2>\u0209\3\2\2\2@\u0212\3\2\2\2B\u0218\3\2\2\2D\u021e\3\2\2\2F"+
"\u0224\3\2\2\2H\u022c\3\2\2\2J\u0234\3\2\2\2L\u023c\3\2\2\2N\u0240\3\2"+
"\2\2P\u0244\3\2\2\2R\u024a\3\2\2\2T\u025c\3\2\2\2V\u025f\3\2\2\2X\u0262"+
"\3\2\2\2Z\u026d\3\2\2\2\\\u026f\3\2\2\2^\u0276\3\2\2\2`\u0278\3\2\2\2"+
"b\u027c\3\2\2\2d\u0281\3\2\2\2f\u028f\3\2\2\2h\u0297\3\2\2\2j\u029e\3"+
"\2\2\2l\u02a6\3\2\2\2n\u02b4\3\2\2\2p\u02c3\3\2\2\2r\u02c5\3\2\2\2t\u02c8"+
"\3\2\2\2v\u02cc\3\2\2\2x\u02d3\3\2\2\2z\u02da\3\2\2\2|\u02df\3\2\2\2~"+
"\u02e1\3\2\2\2\u0080\u02f4\3\2\2\2\u0082\u030c\3\2\2\2\u0084\u030e\3\2"+
"\2\2\u0086\u0311\3\2\2\2\u0088\u0319\3\2\2\2\u008a\u031f\3\2\2\2\u008c"+
"\u0321\3\2\2\2\u008e\u0333\3\2\2\2\u0090\u0341\3\2\2\2\u0092\u0343\3\2"+
"\2\2\u0094\u0349\3\2\2\2\u0096\u0356\3\2\2\2\u0098\u0359\3\2\2\2\u009a"+
"\u035b\3\2\2\2\u009c\u036a\3\2\2\2\u009e\u036c\3\2\2\2\u00a0\u0376\3\2"+
"\2\2\u00a2\u0385\3\2\2\2\u00a4\u0387\3\2\2\2\u00a6\u038a\3\2\2\2\u00a8"+
"\u038e\3\2\2\2\u00aa\u039f\3\2\2\2\u00ac\u03a3\3\2\2\2\u00ae\u03a5\3\2"+
"\2\2\u00b0\u03ad\3\2\2\2\u00b2\u03af\3\2\2\2\u00b4\u03b1\3\2\2\2\u00b6"+
"\u03b9\3\2\2\2\u00b8\u03c1\3\2\2\2\u00ba\u03c8\3\2\2\2\u00bc\u03ca\3\2"+
"\2\2\u00be\u03d4\3\2\2\2\u00c0\u03e3\3\2\2\2\u00c2\u03ec\3\2\2\2\u00c4"+
"\u03ee\3\2\2\2\u00c6\u03f2\3\2\2\2\u00c8\u03f4\3\2\2\2\u00ca\u03fa\3\2"+
"\2\2\u00cc\u03fc\3\2\2\2\u00ce\u0400\3\2\2\2\u00d0\u0408\3\2\2\2\u00d2"+
"\u0412\3\2\2\2\u00d4\u0416\3\2\2\2\u00d6\u041a\3\2\2\2\u00d8\u041f\3\2"+
"\2\2\u00da\u0423\3\2\2\2\u00dc\u0425\3\2\2\2\u00de\u0427\3\2\2\2\u00e0"+
"\u0433\3\2\2\2\u00e2\u0435\3\2\2\2\u00e4\u0439\3\2\2\2\u00e6\u043b\3\2"+
"\2\2\u00e8\u0443\3\2\2\2\u00ea\u044b\3\2\2\2\u00ec\u044d\3\2\2\2\u00ee"+
"\u0461\3\2\2\2\u00f0\u0463\3\2\2\2\u00f2\u047a\3\2\2\2\u00f4\u048b\3\2"+
"\2\2\u00f6\u0494\3\2\2\2\u00f8\u0496\3\2\2\2\u00fa\u059c\3\2\2\2\u00fc"+
"\u059e\3\2\2\2\u00fe\u05a9\3\2\2\2\u0100\u05b4\3\2\2\2\u0102\u05c1\3\2"+
"\2\2\u0104\u05c4\3\2\2\2\u0106\u0608\3\2\2\2\u0108\u060a\3\2\2\2\u010a"+
"\u060e\3\2\2\2\u010c\u0617\3\2\2\2\u010e\u0619\3\2\2\2\u0110\u061b\3\2"+
"\2\2\u0112\u061d\3\2\2\2\u0114\u061f\3\2\2\2\u0116\u0621\3\2\2\2\u0118"+
"\u0626\3\2\2\2\u011a\u0628\3\2\2\2\u011c\u062a\3\2\2\2\u011e\u011f\5\4"+
"\3\2\u011f\3\3\2\2\2\u0120\u0125\5\b\5\2\u0121\u0126\5\16\b\2\u0122\u0126"+
"\5\24\13\2\u0123\u0126\5\26\f\2\u0124\u0126\5\30\r\2\u0125\u0121\3\2\2"+
"\2\u0125\u0122\3\2\2\2\u0125\u0123\3\2\2\2\u0125\u0124\3\2\2\2\u0126\u0127"+
"\3\2\2\2\u0127\u0128\58\35\2\u0128\5\3\2\2\2\u0129\u012a\5:\36\2\u012a"+
"\7\3\2\2\2\u012b\u012e\5\n\6\2\u012c\u012e\5\f\7\2\u012d\u012b\3\2\2\2"+
"\u012d\u012c\3\2\2\2\u012e\u0131\3\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130"+
"\3\2\2\2\u0130\t\3\2\2\2\u0131\u012f\3\2\2\2\u0132\u0133\7\5\2\2\u0133"+
"\u0134\t\2\2\2\u0134\13\3\2\2\2\u0135\u0136\7\6\2\2\u0136\u0137\7\u0091"+
"\2\2\u0137\u0138\t\2\2\2\u0138\r\3\2\2\2\u0139\u013d\5\22\n\2\u013a\u013c"+
"\5\32\16\2\u013b\u013a\3\2\2\2\u013c\u013f\3\2\2\2\u013d\u013b\3\2\2\2"+
"\u013d\u013e\3\2\2\2\u013e\u0140\3\2\2\2\u013f\u013d\3\2\2\2\u0140\u0141"+
"\5\"\22\2\u0141\u0142\5$\23\2\u0142\17\3\2\2\2\u0143\u0144\5\22\n\2\u0144"+
"\u0145\5\"\22\2\u0145\u0146\5$\23\2\u0146\u0147\58\35\2\u0147\21\3\2\2"+
"\2\u0148\u014a\7\7\2\2\u0149\u014b\t\3\2\2\u014a\u0149\3\2\2\2\u014a\u014b"+
"\3\2\2\2\u014b\u015c\3\2\2\2\u014c\u0158\5\u00dco\2\u014d\u014e\5\u00e2"+
"r\2\u014e\u014f\7-\2\2\u014f\u0150\5\u00dco\2\u0150\u0158\3\2\2\2\u0151"+
"\u0152\7\u0085\2\2\u0152\u0153\5\u00e2r\2\u0153\u0154\7-\2\2\u0154\u0155"+
"\5\u00dco\2\u0155\u0156\7\u0086\2\2\u0156\u0158\3\2\2\2\u0157\u014c\3"+
"\2\2\2\u0157\u014d\3\2\2\2\u0157\u0151\3\2\2\2\u0158\u0159\3\2\2\2\u0159"+
"\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015d\3\2\2\2\u015b\u015d\7~"+
"\2\2\u015c\u0157\3\2\2\2\u015c\u015b\3\2\2\2\u015d\23\3\2\2\2\u015e\u0176"+
"\7\n\2\2\u015f\u0163\5\u0092J\2\u0160\u0162\5\32\16\2\u0161\u0160\3\2"+
"\2\2\u0162\u0165\3\2\2\2\u0163\u0161\3\2\2\2\u0163\u0164\3\2\2\2\u0164"+
"\u0166\3\2\2\2\u0165\u0163\3\2\2\2\u0166\u0167\5\"\22\2\u0167\u0168\5"+
"$\23\2\u0168\u0177\3\2\2\2\u0169\u016b\5\32\16\2\u016a\u0169\3\2\2\2\u016b"+
"\u016e\3\2\2\2\u016c\u016a\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016f\3\2"+
"\2\2\u016e\u016c\3\2\2\2\u016f\u0170\7\13\2\2\u0170\u0172\7x\2\2\u0171"+
"\u0173\5h\65\2\u0172\u0171\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2"+
"\2\2\u0174\u0175\7y\2\2\u0175\u0177\5$\23\2\u0176\u015f\3\2\2\2\u0176"+
"\u016c\3\2\2\2\u0177\25\3\2\2\2\u0178\u017f\7\f\2\2\u0179\u017b\5\u00da"+
"n\2\u017a\u0179\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017a\3\2\2\2\u017c"+
"\u017d\3\2\2\2\u017d\u0180\3\2\2\2\u017e\u0180\7~\2\2\u017f\u017a\3\2"+
"\2\2\u017f\u017e\3\2\2\2\u0180\u0184\3\2\2\2\u0181\u0183\5\32\16\2\u0182"+
"\u0181\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0182\3\2\2\2\u0184\u0185\3\2"+
"\2\2\u0185\u0188\3\2\2\2\u0186\u0184\3\2\2\2\u0187\u0189\5\"\22\2\u0188"+
"\u0187\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u018b\5$"+
"\23\2\u018b\27\3\2\2\2\u018c\u0190\7\r\2\2\u018d\u018f\5\32\16\2\u018e"+
"\u018d\3\2\2\2\u018f\u0192\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u0191\3\2"+
"\2\2\u0191\u0193\3\2\2\2\u0192\u0190\3\2\2\2\u0193\u0194\5\"\22\2\u0194"+
"\u0195\5$\23\2\u0195\31\3\2\2\2\u0196\u0199\7\16\2\2\u0197\u019a\5\34"+
"\17\2\u0198\u019a\5\36\20\2\u0199\u0197\3\2\2\2\u0199\u0198\3\2\2\2\u019a"+
"\33\3\2\2\2\u019b\u019c\5 \21\2\u019c\35\3\2\2\2\u019d\u019e\7\17\2\2"+
"\u019e\u019f\5 \21\2\u019f\37\3\2\2\2\u01a0\u01a3\5\u0118\u008d\2\u01a1"+
"\u01a3\7\'\2\2\u01a2\u01a0\3\2\2\2\u01a2\u01a1\3\2\2\2\u01a3!\3\2\2\2"+
"\u01a4\u01a6\7\13\2\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a7"+
"\3\2\2\2\u01a7\u01a8\5j\66\2\u01a8#\3\2\2\2\u01a9\u01ab\5&\24\2\u01aa"+
"\u01a9\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ad\3\2\2\2\u01ac\u01ae\5*"+
"\26\2\u01ad\u01ac\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0\3\2\2\2\u01af"+
"\u01b1\5.\30\2\u01b0\u01af\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b3\3\2"+
"\2\2\u01b2\u01b4\5\62\32\2\u01b3\u01b2\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4"+
"%\3\2\2\2\u01b5\u01b6\7\20\2\2\u01b6\u01b8\7\21\2\2\u01b7\u01b9\5(\25"+
"\2\u01b8\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01b8\3\2\2\2\u01ba\u01bb"+
"\3\2\2\2\u01bb\'\3\2\2\2\u01bc\u01c8\5\u00fa~\2\u01bd\u01c8\5\u008cG\2"+
"\u01be\u01bf\7\u0085\2\2\u01bf\u01c2\5\u00e2r\2\u01c0\u01c1\7-\2\2\u01c1"+
"\u01c3\5\u00dco\2\u01c2\u01c0\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c4"+
"\3\2\2\2\u01c4\u01c5\7\u0086\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c8\5\u00dc"+
"o\2\u01c7\u01bc\3\2\2\2\u01c7\u01bd\3\2\2\2\u01c7\u01be\3\2\2\2\u01c7"+
"\u01c6\3\2\2\2\u01c8)\3\2\2\2\u01c9\u01cb\7\22\2\2\u01ca\u01cc\5,\27\2"+
"\u01cb\u01ca\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01cb\3\2\2\2\u01cd\u01ce"+
"\3\2\2\2\u01ce+\3\2\2\2\u01cf\u01d0\5\u008aF\2\u01d0-\3\2\2\2\u01d1\u01d2"+
"\7\23\2\2\u01d2\u01d4\7\21\2\2\u01d3\u01d5\5\60\31\2\u01d4\u01d3\3\2\2"+
"\2\u01d5\u01d6\3\2\2\2\u01d6\u01d4\3\2\2\2\u01d6\u01d7\3\2\2\2\u01d7/"+
"\3\2\2\2\u01d8\u01d9\t\4\2\2\u01d9\u01df\5\u00f8}\2\u01da\u01dd\5\u008a"+
"F\2\u01db\u01dd\5\u00dco\2\u01dc\u01da\3\2\2\2\u01dc\u01db\3\2\2\2\u01dd"+
"\u01df\3\2\2\2\u01de\u01d8\3\2\2\2\u01de\u01dc\3\2\2\2\u01df\61\3\2\2"+
"\2\u01e0\u01e2\5\64\33\2\u01e1\u01e3\5\66\34\2\u01e2\u01e1\3\2\2\2\u01e2"+
"\u01e3\3\2\2\2\u01e3\u01e9\3\2\2\2\u01e4\u01e6\5\66\34\2\u01e5\u01e7\5"+
"\64\33\2\u01e6\u01e5\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01e9\3\2\2\2\u01e8"+
"\u01e0\3\2\2\2\u01e8\u01e4\3\2\2\2\u01e9\63\3\2\2\2\u01ea\u01eb\7\26\2"+
"\2\u01eb\u01ec\7\u0097\2\2\u01ec\65\3\2\2\2\u01ed\u01ee\7\27\2\2\u01ee"+
"\u01ef\7\u0097\2\2\u01ef\67\3\2\2\2\u01f0\u01f1\7s\2\2\u01f1\u01f3\5|"+
"?\2\u01f2\u01f0\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f39\3\2\2\2\u01f4\u01fa"+
"\5\b\5\2\u01f5\u01f8\5<\37\2\u01f6\u01f7\7z\2\2\u01f7\u01f9\5:\36\2\u01f8"+
"\u01f6\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9\u01fb\3\2\2\2\u01fa\u01f5\3\2"+
"\2\2\u01fa\u01fb\3\2\2\2\u01fb;\3\2\2\2\u01fc\u0208\5> \2\u01fd\u0208"+
"\5@!\2\u01fe\u0208\5B\"\2\u01ff\u0208\5F$\2\u0200\u0208\5H%\2\u0201\u0208"+
"\5J&\2\u0202\u0208\5D#\2\u0203\u0208\5L\'\2\u0204\u0208\5N(\2\u0205\u0208"+
"\5P)\2\u0206\u0208\5R*\2\u0207\u01fc\3\2\2\2\u0207\u01fd\3\2\2\2\u0207"+
"\u01fe\3\2\2\2\u0207\u01ff\3\2\2\2\u0207\u0200\3\2\2\2\u0207\u0201\3\2"+
"\2\2\u0207\u0202\3\2\2\2\u0207\u0203\3\2\2\2\u0207\u0204\3\2\2\2\u0207"+
"\u0205\3\2\2\2\u0207\u0206\3\2\2\2\u0208=\3\2\2\2\u0209\u020b\7\30\2\2"+
"\u020a\u020c\7\31\2\2\u020b\u020a\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u020d"+
"\3\2\2\2\u020d\u0210\5\u0118\u008d\2\u020e\u020f\7\32\2\2\u020f\u0211"+
"\5\\/\2\u0210\u020e\3\2\2\2\u0210\u0211\3\2\2\2\u0211?\3\2\2\2\u0212\u0214"+
"\7\33\2\2\u0213\u0215\7\31\2\2\u0214\u0213\3\2\2\2\u0214\u0215\3\2\2\2"+
"\u0215\u0216\3\2\2\2\u0216\u0217\5^\60\2\u0217A\3\2\2\2\u0218\u021a\7"+
"\34\2\2\u0219\u021b\7\31\2\2\u021a\u0219\3\2\2\2\u021a\u021b\3\2\2\2\u021b"+
"\u021c\3\2\2\2\u021c\u021d\5^\60\2\u021dC\3\2\2\2\u021e\u0220\7\35\2\2"+
"\u021f\u0221\7\31\2\2\u0220\u021f\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0222"+
"\3\2\2\2\u0222\u0223\5\\/\2\u0223E\3\2\2\2\u0224\u0226\7\36\2\2\u0225"+
"\u0227\7\31\2\2\u0226\u0225\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\3"+
"\2\2\2\u0228\u0229\5Z.\2\u0229\u022a\7\37\2\2\u022a\u022b\5Z.\2\u022b"+
"G\3\2\2\2\u022c\u022e\7 \2\2\u022d\u022f\7\31\2\2\u022e\u022d\3\2\2\2"+
"\u022e\u022f\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0231\5Z.\2\u0231\u0232"+
"\7\37\2\2\u0232\u0233\5Z.\2\u0233I\3\2\2\2\u0234\u0236\7!\2\2\u0235\u0237"+
"\7\31\2\2\u0236\u0235\3\2\2\2\u0236\u0237\3\2\2\2\u0237\u0238\3\2\2\2"+
"\u0238\u0239\5Z.\2\u0239\u023a\7\37\2\2\u023a\u023b\5Z.\2\u023bK\3\2\2"+
"\2\u023c\u023d\7\"\2\2\u023d\u023e\7#\2\2\u023e\u023f\5b\62\2\u023fM\3"+
"\2\2\2\u0240\u0241\7$\2\2\u0241\u0242\7#\2\2\u0242\u0243\5b\62\2\u0243"+
"O\3\2\2\2\u0244\u0245\7$\2\2\u0245\u0246\7\13\2\2\u0246\u0247\5`\61\2"+
"\u0247Q\3\2\2\2\u0248\u0249\7%\2\2\u0249\u024b\5\u0118\u008d\2\u024a\u0248"+
"\3\2\2\2\u024a\u024b\3\2\2\2\u024b\u0251\3\2\2\2\u024c\u024e\5T+\2\u024d"+
"\u024f\5V,\2\u024e\u024d\3\2\2\2\u024e\u024f\3\2\2\2\u024f\u0252\3\2\2"+
"\2\u0250\u0252\5V,\2\u0251\u024c\3\2\2\2\u0251\u0250\3\2\2\2\u0252\u0256"+
"\3\2\2\2\u0253\u0255\5X-\2\u0254\u0253\3\2\2\2\u0255\u0258\3\2\2\2\u0256"+
"\u0254\3\2\2\2\u0256\u0257\3\2\2\2\u0257\u0259\3\2\2\2\u0258\u0256\3\2"+
"\2\2\u0259\u025a\7\13\2\2\u025a\u025b\5j\66\2\u025bS\3\2\2\2\u025c\u025d"+
"\7$\2\2\u025d\u025e\5`\61\2\u025eU\3\2\2\2\u025f\u0260\7\"\2\2\u0260\u0261"+
"\5`\61\2\u0261W\3\2\2\2\u0262\u0266\7&\2\2\u0263\u0267\5\u0118\u008d\2"+
"\u0264\u0265\7\17\2\2\u0265\u0267\5\u0118\u008d\2\u0266\u0263\3\2\2\2"+
"\u0266\u0264\3\2\2\2\u0267Y\3\2\2\2\u0268\u026e\7\'\2\2\u0269\u026b\7"+
"(\2\2\u026a\u0269\3\2\2\2\u026a\u026b\3\2\2\2\u026b\u026c\3\2\2\2\u026c"+
"\u026e\5\u0118\u008d\2\u026d\u0268\3\2\2\2\u026d\u026a\3\2\2\2\u026e["+
"\3\2\2\2\u026f\u0270\7(\2\2\u0270\u0271\5\u0118\u008d\2\u0271]\3\2\2\2"+
"\u0272\u0277\5\\/\2\u0273\u0277\7\'\2\2\u0274\u0277\7\17\2\2\u0275\u0277"+
"\7)\2\2\u0276\u0272\3\2\2\2\u0276\u0273\3\2\2\2\u0276\u0274\3\2\2\2\u0276"+
"\u0275\3\2\2\2\u0277_\3\2\2\2\u0278\u0279\7x\2\2\u0279\u027a\5d\63\2\u027a"+
"\u027b\7y\2\2\u027ba\3\2\2\2\u027c\u027d\7x\2\2\u027d\u027e\5d\63\2\u027e"+
"\u027f\7y\2\2\u027fc\3\2\2\2\u0280\u0282\5h\65\2\u0281\u0280\3\2\2\2\u0281"+
"\u0282\3\2\2\2\u0282\u028c\3\2\2\2\u0283\u0285\5f\64\2\u0284\u0286\7{"+
"\2\2\u0285\u0284\3\2\2\2\u0285\u0286\3\2\2\2\u0286\u0288\3\2\2\2\u0287"+
"\u0289\5h\65\2\u0288\u0287\3\2\2\2\u0288\u0289\3\2\2\2\u0289\u028b\3\2"+
"\2\2\u028a\u0283\3\2\2\2\u028b\u028e\3\2\2\2\u028c\u028a\3\2\2\2\u028c"+
"\u028d\3\2\2\2\u028de\3\2\2\2\u028e\u028c\3\2\2\2\u028f\u0290\7(\2\2\u0290"+
"\u0291\5\u00dan\2\u0291\u0293\7x\2\2\u0292\u0294\5h\65\2\u0293\u0292\3"+
"\2\2\2\u0293\u0294\3\2\2\2\u0294\u0295\3\2\2\2\u0295\u0296\7y\2\2\u0296"+
"g\3\2\2\2\u0297\u029c\5\u0096L\2\u0298\u029a\7{\2\2\u0299\u029b\5h\65"+
"\2\u029a\u0299\3\2\2\2\u029a\u029b\3\2\2\2\u029b\u029d\3\2\2\2\u029c\u0298"+
"\3\2\2\2\u029c\u029d\3\2\2\2\u029di\3\2\2\2\u029e\u02a1\7x\2\2\u029f\u02a2"+
"\5\20\t\2\u02a0\u02a2\5l\67\2\u02a1\u029f\3\2\2\2\u02a1\u02a0\3\2\2\2"+
"\u02a2\u02a3\3\2\2\2\u02a3\u02a4\7y\2\2\u02a4k\3\2\2\2\u02a5\u02a7\5n"+
"8\2\u02a6\u02a5\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02b1\3\2\2\2\u02a8"+
"\u02aa\5p9\2\u02a9\u02ab\7{\2\2\u02aa\u02a9\3\2\2\2\u02aa\u02ab\3\2\2"+
"\2\u02ab\u02ad\3\2\2\2\u02ac\u02ae\5n8\2\u02ad\u02ac\3\2\2\2\u02ad\u02ae"+
"\3\2\2\2\u02ae\u02b0\3\2\2\2\u02af\u02a8\3\2\2\2\u02b0\u02b3\3\2\2\2\u02b1"+
"\u02af\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2m\3\2\2\2\u02b3\u02b1\3\2\2\2"+
"\u02b4\u02b9\5\u00a2R\2\u02b5\u02b7\7{\2\2\u02b6\u02b8\5n8\2\u02b7\u02b6"+
"\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8\u02ba\3\2\2\2\u02b9\u02b5\3\2\2\2\u02b9"+
"\u02ba\3\2\2\2\u02bao\3\2\2\2\u02bb\u02c4\5\u0086D\2\u02bc\u02c4\5r:\2"+
"\u02bd\u02c4\5\u0084C\2\u02be\u02c4\5t;\2\u02bf\u02c4\5v<\2\u02c0\u02c4"+
"\5\u0088E\2\u02c1\u02c4\5x=\2\u02c2\u02c4\5z>\2\u02c3\u02bb\3\2\2\2\u02c3"+
"\u02bc\3\2\2\2\u02c3\u02bd\3\2\2\2\u02c3\u02be\3\2\2\2\u02c3\u02bf\3\2"+
"\2\2\u02c3\u02c0\3\2\2\2\u02c3\u02c1\3\2\2\2\u02c3\u02c2\3\2\2\2\u02c4"+
"q\3\2\2\2\u02c5\u02c6\7*\2\2\u02c6\u02c7\5j\66\2\u02c7s\3\2\2\2\u02c8"+
"\u02c9\7(\2\2\u02c9\u02ca\5\u00dan\2\u02ca\u02cb\5j\66\2\u02cbu\3\2\2"+
"\2\u02cc\u02ce\7+\2\2\u02cd\u02cf\7\31\2\2\u02ce\u02cd\3\2\2\2\u02ce\u02cf"+
"\3\2\2\2\u02cf\u02d0\3\2\2\2\u02d0\u02d1\5\u00dan\2\u02d1\u02d2\5j\66"+
"\2\u02d2w\3\2\2\2\u02d3\u02d4\7,\2\2\u02d4\u02d5\7\u0085\2\2\u02d5\u02d6"+
"\5\u00e4s\2\u02d6\u02d7\7-\2\2\u02d7\u02d8\5\u00dco\2\u02d8\u02d9\7\u0086"+
"\2\2\u02d9y\3\2\2\2\u02da\u02db\7s\2\2\u02db\u02dc\5|?\2\u02dc{\3\2\2"+
"\2\u02dd\u02e0\5~@\2\u02de\u02e0\5\u0080A\2\u02df\u02dd\3\2\2\2\u02df"+
"\u02de\3\2\2\2\u02e0}\3\2\2\2\u02e1\u02e2\5\u00dco\2\u02e2\u02e6\7x\2"+
"\2\u02e3\u02e5\5\u0082B\2\u02e4\u02e3\3\2\2\2\u02e5\u02e8\3\2\2\2\u02e6"+
"\u02e4\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e9\3\2\2\2\u02e8\u02e6\3\2"+
"\2\2\u02e9\u02ea\7y\2\2\u02ea\177\3\2\2\2\u02eb\u02f5\7\u00a4\2\2\u02ec"+
"\u02f0\7\u0085\2\2\u02ed\u02ef\5\u00dco\2\u02ee\u02ed\3\2\2\2\u02ef\u02f2"+
"\3\2\2\2\u02f0\u02ee\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1\u02f3\3\2\2\2\u02f2"+
"\u02f0\3\2\2\2\u02f3\u02f5\7\u0086\2\2\u02f4\u02eb\3\2\2\2\u02f4\u02ec"+
"\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u0302\7x\2\2\u02f7\u02fb\7\u0085\2"+
"\2\u02f8\u02fa\5\u0082B\2\u02f9\u02f8\3\2\2\2\u02fa\u02fd\3\2\2\2\u02fb"+
"\u02f9\3\2\2\2\u02fb\u02fc\3\2\2\2\u02fc\u02fe\3\2\2\2\u02fd\u02fb\3\2"+
"\2\2\u02fe\u0301\7\u0086\2\2\u02ff\u0301\7\u00a4\2\2\u0300\u02f7\3\2\2"+
"\2\u0300\u02ff\3\2\2\2\u0301\u0304\3\2\2\2\u0302\u0300\3\2\2\2\u0302\u0303"+
"\3\2\2\2\u0303\u0305\3\2\2\2\u0304\u0302\3\2\2\2\u0305\u0306\7y\2\2\u0306"+
"\u0081\3\2\2\2\u0307\u030d\5\u0118\u008d\2\u0308\u030d\5\u010a\u0086\2"+
"\u0309\u030d\5\u010c\u0087\2\u030a\u030d\5\u0114\u008b\2\u030b\u030d\7"+
".\2\2\u030c\u0307\3\2\2\2\u030c\u0308\3\2\2\2\u030c\u0309\3\2\2\2\u030c"+
"\u030a\3\2\2\2\u030c\u030b\3\2\2\2\u030d\u0083\3\2\2\2\u030e\u030f\7/"+
"\2\2\u030f\u0310\5j\66\2\u0310\u0085\3\2\2\2\u0311\u0316\5j\66\2\u0312"+
"\u0313\7\60\2\2\u0313\u0315\5j\66\2\u0314\u0312\3\2\2\2\u0315\u0318\3"+
"\2\2\2\u0316\u0314\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0087\3\2\2\2\u0318"+
"\u0316\3\2\2\2\u0319\u031a\7\61\2\2\u031a\u031b\5\u008aF\2\u031b\u0089"+
"\3\2\2\2\u031c\u0320\5\u00f8}\2\u031d\u0320\5\u00fa~\2\u031e\u0320\5\u008c"+
"G\2\u031f\u031c\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u031e\3\2\2\2\u0320"+
"\u008b\3\2\2\2\u0321\u0322\5\u0118\u008d\2\u0322\u0323\5\u008eH\2\u0323"+
"\u008d\3\2\2\2\u0324\u0334\7\u00a4\2\2\u0325\u0327\7\u0085\2\2\u0326\u0328"+
"\7\b\2\2\u0327\u0326\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0329\3\2\2\2\u0329"+
"\u032e\5\u00e2r\2\u032a\u032b\7\177\2\2\u032b\u032d\5\u00e2r\2\u032c\u032a"+
"\3\2\2\2\u032d\u0330\3\2\2\2\u032e\u032c\3\2\2\2\u032e\u032f\3\2\2\2\u032f"+
"\u0331\3\2\2\2\u0330\u032e\3\2\2\2\u0331\u0332\7\u0086\2\2\u0332\u0334"+
"\3\2\2\2\u0333\u0324\3\2\2\2\u0333\u0325\3\2\2\2\u0334\u008f\3\2\2\2\u0335"+
"\u0342\7\u00a4\2\2\u0336\u0337\7\u0085\2\2\u0337\u033c\5\u00e2r\2\u0338"+
"\u0339\7\177\2\2\u0339\u033b\5\u00e2r\2\u033a\u0338\3\2\2\2\u033b\u033e"+
"\3\2\2\2\u033c\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033f\3\2\2\2\u033e"+
"\u033c\3\2\2\2\u033f\u0340\7\u0086\2\2\u0340\u0342\3\2\2\2\u0341\u0335"+
"\3\2\2\2\u0341\u0336\3\2\2\2\u0342\u0091\3\2\2\2\u0343\u0345\7x\2\2\u0344"+
"\u0346\5\u0094K\2\u0345\u0344\3\2\2\2\u0345\u0346\3\2\2\2\u0346\u0347"+
"\3\2\2\2\u0347\u0348\7y\2\2\u0348\u0093\3\2\2\2\u0349\u034e\5\u0096L\2"+
"\u034a\u034c\7{\2\2\u034b\u034d\5\u0094K\2\u034c\u034b\3\2\2\2\u034c\u034d"+
"\3\2\2\2\u034d\u034f\3\2\2\2\u034e\u034a\3\2\2\2\u034e\u034f\3\2\2\2\u034f"+
"\u0095\3\2\2\2\u0350\u0351\5\u00d8m\2\u0351\u0352\5\u009aN\2\u0352\u0357"+
"\3\2\2\2\u0353\u0354\5\u00c6d\2\u0354\u0355\5\u0098M\2\u0355\u0357\3\2"+
"\2\2\u0356\u0350\3\2\2\2\u0356\u0353\3\2\2\2\u0357\u0097\3\2\2\2\u0358"+
"\u035a\5\u009aN\2\u0359\u0358\3\2\2\2\u0359\u035a\3\2\2\2\u035a\u0099"+
"\3\2\2\2\u035b\u035c\5\u009cO\2\u035c\u0365\5\u009eP\2\u035d\u0361\7z"+
"\2\2\u035e\u035f\5\u009cO\2\u035f\u0360\5\u009eP\2\u0360\u0362\3\2\2\2"+
"\u0361\u035e\3\2\2\2\u0361\u0362\3\2\2\2\u0362\u0364\3\2\2\2\u0363\u035d"+
"\3\2\2\2\u0364\u0367\3\2\2\2\u0365\u0363\3\2\2\2\u0365\u0366\3\2\2\2\u0366"+
"\u009b\3\2\2\2\u0367\u0365\3\2\2\2\u0368\u036b\5\u00dan\2\u0369\u036b"+
"\7\62\2\2\u036a\u0368\3\2\2\2\u036a\u0369\3\2\2\2\u036b\u009d\3\2\2\2"+
"\u036c\u0371\5\u00a0Q\2\u036d\u036e\7\177\2\2\u036e\u0370\5\u00a0Q\2\u036f"+
"\u036d\3\2\2\2\u0370\u0373\3\2\2\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2"+
"\2\2\u0372\u009f\3\2\2\2\u0373\u0371\3\2\2\2\u0374\u0377\5\u00d2j\2\u0375"+
"\u0377\5\u00dep\2\u0376\u0374\3\2\2\2\u0376\u0375\3\2\2\2\u0377\u00a1"+
"\3\2\2\2\u0378\u0386\5\u00a4S\2\u0379\u037a\5\u00dep\2\u037a\u037b\5\u00a8"+
"U\2\u037b\u0386\3\2\2\2\u037c\u037e\5\u00d6l\2\u037d\u037c\3\2\2\2\u037d"+
"\u037e\3\2\2\2\u037e\u037f\3\2\2\2\u037f\u0380\5\u00d6l\2\u0380\u0381"+
"\5\u00a8U\2\u0381\u0386\3\2\2\2\u0382\u0383\5\u00caf\2\u0383\u0384\5\u00a6"+
"T\2\u0384\u0386\3\2\2\2\u0385\u0378\3\2\2\2\u0385\u0379\3\2\2\2\u0385"+
"\u037d\3\2\2\2\u0385\u0382\3\2\2\2\u0386\u00a3\3\2\2\2\u0387\u0388\5\u00dc"+
"o\2\u0388\u00a5\3\2\2\2\u0389\u038b\5\u00a8U\2\u038a\u0389\3\2\2\2\u038a"+
"\u038b\3\2\2\2\u038b\u00a7\3\2\2\2\u038c\u038f\5\u00aaV\2\u038d\u038f"+
"\5\u00acW\2\u038e\u038c\3\2\2\2\u038e\u038d\3\2\2\2\u038f\u0390\3\2\2"+
"\2\u0390\u039c\5\u00aeX\2\u0391\u0398\7z\2\2\u0392\u0395\5\u00aaV\2\u0393"+
"\u0395\5\u00acW\2\u0394\u0392\3\2\2\2\u0394\u0393\3\2\2\2\u0395\u0396"+
"\3\2\2\2\u0396\u0397\5\u009eP\2\u0397\u0399\3\2\2\2\u0398\u0394\3\2\2"+
"\2\u0398\u0399\3\2\2\2\u0399\u039b\3\2\2\2\u039a\u0391\3\2\2\2\u039b\u039e"+
"\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u00a9\3\2\2\2\u039e"+
"\u039c\3\2\2\2\u039f\u03a0\5\u00b2Z\2\u03a0\u00ab\3\2\2\2\u03a1\u03a4"+
"\5\u00dco\2\u03a2\u03a4\7\u00a4\2\2\u03a3\u03a1\3\2\2\2\u03a3\u03a2\3"+
"\2\2\2\u03a4\u00ad\3\2\2\2\u03a5\u03aa\5\u00b0Y\2\u03a6\u03a7\7\177\2"+
"\2\u03a7\u03a9\5\u00b0Y\2\u03a8\u03a6\3\2\2\2\u03a9\u03ac\3\2\2\2\u03aa"+
"\u03a8\3\2\2\2\u03aa\u03ab\3\2\2\2\u03ab\u00af\3\2\2\2\u03ac\u03aa\3\2"+
"\2\2\u03ad\u03ae\5\u00d4k\2\u03ae\u00b1\3\2\2\2\u03af\u03b0\5\u00b4[\2"+
"\u03b0\u00b3\3\2\2\2\u03b1\u03b6\5\u00b6\\\2\u03b2\u03b3\7\u008c\2\2\u03b3"+
"\u03b5\5\u00b6\\\2\u03b4\u03b2\3\2\2\2\u03b5\u03b8\3\2\2\2\u03b6\u03b4"+
"\3\2\2\2\u03b6\u03b7\3\2\2\2\u03b7\u00b5\3\2\2\2\u03b8\u03b6\3\2\2\2\u03b9"+
"\u03be\5\u00ba^\2\u03ba\u03bb\7\u0081\2\2\u03bb\u03bd\5\u00ba^\2\u03bc"+
"\u03ba\3\2\2\2\u03bd\u03c0\3\2\2\2\u03be\u03bc\3\2\2\2\u03be\u03bf\3\2"+
"\2\2\u03bf\u00b7\3\2\2\2\u03c0\u03be\3\2\2\2\u03c1\u03c3\5\u00be`\2\u03c2"+
"\u03c4\5\u00bc_\2\u03c3\u03c2\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4\u00b9"+
"\3\2\2\2\u03c5\u03c9\5\u00b8]\2\u03c6\u03c7\7\u008d\2\2\u03c7\u03c9\5"+
"\u00b8]\2\u03c8\u03c5\3\2\2\2\u03c8\u03c6\3\2\2\2\u03c9\u00bb\3\2\2\2"+
"\u03ca\u03cb\t\5\2\2\u03cb\u00bd\3\2\2\2\u03cc\u03d5\5\u0118\u008d\2\u03cd"+
"\u03d5\7\62\2\2\u03ce\u03cf\7\u0080\2\2\u03cf\u03d5\5\u00c0a\2\u03d0\u03d1"+
"\7\u0085\2\2\u03d1\u03d2\5\u00b2Z\2\u03d2\u03d3\7\u0086\2\2\u03d3\u03d5"+
"\3\2\2\2\u03d4\u03cc\3\2\2\2\u03d4\u03cd\3\2\2\2\u03d4\u03ce\3\2\2\2\u03d4"+
"\u03d0\3\2\2\2\u03d5\u00bf\3\2\2\2\u03d6\u03e4\5\u00c2b\2\u03d7\u03e0"+
"\7\u0085\2\2\u03d8\u03dd\5\u00c2b\2\u03d9\u03da\7\u008c\2\2\u03da\u03dc"+
"\5\u00c2b\2\u03db\u03d9\3\2\2\2\u03dc\u03df\3\2\2\2\u03dd\u03db\3\2\2"+
"\2\u03dd\u03de\3\2\2\2\u03de\u03e1\3\2\2\2\u03df\u03dd\3\2\2\2\u03e0\u03d8"+
"\3\2\2\2\u03e0\u03e1\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u03e4\7\u0086\2"+
"\2\u03e3\u03d6\3\2\2\2\u03e3\u03d7\3\2\2\2\u03e4\u00c1\3\2\2\2\u03e5\u03ed"+
"\5\u0118\u008d\2\u03e6\u03ed\7\62\2\2\u03e7\u03ea\7\u008d\2\2\u03e8\u03eb"+
"\5\u0118\u008d\2\u03e9\u03eb\7\62\2\2\u03ea\u03e8\3\2\2\2\u03ea\u03e9"+
"\3\2\2\2\u03eb\u03ed\3\2\2\2\u03ec\u03e5\3\2\2\2\u03ec\u03e6\3\2\2\2\u03ec"+
"\u03e7\3\2\2\2\u03ed\u00c3\3\2\2\2\u03ee\u03ef\7\u0097\2\2\u03ef\u00c5"+
"\3\2\2\2\u03f0\u03f3\5\u00ceh\2\u03f1\u03f3\5\u00c8e\2\u03f2\u03f0\3\2"+
"\2\2\u03f2\u03f1\3\2\2\2\u03f3\u00c7\3\2\2\2\u03f4\u03f5\7\u008a\2\2\u03f5"+
"\u03f6\5\u009aN\2\u03f6\u03f7\7\u008b\2\2\u03f7\u00c9\3\2\2\2\u03f8\u03fb"+
"\5\u00d0i\2\u03f9\u03fb\5\u00ccg\2\u03fa\u03f8\3\2\2\2\u03fa\u03f9\3\2"+
"\2\2\u03fb\u00cb\3\2\2\2\u03fc\u03fd\7\u008a\2\2\u03fd\u03fe\5\u00a8U"+
"\2\u03fe\u03ff\7\u008b\2\2\u03ff\u00cd\3\2\2\2\u0400\u0402\7\u0085\2\2"+
"\u0401\u0403\5\u00d2j\2\u0402\u0401\3\2\2\2\u0403\u0404\3\2\2\2\u0404"+
"\u0402\3\2\2\2\u0404\u0405\3\2\2\2\u0405\u0406\3\2\2\2\u0406\u0407\7\u0086"+
"\2\2\u0407\u00cf\3\2\2\2\u0408\u040a\7\u0085\2\2\u0409\u040b\5\u00d4k"+
"\2\u040a\u0409\3\2\2\2\u040b\u040c\3\2\2\2\u040c\u040a\3\2\2\2\u040c\u040d"+
"\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u040f\7\u0086\2\2\u040f\u00d1\3\2\2"+
"\2\u0410\u0413\5\u00d6l\2\u0411\u0413\5\u00c6d\2\u0412\u0410\3\2\2\2\u0412"+
"\u0411\3\2\2\2\u0413\u00d3\3\2\2\2\u0414\u0417\5\u00d8m\2\u0415\u0417"+
"\5\u00caf\2\u0416\u0414\3\2\2\2\u0416\u0415\3\2\2\2\u0417\u00d5\3\2\2"+
"\2\u0418\u041b\5\u00dco\2\u0419\u041b\5\u00e0q\2\u041a\u0418\3\2\2\2\u041a"+
"\u0419\3\2\2\2\u041b\u00d7\3\2\2\2\u041c\u0420\5\u00dco\2\u041d\u0420"+
"\5\u00e0q\2\u041e\u0420\5\u00dep\2\u041f\u041c\3\2\2\2\u041f\u041d\3\2"+
"\2\2\u041f\u041e\3\2\2\2\u0420\u00d9\3\2\2\2\u0421\u0424\5\u00dco\2\u0422"+
"\u0424\5\u0118\u008d\2\u0423\u0421\3\2\2\2\u0423\u0422\3\2\2\2\u0424\u00db"+
"\3\2\2\2\u0425\u0426\t\6\2\2\u0426\u00dd\3\2\2\2\u0427\u0428\7\3\2\2\u0428"+
"\u0429\5\u00d8m\2\u0429\u042a\5\u009cO\2\u042a\u042b\5\u00d8m\2\u042b"+
"\u042c\7\4\2\2\u042c\u00df\3\2\2\2\u042d\u0434\5\u0118\u008d\2\u042e\u0434"+
"\5\u010a\u0086\2\u042f\u0434\5\u010c\u0087\2\u0430\u0434\5\u0114\u008b"+
"\2\u0431\u0434\5\u011c\u008f\2\u0432\u0434\7\u00a4\2\2\u0433\u042d\3\2"+
"\2\2\u0433\u042e\3\2\2\2\u0433\u042f\3\2\2\2\u0433\u0430\3\2\2\2\u0433"+
"\u0431\3\2\2\2\u0433\u0432\3\2\2\2\u0434\u00e1\3\2\2\2\u0435\u0436\5\u00e6"+
"t\2\u0436\u00e3\3\2\2\2\u0437\u043a\5\u00e2r\2\u0438\u043a\5\u00dep\2"+
"\u0439\u0437\3\2\2\2\u0439\u0438\3\2\2\2\u043a\u00e5\3\2\2\2\u043b\u0440"+
"\5\u00e8u\2\u043c\u043d\7w\2\2\u043d\u043f\5\u00e8u\2\u043e\u043c\3\2"+
"\2\2\u043f\u0442\3\2\2\2\u0440\u043e\3\2\2\2\u0440\u0441\3\2\2\2\u0441"+
"\u00e7\3\2\2\2\u0442\u0440\3\2\2\2\u0443\u0448\5\u00eav\2\u0444\u0445"+
"\7v\2\2\u0445\u0447\5\u00eav\2\u0446\u0444\3\2\2\2\u0447\u044a\3\2\2\2"+
"\u0448\u0446\3\2\2\2\u0448\u0449\3\2\2\2\u0449\u00e9\3\2\2\2\u044a\u0448"+
"\3\2\2\2\u044b\u044c\5\u00ecw\2\u044c\u00eb\3\2\2\2\u044d\u045f\5\u00ee"+
"x\2\u044e\u044f\7\u0082\2\2\u044f\u0460\5\u00eex\2\u0450\u0451\7\u0089"+
"\2\2\u0451\u0460\5\u00eex\2\u0452\u0453\7\u0083\2\2\u0453\u0460\5\u00ee"+
"x\2\u0454\u0455\7\u0084\2\2\u0455\u0460\5\u00eex\2\u0456\u0457\7\u0087"+
"\2\2\u0457\u0460\5\u00eex\2\u0458\u0459\7\u0088\2\2\u0459\u0460\5\u00ee"+
"x\2\u045a\u045b\7\64\2\2\u045b\u0460\5\u0090I\2\u045c\u045d\7\63\2\2\u045d"+
"\u045e\7\64\2\2\u045e\u0460\5\u0090I\2\u045f\u044e\3\2\2\2\u045f\u0450"+
"\3\2\2\2\u045f\u0452\3\2\2\2\u045f\u0454\3\2\2\2\u045f\u0456\3\2\2\2\u045f"+
"\u0458\3\2\2\2\u045f\u045a\3\2\2\2\u045f\u045c\3\2\2\2\u045f\u0460\3\2"+
"\2\2\u0460\u00ed\3\2\2\2\u0461\u0462\5\u00f0y\2\u0462\u00ef\3\2\2\2\u0463"+
"\u0477\5\u00f2z\2\u0464\u0465\7|\2\2\u0465\u0476\5\u00f2z\2\u0466\u0467"+
"\7}\2\2\u0467\u0476\5\u00f2z\2\u0468\u046b\5\u0110\u0089\2\u0469\u046b"+
"\5\u0112\u008a\2\u046a\u0468\3\2\2\2\u046a\u0469\3\2\2\2\u046b\u0472\3"+
"\2\2\2\u046c\u046d\7~\2\2\u046d\u0471\5\u00f4{\2\u046e\u046f\7\u0081\2"+
"\2\u046f\u0471\5\u00f4{\2\u0470\u046c\3\2\2\2\u0470\u046e\3\2\2\2\u0471"+
"\u0474\3\2\2\2\u0472\u0470\3\2\2\2\u0472\u0473\3\2\2\2\u0473\u0476\3\2"+
"\2\2\u0474\u0472\3\2\2\2\u0475\u0464\3\2\2\2\u0475\u0466\3\2\2\2\u0475"+
"\u046a\3\2\2\2\u0476\u0479\3\2\2\2\u0477\u0475\3\2\2\2\u0477\u0478\3\2"+
"\2\2\u0478\u00f1\3\2\2\2\u0479\u0477\3\2\2\2\u047a\u0481\5\u00f4{\2\u047b"+
"\u047c\7~\2\2\u047c\u0480\5\u00f4{\2\u047d\u047e\7\u0081\2\2\u047e\u0480"+
"\5\u00f4{\2\u047f\u047b\3\2\2\2\u047f\u047d\3\2\2\2\u0480\u0483\3\2\2"+
"\2\u0481\u047f\3\2\2\2\u0481\u0482\3\2\2\2\u0482\u00f3\3\2\2\2\u0483\u0481"+
"\3\2\2\2\u0484\u0485\7\u0080\2\2\u0485\u048c\5\u00f6|\2\u0486\u0487\7"+
"|\2\2\u0487\u048c\5\u00f6|\2\u0488\u0489\7}\2\2\u0489\u048c\5\u00f6|\2"+
"\u048a\u048c\5\u00f6|\2\u048b\u0484\3\2\2\2\u048b\u0486\3\2\2\2\u048b"+
"\u0488\3\2\2\2\u048b\u048a\3\2\2\2\u048c\u00f5\3\2\2\2\u048d\u0495\5\u00f8"+
"}\2\u048e\u0495\5\u00fa~\2\u048f\u0495\5\u0108\u0085\2\u0490\u0495\5\u010a"+
"\u0086\2\u0491\u0495\5\u010c\u0087\2\u0492\u0495\5\u0114\u008b\2\u0493"+
"\u0495\5\u00dco\2\u0494\u048d\3\2\2\2\u0494\u048e\3\2\2\2\u0494\u048f"+
"\3\2\2\2\u0494\u0490\3\2\2\2\u0494\u0491\3\2\2\2\u0494\u0492\3\2\2\2\u0494"+
"\u0493\3\2\2\2\u0495\u00f7\3\2\2\2\u0496\u0497\7\u0085\2\2\u0497\u0498"+
"\5\u00e2r\2\u0498\u0499\7\u0086\2\2\u0499\u00f9\3\2\2\2\u049a\u059d\5"+
"\u0106\u0084\2\u049b\u049c\7\65\2\2\u049c\u049d\7\u0085\2\2\u049d\u049e"+
"\5\u00e2r\2\u049e\u049f\7\u0086\2\2\u049f\u059d\3\2\2\2\u04a0\u04a1\7"+
"\66\2\2\u04a1\u04a2\7\u0085\2\2\u04a2\u04a3\5\u00e2r\2\u04a3\u04a4\7\u0086"+
"\2\2\u04a4\u059d\3\2\2\2\u04a5\u04a6\7\67\2\2\u04a6\u04a7\7\u0085\2\2"+
"\u04a7\u04a8\5\u00e2r\2\u04a8\u04a9\7\177\2\2\u04a9\u04aa\5\u00e2r\2\u04aa"+
"\u04ab\7\u0086\2\2\u04ab\u059d\3\2\2\2\u04ac\u04ad\78\2\2\u04ad\u04ae"+
"\7\u0085\2\2\u04ae\u04af\5\u00e2r\2\u04af\u04b0\7\u0086\2\2\u04b0\u059d"+
"\3\2\2\2\u04b1\u04b2\79\2\2\u04b2\u04b3\7\u0085\2\2\u04b3\u04b4\5\u00dc"+
"o\2\u04b4\u04b5\7\u0086\2\2\u04b5\u059d\3\2\2\2\u04b6\u04b7\7:\2\2\u04b7"+
"\u04b8\7\u0085\2\2\u04b8\u04b9\5\u00e2r\2\u04b9\u04ba\7\u0086\2\2\u04ba"+
"\u059d\3\2\2\2\u04bb\u04bc\7;\2\2\u04bc\u04bd\7\u0085\2\2\u04bd\u04be"+
"\5\u00e2r\2\u04be\u04bf\7\u0086\2\2\u04bf\u059d\3\2\2\2\u04c0\u04c6\7"+
"<\2\2\u04c1\u04c2\7\u0085\2\2\u04c2\u04c3\5\u00e2r\2\u04c3\u04c4\7\u0086"+
"\2\2\u04c4\u04c7\3\2\2\2\u04c5\u04c7\7\u00a4\2\2\u04c6\u04c1\3\2\2\2\u04c6"+
"\u04c5\3\2\2\2\u04c7\u059d\3\2\2\2\u04c8\u04c9\7=\2\2\u04c9\u059d\7\u00a4"+
"\2\2\u04ca\u04cb\7>\2\2\u04cb\u04cc\7\u0085\2\2\u04cc\u04cd\5\u00e2r\2"+
"\u04cd\u04ce\7\u0086\2\2\u04ce\u059d\3\2\2\2\u04cf\u04d0\7?\2\2\u04d0"+
"\u04d1\7\u0085\2\2\u04d1\u04d2\5\u00e2r\2\u04d2\u04d3\7\u0086\2\2\u04d3"+
"\u059d\3\2\2\2\u04d4\u04d5\7@\2\2\u04d5\u04d6\7\u0085\2\2\u04d6\u04d7"+
"\5\u00e2r\2\u04d7\u04d8\7\u0086\2\2\u04d8\u059d\3\2\2\2\u04d9\u04da\7"+
"A\2\2\u04da\u04db\7\u0085\2\2\u04db\u04dc\5\u00e2r\2\u04dc\u04dd\7\u0086"+
"\2\2\u04dd\u059d\3\2\2\2\u04de\u04df\7B\2\2\u04df\u059d\5\u0090I\2\u04e0"+
"\u059d\5\u00fe\u0080\2\u04e1\u04e2\7C\2\2\u04e2\u04e3\7\u0085\2\2\u04e3"+
"\u04e4\5\u00e2r\2\u04e4\u04e5\7\u0086\2\2\u04e5\u059d\3\2\2\2\u04e6\u059d"+
"\5\u0100\u0081\2\u04e7\u04e8\7D\2\2\u04e8\u04e9\7\u0085\2\2\u04e9\u04ea"+
"\5\u00e2r\2\u04ea\u04eb\7\u0086\2\2\u04eb\u059d\3\2\2\2\u04ec\u04ed\7"+
"E\2\2\u04ed\u04ee\7\u0085\2\2\u04ee\u04ef\5\u00e2r\2\u04ef\u04f0\7\u0086"+
"\2\2\u04f0\u059d\3\2\2\2\u04f1\u04f2\7F\2\2\u04f2\u04f3\7\u0085\2\2\u04f3"+
"\u04f4\5\u00e2r\2\u04f4\u04f5\7\u0086\2\2\u04f5\u059d\3\2\2\2\u04f6\u04f7"+
"\7G\2\2\u04f7\u04f8\7\u0085\2\2\u04f8\u04f9\5\u00e2r\2\u04f9\u04fa\7\177"+
"\2\2\u04fa\u04fb\5\u00e2r\2\u04fb\u04fc\7\u0086\2\2\u04fc\u059d\3\2\2"+
"\2\u04fd\u04fe\7H\2\2\u04fe\u04ff\7\u0085\2\2\u04ff\u0500\5\u00e2r\2\u0500"+
"\u0501\7\177\2\2\u0501\u0502\5\u00e2r\2\u0502\u0503\7\u0086\2\2\u0503"+
"\u059d\3\2\2\2\u0504\u0505\7I\2\2\u0505\u0506\7\u0085\2\2\u0506\u0507"+
"\5\u00e2r\2\u0507\u0508\7\177\2\2\u0508\u0509\5\u00e2r\2\u0509\u050a\7"+
"\u0086\2\2\u050a\u059d\3\2\2\2\u050b\u050c\7J\2\2\u050c\u050d\7\u0085"+
"\2\2\u050d\u050e\5\u00e2r\2\u050e\u050f\7\177\2\2\u050f\u0510\5\u00e2"+
"r\2\u0510\u0511\7\u0086\2\2\u0511\u059d\3\2\2\2\u0512\u0513\7K\2\2\u0513"+
"\u0514\7\u0085\2\2\u0514\u0515\5\u00e2r\2\u0515\u0516\7\177\2\2\u0516"+
"\u0517\5\u00e2r\2\u0517\u0518\7\u0086\2\2\u0518\u059d\3\2\2\2\u0519\u051a"+
"\7L\2\2\u051a\u051b\7\u0085\2\2\u051b\u051c\5\u00e2r\2\u051c\u051d\7\u0086"+
"\2\2\u051d\u059d\3\2\2\2\u051e\u051f\7M\2\2\u051f\u0520\7\u0085\2\2\u0520"+
"\u0521\5\u00e2r\2\u0521\u0522\7\u0086\2\2\u0522\u059d\3\2\2\2\u0523\u0524"+
"\7N\2\2\u0524\u0525\7\u0085\2\2\u0525\u0526\5\u00e2r\2\u0526\u0527\7\u0086"+
"\2\2\u0527\u059d\3\2\2\2\u0528\u0529\7O\2\2\u0529\u052a\7\u0085\2\2\u052a"+
"\u052b\5\u00e2r\2\u052b\u052c\7\u0086\2\2\u052c\u059d\3\2\2\2\u052d\u052e"+
"\7P\2\2\u052e\u052f\7\u0085\2\2\u052f\u0530\5\u00e2r\2\u0530\u0531\7\u0086"+
"\2\2\u0531\u059d\3\2\2\2\u0532\u0533\7Q\2\2\u0533\u0534\7\u0085\2\2\u0534"+
"\u0535\5\u00e2r\2\u0535\u0536\7\u0086\2\2\u0536\u059d\3\2\2\2\u0537\u0538"+
"\7R\2\2\u0538\u0539\7\u0085\2\2\u0539\u053a\5\u00e2r\2\u053a\u053b\7\u0086"+
"\2\2\u053b\u059d\3\2\2\2\u053c\u053d\7S\2\2\u053d\u053e\7\u0085\2\2\u053e"+
"\u053f\5\u00e2r\2\u053f\u0540\7\u0086\2\2\u0540\u059d\3\2\2\2\u0541\u0542"+
"\7T\2\2\u0542\u059d\7\u00a4\2\2\u0543\u0544\7U\2\2\u0544\u059d\7\u00a4"+
"\2\2\u0545\u0546\7V\2\2\u0546\u059d\7\u00a4\2\2\u0547\u0548\7W\2\2\u0548"+
"\u0549\7\u0085\2\2\u0549\u054a\5\u00e2r\2\u054a\u054b\7\u0086\2\2\u054b"+
"\u059d\3\2\2\2\u054c\u054d\7X\2\2\u054d\u054e\7\u0085\2\2\u054e\u054f"+
"\5\u00e2r\2\u054f\u0550\7\u0086\2\2\u0550\u059d\3\2\2\2\u0551\u0552\7"+
"Y\2\2\u0552\u0553\7\u0085\2\2\u0553\u0554\5\u00e2r\2\u0554\u0555\7\u0086"+
"\2\2\u0555\u059d\3\2\2\2\u0556\u0557\7Z\2\2\u0557\u0558\7\u0085\2\2\u0558"+
"\u0559\5\u00e2r\2\u0559\u055a\7\u0086\2\2\u055a\u059d\3\2\2\2\u055b\u055c"+
"\7[\2\2\u055c\u055d\7\u0085\2\2\u055d\u055e\5\u00e2r\2\u055e\u055f\7\u0086"+
"\2\2\u055f\u059d\3\2\2\2\u0560\u0561\7\\\2\2\u0561\u059d\5\u0090I\2\u0562"+
"\u0563\7]\2\2\u0563\u0564\7\u0085\2\2\u0564\u0565\5\u00e2r\2\u0565\u0566"+
"\7\177\2\2\u0566\u0567\5\u00e2r\2\u0567\u0568\7\177\2\2\u0568\u0569\5"+
"\u00e2r\2\u0569\u056a\7\u0086\2\2\u056a\u059d\3\2\2\2\u056b\u056c\7^\2"+
"\2\u056c\u056d\7\u0085\2\2\u056d\u056e\5\u00e2r\2\u056e\u056f\7\177\2"+
"\2\u056f\u0570\5\u00e2r\2\u0570\u0571\7\u0086\2\2\u0571\u059d\3\2\2\2"+
"\u0572\u0573\7_\2\2\u0573\u0574\7\u0085\2\2\u0574\u0575\5\u00e2r\2\u0575"+
"\u0576\7\177\2\2\u0576\u0577\5\u00e2r\2\u0577\u0578\7\u0086\2\2\u0578"+
"\u059d\3\2\2\2\u0579\u057a\7`\2\2\u057a\u057b\7\u0085\2\2\u057b\u057c"+
"\5\u00e2r\2\u057c\u057d\7\177\2\2\u057d\u057e\5\u00e2r\2\u057e\u057f\7"+
"\u0086\2\2\u057f\u059d\3\2\2\2\u0580\u0581\7a\2\2\u0581\u0582\7\u0085"+
"\2\2\u0582\u0583\5\u00e2r\2\u0583\u0584\7\u0086\2\2\u0584\u059d\3\2\2"+
"\2\u0585\u0586\7b\2\2\u0586\u0587\7\u0085\2\2\u0587\u0588\5\u00e2r\2\u0588"+
"\u0589\7\u0086\2\2\u0589\u059d\3\2\2\2\u058a\u058b\7c\2\2\u058b\u058c"+
"\7\u0085\2\2\u058c\u058d\5\u00e2r\2\u058d\u058e\7\u0086\2\2\u058e\u059d"+
"\3\2\2\2\u058f\u0590\7d\2\2\u0590\u0591\7\u0085\2\2\u0591\u0592\5\u00e2"+
"r\2\u0592\u0593\7\u0086\2\2\u0593\u059d\3\2\2\2\u0594\u0595\7e\2\2\u0595"+
"\u0596\7\u0085\2\2\u0596\u0597\5\u00e2r\2\u0597\u0598\7\u0086\2\2\u0598"+
"\u059d\3\2\2\2\u0599\u059d\5\u00fc\177\2\u059a\u059d\5\u0102\u0082\2\u059b"+
"\u059d\5\u0104\u0083\2\u059c\u049a\3\2\2\2\u059c\u049b\3\2\2\2\u059c\u04a0"+
"\3\2\2\2\u059c\u04a5\3\2\2\2\u059c\u04ac\3\2\2\2\u059c\u04b1\3\2\2\2\u059c"+
"\u04b6\3\2\2\2\u059c\u04bb\3\2\2\2\u059c\u04c0\3\2\2\2\u059c\u04c8\3\2"+
"\2\2\u059c\u04ca\3\2\2\2\u059c\u04cf\3\2\2\2\u059c\u04d4\3\2\2\2\u059c"+
"\u04d9\3\2\2\2\u059c\u04de\3\2\2\2\u059c\u04e0\3\2\2\2\u059c\u04e1\3\2"+
"\2\2\u059c\u04e6\3\2\2\2\u059c\u04e7\3\2\2\2\u059c\u04ec\3\2\2\2\u059c"+
"\u04f1\3\2\2\2\u059c\u04f6\3\2\2\2\u059c\u04fd\3\2\2\2\u059c\u0504\3\2"+
"\2\2\u059c\u050b\3\2\2\2\u059c\u0512\3\2\2\2\u059c\u0519\3\2\2\2\u059c"+
"\u051e\3\2\2\2\u059c\u0523\3\2\2\2\u059c\u0528\3\2\2\2\u059c\u052d\3\2"+
"\2\2\u059c\u0532\3\2\2\2\u059c\u0537\3\2\2\2\u059c\u053c\3\2\2\2\u059c"+
"\u0541\3\2\2\2\u059c\u0543\3\2\2\2\u059c\u0545\3\2\2\2\u059c\u0547\3\2"+
"\2\2\u059c\u054c\3\2\2\2\u059c\u0551\3\2\2\2\u059c\u0556\3\2\2\2\u059c"+
"\u055b\3\2\2\2\u059c\u0560\3\2\2\2\u059c\u0562\3\2\2\2\u059c\u056b\3\2"+
"\2\2\u059c\u0572\3\2\2\2\u059c\u0579\3\2\2\2\u059c\u0580\3\2\2\2\u059c"+
"\u0585\3\2\2\2\u059c\u058a\3\2\2\2\u059c\u058f\3\2\2\2\u059c\u0594\3\2"+
"\2\2\u059c\u0599\3\2\2\2\u059c\u059a\3\2\2\2\u059c\u059b\3\2\2\2\u059d"+
"\u00fb\3\2\2\2\u059e\u059f\7f\2\2\u059f\u05a0\7\u0085\2\2\u05a0\u05a1"+
"\5\u00e2r\2\u05a1\u05a2\7\177\2\2\u05a2\u05a5\5\u00e2r\2\u05a3\u05a4\7"+
"\177\2\2\u05a4\u05a6\5\u00e2r\2\u05a5\u05a3\3\2\2\2\u05a5\u05a6\3\2\2"+
"\2\u05a6\u05a7\3\2\2\2\u05a7\u05a8\7\u0086\2\2\u05a8\u00fd\3\2\2\2\u05a9"+
"\u05aa\7g\2\2\u05aa\u05ab\7\u0085\2\2\u05ab\u05ac\5\u00e2r\2\u05ac\u05ad"+
"\7\177\2\2\u05ad\u05b0\5\u00e2r\2\u05ae\u05af\7\177\2\2\u05af\u05b1\5"+
"\u00e2r\2\u05b0\u05ae\3\2\2\2\u05b0\u05b1\3\2\2\2\u05b1\u05b2\3\2\2\2"+
"\u05b2\u05b3\7\u0086\2\2\u05b3\u00ff\3\2\2\2\u05b4\u05b5\7h\2\2\u05b5"+
"\u05b6\7\u0085\2\2\u05b6\u05b7\5\u00e2r\2\u05b7\u05b8\7\177\2\2\u05b8"+
"\u05b9\5\u00e2r\2\u05b9\u05ba\7\177\2\2\u05ba\u05bd\5\u00e2r\2\u05bb\u05bc"+
"\7\177\2\2\u05bc\u05be\5\u00e2r\2\u05bd\u05bb\3\2\2\2\u05bd\u05be\3\2"+
"\2\2\u05be\u05bf\3\2\2\2\u05bf\u05c0\7\u0086\2\2\u05c0\u0101\3\2\2\2\u05c1"+
"\u05c2\7i\2\2\u05c2\u05c3\5j\66\2\u05c3\u0103\3\2\2\2\u05c4\u05c5\7\63"+
"\2\2\u05c5\u05c6\7i\2\2\u05c6\u05c7\5j\66\2\u05c7\u0105\3\2\2\2\u05c8"+
"\u05c9\7j\2\2\u05c9\u05cb\7\u0085\2\2\u05ca\u05cc\7\b\2\2\u05cb\u05ca"+
"\3\2\2\2\u05cb\u05cc\3\2\2\2\u05cc\u05cf\3\2\2\2\u05cd\u05d0\7~\2\2\u05ce"+
"\u05d0\5\u00e2r\2\u05cf\u05cd\3\2\2\2\u05cf\u05ce\3\2\2\2\u05d0\u05d1"+
"\3\2\2\2\u05d1\u0609\7\u0086\2\2\u05d2\u05d3\7k\2\2\u05d3\u05d5\7\u0085"+
"\2\2\u05d4\u05d6\7\b\2\2\u05d5\u05d4\3\2\2\2\u05d5\u05d6\3\2\2\2\u05d6"+
"\u05d7\3\2\2\2\u05d7\u05d8\5\u00e2r\2\u05d8\u05d9\7\u0086\2\2\u05d9\u0609"+
"\3\2\2\2\u05da\u05db\7l\2\2\u05db\u05dd\7\u0085\2\2\u05dc\u05de\7\b\2"+
"\2\u05dd\u05dc\3\2\2\2\u05dd\u05de\3\2\2\2\u05de\u05df\3\2\2\2\u05df\u05e0"+
"\5\u00e2r\2\u05e0\u05e1\7\u0086\2\2\u05e1\u0609\3\2\2\2\u05e2\u05e3\7"+
"m\2\2\u05e3\u05e5\7\u0085\2\2\u05e4\u05e6\7\b\2\2\u05e5\u05e4\3\2\2\2"+
"\u05e5\u05e6\3\2\2\2\u05e6\u05e7\3\2\2\2\u05e7\u05e8\5\u00e2r\2\u05e8"+
"\u05e9\7\u0086\2\2\u05e9\u0609\3\2\2\2\u05ea\u05eb\7n\2\2\u05eb\u05ed"+
"\7\u0085\2\2\u05ec\u05ee\7\b\2\2\u05ed\u05ec\3\2\2\2\u05ed\u05ee\3\2\2"+
"\2\u05ee\u05ef\3\2\2\2\u05ef\u05f0\5\u00e2r\2\u05f0\u05f1\7\u0086\2\2"+
"\u05f1\u0609\3\2\2\2\u05f2\u05f3\7t\2\2\u05f3\u05f5\7\u0085\2\2\u05f4"+
"\u05f6\7\b\2\2\u05f5\u05f4\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6\u05f7\3\2"+
"\2\2\u05f7\u05f8\5\u00e2r\2\u05f8\u05f9\7\u0086\2\2\u05f9\u0609\3\2\2"+
"\2\u05fa\u05fb\7o\2\2\u05fb\u05fd\7\u0085\2\2\u05fc\u05fe\7\b\2\2\u05fd"+
"\u05fc\3\2\2\2\u05fd\u05fe\3\2\2\2\u05fe\u05ff\3\2\2\2\u05ff\u0604\5\u00e2"+
"r\2\u0600\u0601\7z\2\2\u0601\u0602\7p\2\2\u0602\u0603\7\u0082\2\2\u0603"+
"\u0605\5\u0116\u008c\2\u0604\u0600\3\2\2\2\u0604\u0605\3\2\2\2\u0605\u0606"+
"\3\2\2\2\u0606\u0607\7\u0086\2\2\u0607\u0609\3\2\2\2\u0608\u05c8\3\2\2"+
"\2\u0608\u05d2\3\2\2\2\u0608\u05da\3\2\2\2\u0608\u05e2\3\2\2\2\u0608\u05ea"+
"\3\2\2\2\u0608\u05f2\3\2\2\2\u0608\u05fa\3\2\2\2\u0609\u0107\3\2\2\2\u060a"+
"\u060c\5\u0118\u008d\2\u060b\u060d\5\u008eH\2\u060c\u060b\3\2\2\2\u060c"+
"\u060d\3\2\2\2\u060d\u0109\3\2\2\2\u060e\u0612\5\u0116\u008c\2\u060f\u0613"+
"\7\u0096\2\2\u0610\u0611\7u\2\2\u0611\u0613\5\u0118\u008d\2\u0612\u060f"+
"\3\2\2\2\u0612\u0610\3\2\2\2\u0612\u0613\3\2\2\2\u0613\u010b\3\2\2\2\u0614"+
"\u0618\5\u010e\u0088\2\u0615\u0618\5\u0110\u0089\2\u0616\u0618\5\u0112"+
"\u008a\2\u0617\u0614\3\2\2\2\u0617\u0615\3\2\2\2\u0617\u0616\3\2\2\2\u0618"+
"\u010d\3\2\2\2\u0619\u061a\t\7\2\2\u061a\u010f\3\2\2\2\u061b\u061c\t\b"+
"\2\2\u061c\u0111\3\2\2\2\u061d\u061e\t\t\2\2\u061e\u0113\3\2\2\2\u061f"+
"\u0620\t\n\2\2\u0620\u0115\3\2\2\2\u0621\u0622\t\13\2\2\u0622\u0117\3"+
"\2\2\2\u0623\u0627\7\u0090\2\2\u0624\u0627\5\u011a\u008e\2\u0625\u0627"+
"\7\u00aa\2\2\u0626\u0623\3\2\2\2\u0626\u0624\3\2\2\2\u0626\u0625\3\2\2"+
"\2\u0627\u0119\3\2\2\2\u0628\u0629\t\f\2\2\u0629\u011b\3\2\2\2\u062a\u062b"+
"\t\r\2\2\u062b\u011d\3\2\2\2\u009e\u0125\u012d\u012f\u013d\u014a\u0157"+
"\u0159\u015c\u0163\u016c\u0172\u0176\u017c\u017f\u0184\u0188\u0190\u0199"+
"\u01a2\u01a5\u01aa\u01ad\u01b0\u01b3\u01ba\u01c2\u01c7\u01cd\u01d6\u01dc"+
"\u01de\u01e2\u01e6\u01e8\u01f2\u01f8\u01fa\u0207\u020b\u0210\u0214\u021a"+
"\u0220\u0226\u022e\u0236\u024a\u024e\u0251\u0256\u0266\u026a\u026d\u0276"+
"\u0281\u0285\u0288\u028c\u0293\u029a\u029c\u02a1\u02a6\u02aa\u02ad\u02b1"+
"\u02b7\u02b9\u02c3\u02ce\u02df\u02e6\u02f0\u02f4\u02fb\u0300\u0302\u030c"+
"\u0316\u031f\u0327\u032e\u0333\u033c\u0341\u0345\u034c\u034e\u0356\u0359"+
"\u0361\u0365\u036a\u0371\u0376\u037d\u0385\u038a\u038e\u0394\u0398\u039c"+
"\u03a3\u03aa\u03b6\u03be\u03c3\u03c8\u03d4\u03dd\u03e0\u03e3\u03ea\u03ec"+
"\u03f2\u03fa\u0404\u040c\u0412\u0416\u041a\u041f\u0423\u0433\u0439\u0440"+
"\u0448\u045f\u046a\u0470\u0472\u0475\u0477\u047f\u0481\u048b\u0494\u04c6"+
"\u059c\u05a5\u05b0\u05bd\u05cb\u05cf\u05d5\u05dd\u05e5\u05ed\u05f5\u05fd"+
"\u0604\u0608\u060c\u0612\u0617\u0626";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy