com.argot.compiler.ArgotParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of argot-compiler Show documentation
Show all versions of argot-compiler Show documentation
Argot dictionary compiler.
The newest version!
// Generated from com/argot/compiler/Argot.g4 by ANTLR 4.7.2
package com.argot.compiler;
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 ArgotParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, IDENTIFIER=23, QSTRING=24,
Int=25, WS=26, BlockComment=27;
public static final int
RULE_file = 0, RULE_headers = 1, RULE_headerline = 2, RULE_cluster = 3,
RULE_definition = 4, RULE_relation = 5, RULE_sequence = 6, RULE_tag = 7,
RULE_reserve = 8, RULE_load = 9, RULE_importl = 10, RULE_expression = 11,
RULE_expressionIdentifier = 12, RULE_primary = 13, RULE_array = 14, RULE_typeIdentifier = 15,
RULE_value = 16, RULE_mappedIdentifier = 17, RULE_identifier = 18;
private static String[] makeRuleNames() {
return new String[] {
"file", "headers", "headerline", "cluster", "definition", "relation",
"sequence", "tag", "reserve", "load", "importl", "expression", "expressionIdentifier",
"primary", "array", "typeIdentifier", "value", "mappedIdentifier", "identifier"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'cluster'", "';'", "'definition'", "'.'", "':'", "'relation'",
"'{'", "'}'", "'@'", "'#'", "'!'", "'reserve'", "'load'", "','", "'import'",
"'as'", "'('", "')'", "'/'", "'['", "']'", "'$'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
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, "IDENTIFIER",
"QSTRING", "Int", "WS", "BlockComment"
};
}
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 "Argot.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public ArgotParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class FileContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(ArgotParser.EOF, 0); }
public HeadersContext headers() {
return getRuleContext(HeadersContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public FileContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_file; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitFile(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitFile(this);
else return visitor.visitChildren(this);
}
}
public final FileContext file() throws RecognitionException {
FileContext _localctx = new FileContext(_ctx, getState());
enterRule(_localctx, 0, RULE_file);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(39);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__2) | (1L << T__5) | (1L << T__10))) != 0)) {
{
setState(38);
headers();
}
}
setState(44);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__16) {
{
{
setState(41);
expression();
}
}
setState(46);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(47);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HeadersContext extends ParserRuleContext {
public HeaderlineContext headerline() {
return getRuleContext(HeaderlineContext.class,0);
}
public HeadersContext headers() {
return getRuleContext(HeadersContext.class,0);
}
public HeadersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_headers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterHeaders(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitHeaders(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitHeaders(this);
else return visitor.visitChildren(this);
}
}
public final HeadersContext headers() throws RecognitionException {
HeadersContext _localctx = new HeadersContext(_ctx, getState());
enterRule(_localctx, 2, RULE_headers);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(49);
headerline();
setState(51);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__2) | (1L << T__5) | (1L << T__10))) != 0)) {
{
setState(50);
headers();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HeaderlineContext extends ParserRuleContext {
public ImportlContext importl() {
return getRuleContext(ImportlContext.class,0);
}
public LoadContext load() {
return getRuleContext(LoadContext.class,0);
}
public ReserveContext reserve() {
return getRuleContext(ReserveContext.class,0);
}
public ClusterContext cluster() {
return getRuleContext(ClusterContext.class,0);
}
public DefinitionContext definition() {
return getRuleContext(DefinitionContext.class,0);
}
public RelationContext relation() {
return getRuleContext(RelationContext.class,0);
}
public HeaderlineContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_headerline; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterHeaderline(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitHeaderline(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitHeaderline(this);
else return visitor.visitChildren(this);
}
}
public final HeaderlineContext headerline() throws RecognitionException {
HeaderlineContext _localctx = new HeaderlineContext(_ctx, getState());
enterRule(_localctx, 4, RULE_headerline);
try {
setState(59);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(53);
importl();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(54);
load();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(55);
reserve();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(56);
cluster();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(57);
definition();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(58);
relation();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClusterContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ClusterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cluster; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterCluster(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitCluster(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitCluster(this);
else return visitor.visitChildren(this);
}
}
public final ClusterContext cluster() throws RecognitionException {
ClusterContext _localctx = new ClusterContext(_ctx, getState());
enterRule(_localctx, 6, RULE_cluster);
try {
enterOuterAlt(_localctx, 1);
{
setState(61);
match(T__0);
setState(62);
identifier();
setState(63);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List Int() { return getTokens(ArgotParser.Int); }
public TerminalNode Int(int i) {
return getToken(ArgotParser.Int, i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SequenceContext sequence() {
return getRuleContext(SequenceContext.class,0);
}
public DefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_definition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitDefinition(this);
else return visitor.visitChildren(this);
}
}
public final DefinitionContext definition() throws RecognitionException {
DefinitionContext _localctx = new DefinitionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_definition);
try {
enterOuterAlt(_localctx, 1);
{
setState(65);
match(T__2);
setState(66);
identifier();
setState(67);
match(Int);
setState(68);
match(T__3);
setState(69);
match(Int);
setState(70);
match(T__4);
setState(73);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__16:
{
setState(71);
expression();
}
break;
case T__6:
{
setState(72);
sequence();
}
break;
default:
throw new NoViableAltException(this);
}
setState(75);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List Int() { return getTokens(ArgotParser.Int); }
public TerminalNode Int(int i) {
return getToken(ArgotParser.Int, i);
}
public TerminalNode QSTRING() { return getToken(ArgotParser.QSTRING, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public RelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitRelation(this);
else return visitor.visitChildren(this);
}
}
public final RelationContext relation() throws RecognitionException {
RelationContext _localctx = new RelationContext(_ctx, getState());
enterRule(_localctx, 10, RULE_relation);
try {
enterOuterAlt(_localctx, 1);
{
setState(77);
match(T__5);
setState(78);
identifier();
setState(79);
match(Int);
setState(80);
match(T__3);
setState(81);
match(Int);
setState(82);
match(QSTRING);
setState(83);
match(T__4);
{
setState(84);
expression();
}
setState(85);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SequenceContext extends ParserRuleContext {
public List tag() {
return getRuleContexts(TagContext.class);
}
public TagContext tag(int i) {
return getRuleContext(TagContext.class,i);
}
public SequenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sequence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterSequence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitSequence(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitSequence(this);
else return visitor.visitChildren(this);
}
}
public final SequenceContext sequence() throws RecognitionException {
SequenceContext _localctx = new SequenceContext(_ctx, getState());
enterRule(_localctx, 12, RULE_sequence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(87);
match(T__6);
setState(91);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__8) {
{
{
setState(88);
tag();
}
}
setState(93);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(94);
match(T__7);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TagContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TagContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tag; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterTag(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitTag(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitTag(this);
else return visitor.visitChildren(this);
}
}
public final TagContext tag() throws RecognitionException {
TagContext _localctx = new TagContext(_ctx, getState());
enterRule(_localctx, 14, RULE_tag);
try {
enterOuterAlt(_localctx, 1);
{
setState(96);
match(T__8);
setState(97);
identifier();
setState(98);
match(T__9);
setState(99);
identifier();
setState(100);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReserveContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ReserveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reserve; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterReserve(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitReserve(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitReserve(this);
else return visitor.visitChildren(this);
}
}
public final ReserveContext reserve() throws RecognitionException {
ReserveContext _localctx = new ReserveContext(_ctx, getState());
enterRule(_localctx, 16, RULE_reserve);
try {
enterOuterAlt(_localctx, 1);
{
setState(102);
match(T__10);
setState(103);
match(T__11);
setState(104);
identifier();
setState(105);
match(T__1);
}
}
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 QSTRING() { return getToken(ArgotParser.QSTRING, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.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 ArgotListener ) ((ArgotListener)listener).enterLoad(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitLoad(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitLoad(this);
else return visitor.visitChildren(this);
}
}
public final LoadContext load() throws RecognitionException {
LoadContext _localctx = new LoadContext(_ctx, getState());
enterRule(_localctx, 18, RULE_load);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(107);
match(T__10);
setState(108);
match(T__12);
setState(109);
match(QSTRING);
setState(112);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__13) {
{
setState(110);
match(T__13);
setState(111);
identifier();
}
}
setState(114);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportlContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public ImportlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterImportl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitImportl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitImportl(this);
else return visitor.visitChildren(this);
}
}
public final ImportlContext importl() throws RecognitionException {
ImportlContext _localctx = new ImportlContext(_ctx, getState());
enterRule(_localctx, 20, RULE_importl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(116);
match(T__10);
setState(117);
match(T__14);
setState(118);
identifier();
setState(121);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__15) {
{
setState(119);
match(T__15);
setState(120);
identifier();
}
}
setState(123);
match(T__1);
}
}
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 ExpressionIdentifierContext expressionIdentifier() {
return getRuleContext(ExpressionIdentifierContext.class,0);
}
public List primary() {
return getRuleContexts(PrimaryContext.class);
}
public PrimaryContext primary(int i) {
return getRuleContext(PrimaryContext.class,i);
}
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 ArgotListener ) ((ArgotListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 22, RULE_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(125);
match(T__16);
setState(126);
expressionIdentifier();
setState(130);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__9) | (1L << T__16) | (1L << T__19) | (1L << T__21) | (1L << IDENTIFIER))) != 0)) {
{
{
setState(127);
primary();
}
}
setState(132);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(133);
match(T__17);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List Int() { return getTokens(ArgotParser.Int); }
public TerminalNode Int(int i) {
return getToken(ArgotParser.Int, i);
}
public ExpressionIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterExpressionIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitExpressionIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitExpressionIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionIdentifierContext expressionIdentifier() throws RecognitionException {
ExpressionIdentifierContext _localctx = new ExpressionIdentifierContext(_ctx, getState());
enterRule(_localctx, 24, RULE_expressionIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(135);
identifier();
setState(140);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__18) {
{
setState(136);
match(T__18);
setState(137);
match(Int);
setState(138);
match(T__3);
setState(139);
match(Int);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ArrayContext array() {
return getRuleContext(ArrayContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public TypeIdentifierContext typeIdentifier() {
return getRuleContext(TypeIdentifierContext.class,0);
}
public MappedIdentifierContext mappedIdentifier() {
return getRuleContext(MappedIdentifierContext.class,0);
}
public PrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitPrimary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitPrimary(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryContext primary() throws RecognitionException {
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
enterRule(_localctx, 26, RULE_primary);
try {
setState(147);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__16:
enterOuterAlt(_localctx, 1);
{
setState(142);
expression();
}
break;
case T__19:
enterOuterAlt(_localctx, 2);
{
setState(143);
array();
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 3);
{
setState(144);
value();
}
break;
case T__9:
enterOuterAlt(_localctx, 4);
{
setState(145);
typeIdentifier();
}
break;
case T__21:
enterOuterAlt(_localctx, 5);
{
setState(146);
mappedIdentifier();
}
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 ArrayContext extends ParserRuleContext {
public List primary() {
return getRuleContexts(PrimaryContext.class);
}
public PrimaryContext primary(int i) {
return getRuleContext(PrimaryContext.class,i);
}
public ArrayContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_array; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterArray(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitArray(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitArray(this);
else return visitor.visitChildren(this);
}
}
public final ArrayContext array() throws RecognitionException {
ArrayContext _localctx = new ArrayContext(_ctx, getState());
enterRule(_localctx, 28, RULE_array);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(149);
match(T__19);
setState(153);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__9) | (1L << T__16) | (1L << T__19) | (1L << T__21) | (1L << IDENTIFIER))) != 0)) {
{
{
setState(150);
primary();
}
}
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(156);
match(T__20);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterTypeIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitTypeIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitTypeIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final TypeIdentifierContext typeIdentifier() throws RecognitionException {
TypeIdentifierContext _localctx = new TypeIdentifierContext(_ctx, getState());
enterRule(_localctx, 30, RULE_typeIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(158);
match(T__9);
setState(159);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode Int() { return getToken(ArgotParser.Int, 0); }
public TerminalNode QSTRING() { return getToken(ArgotParser.QSTRING, 0); }
public ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitValue(this);
else return visitor.visitChildren(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 32, RULE_value);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(161);
identifier();
setState(162);
match(T__4);
setState(163);
_la = _input.LA(1);
if ( !(_la==QSTRING || _la==Int) ) {
_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 MappedIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MappedIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mappedIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterMappedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitMappedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitMappedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final MappedIdentifierContext mappedIdentifier() throws RecognitionException {
MappedIdentifierContext _localctx = new MappedIdentifierContext(_ctx, getState());
enterRule(_localctx, 34, RULE_mappedIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(165);
match(T__21);
setState(166);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(ArgotParser.IDENTIFIER, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ArgotListener ) ((ArgotListener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof ArgotVisitor ) return ((ArgotVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 36, RULE_identifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(168);
match(IDENTIFIER);
}
}
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\35\u00ad\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\3\2\5\2*\n\2\3\2\7\2-\n\2\f\2\16\2\60\13\2\3\2\3"+
"\2\3\3\3\3\5\3\66\n\3\3\4\3\4\3\4\3\4\3\4\3\4\5\4>\n\4\3\5\3\5\3\5\3\5"+
"\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6L\n\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7"+
"\3\7\3\7\3\7\3\7\3\7\3\b\3\b\7\b\\\n\b\f\b\16\b_\13\b\3\b\3\b\3\t\3\t"+
"\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\5\13s\n"+
"\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\5\f|\n\f\3\f\3\f\3\r\3\r\3\r\7\r\u0083"+
"\n\r\f\r\16\r\u0086\13\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\5\16\u008f\n"+
"\16\3\17\3\17\3\17\3\17\3\17\5\17\u0096\n\17\3\20\3\20\7\20\u009a\n\20"+
"\f\20\16\20\u009d\13\20\3\20\3\20\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3"+
"\23\3\23\3\23\3\24\3\24\3\24\2\2\25\2\4\6\b\n\f\16\20\22\24\26\30\32\34"+
"\36 \"$&\2\3\3\2\32\33\2\u00ac\2)\3\2\2\2\4\63\3\2\2\2\6=\3\2\2\2\b?\3"+
"\2\2\2\nC\3\2\2\2\fO\3\2\2\2\16Y\3\2\2\2\20b\3\2\2\2\22h\3\2\2\2\24m\3"+
"\2\2\2\26v\3\2\2\2\30\177\3\2\2\2\32\u0089\3\2\2\2\34\u0095\3\2\2\2\36"+
"\u0097\3\2\2\2 \u00a0\3\2\2\2\"\u00a3\3\2\2\2$\u00a7\3\2\2\2&\u00aa\3"+
"\2\2\2(*\5\4\3\2)(\3\2\2\2)*\3\2\2\2*.\3\2\2\2+-\5\30\r\2,+\3\2\2\2-\60"+
"\3\2\2\2.,\3\2\2\2./\3\2\2\2/\61\3\2\2\2\60.\3\2\2\2\61\62\7\2\2\3\62"+
"\3\3\2\2\2\63\65\5\6\4\2\64\66\5\4\3\2\65\64\3\2\2\2\65\66\3\2\2\2\66"+
"\5\3\2\2\2\67>\5\26\f\28>\5\24\13\29>\5\22\n\2:>\5\b\5\2;>\5\n\6\2<>\5"+
"\f\7\2=\67\3\2\2\2=8\3\2\2\2=9\3\2\2\2=:\3\2\2\2=;\3\2\2\2=<\3\2\2\2>"+
"\7\3\2\2\2?@\7\3\2\2@A\5&\24\2AB\7\4\2\2B\t\3\2\2\2CD\7\5\2\2DE\5&\24"+
"\2EF\7\33\2\2FG\7\6\2\2GH\7\33\2\2HK\7\7\2\2IL\5\30\r\2JL\5\16\b\2KI\3"+
"\2\2\2KJ\3\2\2\2LM\3\2\2\2MN\7\4\2\2N\13\3\2\2\2OP\7\b\2\2PQ\5&\24\2Q"+
"R\7\33\2\2RS\7\6\2\2ST\7\33\2\2TU\7\32\2\2UV\7\7\2\2VW\5\30\r\2WX\7\4"+
"\2\2X\r\3\2\2\2Y]\7\t\2\2Z\\\5\20\t\2[Z\3\2\2\2\\_\3\2\2\2][\3\2\2\2]"+
"^\3\2\2\2^`\3\2\2\2_]\3\2\2\2`a\7\n\2\2a\17\3\2\2\2bc\7\13\2\2cd\5&\24"+
"\2de\7\f\2\2ef\5&\24\2fg\7\4\2\2g\21\3\2\2\2hi\7\r\2\2ij\7\16\2\2jk\5"+
"&\24\2kl\7\4\2\2l\23\3\2\2\2mn\7\r\2\2no\7\17\2\2or\7\32\2\2pq\7\20\2"+
"\2qs\5&\24\2rp\3\2\2\2rs\3\2\2\2st\3\2\2\2tu\7\4\2\2u\25\3\2\2\2vw\7\r"+
"\2\2wx\7\21\2\2x{\5&\24\2yz\7\22\2\2z|\5&\24\2{y\3\2\2\2{|\3\2\2\2|}\3"+
"\2\2\2}~\7\4\2\2~\27\3\2\2\2\177\u0080\7\23\2\2\u0080\u0084\5\32\16\2"+
"\u0081\u0083\5\34\17\2\u0082\u0081\3\2\2\2\u0083\u0086\3\2\2\2\u0084\u0082"+
"\3\2\2\2\u0084\u0085\3\2\2\2\u0085\u0087\3\2\2\2\u0086\u0084\3\2\2\2\u0087"+
"\u0088\7\24\2\2\u0088\31\3\2\2\2\u0089\u008e\5&\24\2\u008a\u008b\7\25"+
"\2\2\u008b\u008c\7\33\2\2\u008c\u008d\7\6\2\2\u008d\u008f\7\33\2\2\u008e"+
"\u008a\3\2\2\2\u008e\u008f\3\2\2\2\u008f\33\3\2\2\2\u0090\u0096\5\30\r"+
"\2\u0091\u0096\5\36\20\2\u0092\u0096\5\"\22\2\u0093\u0096\5 \21\2\u0094"+
"\u0096\5$\23\2\u0095\u0090\3\2\2\2\u0095\u0091\3\2\2\2\u0095\u0092\3\2"+
"\2\2\u0095\u0093\3\2\2\2\u0095\u0094\3\2\2\2\u0096\35\3\2\2\2\u0097\u009b"+
"\7\26\2\2\u0098\u009a\5\34\17\2\u0099\u0098\3\2\2\2\u009a\u009d\3\2\2"+
"\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009e\3\2\2\2\u009d\u009b"+
"\3\2\2\2\u009e\u009f\7\27\2\2\u009f\37\3\2\2\2\u00a0\u00a1\7\f\2\2\u00a1"+
"\u00a2\5&\24\2\u00a2!\3\2\2\2\u00a3\u00a4\5&\24\2\u00a4\u00a5\7\7\2\2"+
"\u00a5\u00a6\t\2\2\2\u00a6#\3\2\2\2\u00a7\u00a8\7\30\2\2\u00a8\u00a9\5"+
"&\24\2\u00a9%\3\2\2\2\u00aa\u00ab\7\31\2\2\u00ab\'\3\2\2\2\16).\65=K]"+
"r{\u0084\u008e\u0095\u009b";
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