1062 lines
39 KiB
C#
1062 lines
39 KiB
C#
//------------------------------------------------------------------------------
|
|
// <auto-generated>
|
|
// This code was generated by a tool.
|
|
// ANTLR Version: 4.13.2
|
|
//
|
|
// Changes to this file may cause incorrect behavior and will be lost if
|
|
// the code is regenerated.
|
|
// </auto-generated>
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generated from E:/ProgettiUnity/InkAntlr/InkBlot/InkBlot/InkBlotAntlrGrammar.g4 by ANTLR 4.13.2
|
|
|
|
// Unreachable code detected
|
|
#pragma warning disable 0162
|
|
// The variable '...' is assigned but its value is never used
|
|
#pragma warning disable 0219
|
|
// Missing XML comment for publicly visible type or member '...'
|
|
#pragma warning disable 1591
|
|
// Ambiguous reference in cref attribute
|
|
#pragma warning disable 419
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Diagnostics;
|
|
using System.Collections.Generic;
|
|
using Antlr4.Runtime;
|
|
using Antlr4.Runtime.Atn;
|
|
using Antlr4.Runtime.Misc;
|
|
using Antlr4.Runtime.Tree;
|
|
using DFA = Antlr4.Runtime.Dfa.DFA;
|
|
|
|
[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.13.2")]
|
|
[System.CLSCompliant(false)]
|
|
public partial class InkBlotAntlrGrammarParser : Parser {
|
|
protected static DFA[] decisionToDFA;
|
|
protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
|
|
public const int
|
|
T__0=1, T__1=2, T__2=3, T__3=4, THREAD_ARROW=5, DIVERT_ARROW=6, TUNNEL_ARROW=7,
|
|
IDENTIFIER=8, WS=9, NL=10;
|
|
public const int
|
|
RULE_story = 0, RULE_topLevelStatements = 1, RULE_topLevelStatement = 2,
|
|
RULE_multiDivert = 3, RULE_multiDivert_withoutWS = 4, RULE_multiDivertArrows_tail = 5,
|
|
RULE_divertIdentifierWithArguments = 6, RULE_divertIdentifierWithArguments_name = 7,
|
|
RULE_divertIdentifierWithArguments_arguments = 8, RULE_identifier = 9,
|
|
RULE_expression = 10;
|
|
public static readonly string[] ruleNames = {
|
|
"story", "topLevelStatements", "topLevelStatement", "multiDivert", "multiDivert_withoutWS",
|
|
"multiDivertArrows_tail", "divertIdentifierWithArguments", "divertIdentifierWithArguments_name",
|
|
"divertIdentifierWithArguments_arguments", "identifier", "expression"
|
|
};
|
|
|
|
private static readonly string[] _LiteralNames = {
|
|
null, "'.'", "'('", "','", "')'", "'<-'", "'->'", "'->->'"
|
|
};
|
|
private static readonly string[] _SymbolicNames = {
|
|
null, null, null, null, null, "THREAD_ARROW", "DIVERT_ARROW", "TUNNEL_ARROW",
|
|
"IDENTIFIER", "WS", "NL"
|
|
};
|
|
public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);
|
|
|
|
[NotNull]
|
|
public override IVocabulary Vocabulary
|
|
{
|
|
get
|
|
{
|
|
return DefaultVocabulary;
|
|
}
|
|
}
|
|
|
|
public override string GrammarFileName { get { return "InkBlotAntlrGrammar.g4"; } }
|
|
|
|
public override string[] RuleNames { get { return ruleNames; } }
|
|
|
|
public override int[] SerializedAtn { get { return _serializedATN; } }
|
|
|
|
static InkBlotAntlrGrammarParser() {
|
|
decisionToDFA = new DFA[_ATN.NumberOfDecisions];
|
|
for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
|
|
decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
|
|
}
|
|
}
|
|
|
|
public InkBlotAntlrGrammarParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }
|
|
|
|
public InkBlotAntlrGrammarParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
|
|
: base(input, output, errorOutput)
|
|
{
|
|
Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
|
|
}
|
|
|
|
public partial class StoryContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public TopLevelStatementsContext topLevelStatements() {
|
|
return GetRuleContext<TopLevelStatementsContext>(0);
|
|
}
|
|
public StoryContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_story; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterStory(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitStory(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitStory(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public StoryContext story() {
|
|
StoryContext _localctx = new StoryContext(Context, State);
|
|
EnterRule(_localctx, 0, RULE_story);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 22;
|
|
topLevelStatements();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class TopLevelStatementsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public TopLevelStatementContext[] topLevelStatement() {
|
|
return GetRuleContexts<TopLevelStatementContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public TopLevelStatementContext topLevelStatement(int i) {
|
|
return GetRuleContext<TopLevelStatementContext>(i);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] NL() { return GetTokens(InkBlotAntlrGrammarParser.NL); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NL(int i) {
|
|
return GetToken(InkBlotAntlrGrammarParser.NL, i);
|
|
}
|
|
public TopLevelStatementsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_topLevelStatements; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterTopLevelStatements(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitTopLevelStatements(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitTopLevelStatements(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public TopLevelStatementsContext topLevelStatements() {
|
|
TopLevelStatementsContext _localctx = new TopLevelStatementsContext(Context, State);
|
|
EnterRule(_localctx, 2, RULE_topLevelStatements);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 24;
|
|
topLevelStatement();
|
|
State = 33;
|
|
ErrorHandler.Sync(this);
|
|
_alt = Interpreter.AdaptivePredict(TokenStream,1,Context);
|
|
while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
State = 26;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 25;
|
|
Match(NL);
|
|
}
|
|
}
|
|
State = 28;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==NL );
|
|
State = 30;
|
|
topLevelStatement();
|
|
}
|
|
}
|
|
}
|
|
State = 35;
|
|
ErrorHandler.Sync(this);
|
|
_alt = Interpreter.AdaptivePredict(TokenStream,1,Context);
|
|
}
|
|
State = 39;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
while (_la==NL) {
|
|
{
|
|
{
|
|
State = 36;
|
|
Match(NL);
|
|
}
|
|
}
|
|
State = 41;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class TopLevelStatementContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert() {
|
|
return GetRuleContext<MultiDivertContext>(0);
|
|
}
|
|
public TopLevelStatementContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_topLevelStatement; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterTopLevelStatement(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitTopLevelStatement(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitTopLevelStatement(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public TopLevelStatementContext topLevelStatement() {
|
|
TopLevelStatementContext _localctx = new TopLevelStatementContext(Context, State);
|
|
EnterRule(_localctx, 4, RULE_topLevelStatement);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 42;
|
|
multiDivert();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class MultiDivertContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public MultiDivert_withoutWSContext multiDivert_withoutWS() {
|
|
return GetRuleContext<MultiDivert_withoutWSContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS() { return GetToken(InkBlotAntlrGrammarParser.WS, 0); }
|
|
public MultiDivertContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_multiDivert; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterMultiDivert(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitMultiDivert(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitMultiDivert(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public MultiDivertContext multiDivert() {
|
|
MultiDivertContext _localctx = new MultiDivertContext(Context, State);
|
|
EnterRule(_localctx, 6, RULE_multiDivert);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 45;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 44;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 47;
|
|
multiDivert_withoutWS();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class MultiDivert_withoutWSContext : ParserRuleContext {
|
|
public MultiDivert_withoutWSContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_multiDivert_withoutWS; } }
|
|
|
|
public MultiDivert_withoutWSContext() { }
|
|
public virtual void CopyFrom(MultiDivert_withoutWSContext context) {
|
|
base.CopyFrom(context);
|
|
}
|
|
}
|
|
public partial class MultiDivertArrowsContext : MultiDivert_withoutWSContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public MultiDivertArrows_tailContext multiDivertArrows_tail() {
|
|
return GetRuleContext<MultiDivertArrows_tailContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DIVERT_ARROW() { return GetTokens(InkBlotAntlrGrammarParser.DIVERT_ARROW); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIVERT_ARROW(int i) {
|
|
return GetToken(InkBlotAntlrGrammarParser.DIVERT_ARROW, i);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext[] divertIdentifierWithArguments() {
|
|
return GetRuleContexts<DivertIdentifierWithArgumentsContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments(int i) {
|
|
return GetRuleContext<DivertIdentifierWithArgumentsContext>(i);
|
|
}
|
|
public MultiDivertArrowsContext(MultiDivert_withoutWSContext context) { CopyFrom(context); }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterMultiDivertArrows(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitMultiDivertArrows(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
public partial class MultiDivertThreadContext : MultiDivert_withoutWSContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode THREAD_ARROW() { return GetToken(InkBlotAntlrGrammarParser.THREAD_ARROW, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments() {
|
|
return GetRuleContext<DivertIdentifierWithArgumentsContext>(0);
|
|
}
|
|
public MultiDivertThreadContext(MultiDivert_withoutWSContext context) { CopyFrom(context); }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterMultiDivertThread(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitMultiDivertThread(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitMultiDivertThread(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public MultiDivert_withoutWSContext multiDivert_withoutWS() {
|
|
MultiDivert_withoutWSContext _localctx = new MultiDivert_withoutWSContext(Context, State);
|
|
EnterRule(_localctx, 8, RULE_multiDivert_withoutWS);
|
|
try {
|
|
int _alt;
|
|
State = 59;
|
|
ErrorHandler.Sync(this);
|
|
switch (TokenStream.LA(1)) {
|
|
case THREAD_ARROW:
|
|
_localctx = new MultiDivertThreadContext(_localctx);
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 49;
|
|
Match(THREAD_ARROW);
|
|
State = 50;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
break;
|
|
case DIVERT_ARROW:
|
|
case TUNNEL_ARROW:
|
|
_localctx = new MultiDivertArrowsContext(_localctx);
|
|
EnterOuterAlt(_localctx, 2);
|
|
{
|
|
State = 55;
|
|
ErrorHandler.Sync(this);
|
|
_alt = Interpreter.AdaptivePredict(TokenStream,4,Context);
|
|
while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
State = 51;
|
|
Match(DIVERT_ARROW);
|
|
State = 52;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
}
|
|
}
|
|
State = 57;
|
|
ErrorHandler.Sync(this);
|
|
_alt = Interpreter.AdaptivePredict(TokenStream,4,Context);
|
|
}
|
|
State = 58;
|
|
multiDivertArrows_tail();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class MultiDivertArrows_tailContext : ParserRuleContext {
|
|
public MultiDivertArrows_tailContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_multiDivertArrows_tail; } }
|
|
|
|
public MultiDivertArrows_tailContext() { }
|
|
public virtual void CopyFrom(MultiDivertArrows_tailContext context) {
|
|
base.CopyFrom(context);
|
|
}
|
|
}
|
|
public partial class MultiDivertArrows_tailTunnelWithReplacementContext : MultiDivertArrows_tailContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TUNNEL_ARROW() { return GetToken(InkBlotAntlrGrammarParser.TUNNEL_ARROW, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments() {
|
|
return GetRuleContext<DivertIdentifierWithArgumentsContext>(0);
|
|
}
|
|
public MultiDivertArrows_tailTunnelWithReplacementContext(MultiDivertArrows_tailContext context) { CopyFrom(context); }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterMultiDivertArrows_tailTunnelWithReplacement(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitMultiDivertArrows_tailTunnelWithReplacement(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows_tailTunnelWithReplacement(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
public partial class MultiDivertArrows_tailDivertContext : MultiDivertArrows_tailContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIVERT_ARROW() { return GetToken(InkBlotAntlrGrammarParser.DIVERT_ARROW, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments() {
|
|
return GetRuleContext<DivertIdentifierWithArgumentsContext>(0);
|
|
}
|
|
public MultiDivertArrows_tailDivertContext(MultiDivertArrows_tailContext context) { CopyFrom(context); }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterMultiDivertArrows_tailDivert(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitMultiDivertArrows_tailDivert(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows_tailDivert(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
public partial class MultiDivertArrows_tailTunnelContext : MultiDivertArrows_tailContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TUNNEL_ARROW() { return GetToken(InkBlotAntlrGrammarParser.TUNNEL_ARROW, 0); }
|
|
public MultiDivertArrows_tailTunnelContext(MultiDivertArrows_tailContext context) { CopyFrom(context); }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterMultiDivertArrows_tailTunnel(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitMultiDivertArrows_tailTunnel(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows_tailTunnel(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
public partial class MultiDivertArrows_tailDefaultChoiceContext : MultiDivertArrows_tailContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIVERT_ARROW() { return GetToken(InkBlotAntlrGrammarParser.DIVERT_ARROW, 0); }
|
|
public MultiDivertArrows_tailDefaultChoiceContext(MultiDivertArrows_tailContext context) { CopyFrom(context); }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterMultiDivertArrows_tailDefaultChoice(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitMultiDivertArrows_tailDefaultChoice(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows_tailDefaultChoice(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public MultiDivertArrows_tailContext multiDivertArrows_tail() {
|
|
MultiDivertArrows_tailContext _localctx = new MultiDivertArrows_tailContext(Context, State);
|
|
EnterRule(_localctx, 10, RULE_multiDivertArrows_tail);
|
|
try {
|
|
State = 67;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,6,Context) ) {
|
|
case 1:
|
|
_localctx = new MultiDivertArrows_tailDefaultChoiceContext(_localctx);
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 61;
|
|
Match(DIVERT_ARROW);
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new MultiDivertArrows_tailDivertContext(_localctx);
|
|
EnterOuterAlt(_localctx, 2);
|
|
{
|
|
State = 62;
|
|
Match(DIVERT_ARROW);
|
|
State = 63;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new MultiDivertArrows_tailTunnelWithReplacementContext(_localctx);
|
|
EnterOuterAlt(_localctx, 3);
|
|
{
|
|
State = 64;
|
|
Match(TUNNEL_ARROW);
|
|
State = 65;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new MultiDivertArrows_tailTunnelContext(_localctx);
|
|
EnterOuterAlt(_localctx, 4);
|
|
{
|
|
State = 66;
|
|
Match(TUNNEL_ARROW);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class DivertIdentifierWithArgumentsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArguments_nameContext divertIdentifierWithArguments_name() {
|
|
return GetRuleContext<DivertIdentifierWithArguments_nameContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
|
|
return GetToken(InkBlotAntlrGrammarParser.WS, i);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArguments_argumentsContext divertIdentifierWithArguments_arguments() {
|
|
return GetRuleContext<DivertIdentifierWithArguments_argumentsContext>(0);
|
|
}
|
|
public DivertIdentifierWithArgumentsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_divertIdentifierWithArguments; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterDivertIdentifierWithArguments(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitDivertIdentifierWithArguments(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitDivertIdentifierWithArguments(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments() {
|
|
DivertIdentifierWithArgumentsContext _localctx = new DivertIdentifierWithArgumentsContext(Context, State);
|
|
EnterRule(_localctx, 12, RULE_divertIdentifierWithArguments);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 69;
|
|
divertIdentifierWithArguments_name();
|
|
State = 71;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 70;
|
|
Match(WS);
|
|
}
|
|
break;
|
|
}
|
|
State = 74;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==T__1) {
|
|
{
|
|
State = 73;
|
|
divertIdentifierWithArguments_arguments();
|
|
}
|
|
}
|
|
|
|
State = 77;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 76;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class DivertIdentifierWithArguments_nameContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public IdentifierContext[] identifier() {
|
|
return GetRuleContexts<IdentifierContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public IdentifierContext identifier(int i) {
|
|
return GetRuleContext<IdentifierContext>(i);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
|
|
return GetToken(InkBlotAntlrGrammarParser.WS, i);
|
|
}
|
|
public DivertIdentifierWithArguments_nameContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_divertIdentifierWithArguments_name; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterDivertIdentifierWithArguments_name(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitDivertIdentifierWithArguments_name(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitDivertIdentifierWithArguments_name(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public DivertIdentifierWithArguments_nameContext divertIdentifierWithArguments_name() {
|
|
DivertIdentifierWithArguments_nameContext _localctx = new DivertIdentifierWithArguments_nameContext(Context, State);
|
|
EnterRule(_localctx, 14, RULE_divertIdentifierWithArguments_name);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 80;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 79;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 82;
|
|
identifier();
|
|
State = 84;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 83;
|
|
Match(WS);
|
|
}
|
|
break;
|
|
}
|
|
State = 96;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
while (_la==T__0) {
|
|
{
|
|
{
|
|
State = 86;
|
|
Match(T__0);
|
|
State = 88;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 87;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 90;
|
|
identifier();
|
|
State = 92;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 91;
|
|
Match(WS);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
State = 98;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class DivertIdentifierWithArguments_argumentsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
|
|
return GetRuleContexts<ExpressionContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
|
|
return GetRuleContext<ExpressionContext>(i);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
|
|
return GetToken(InkBlotAntlrGrammarParser.WS, i);
|
|
}
|
|
public DivertIdentifierWithArguments_argumentsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_divertIdentifierWithArguments_arguments; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterDivertIdentifierWithArguments_arguments(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitDivertIdentifierWithArguments_arguments(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitDivertIdentifierWithArguments_arguments(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public DivertIdentifierWithArguments_argumentsContext divertIdentifierWithArguments_arguments() {
|
|
DivertIdentifierWithArguments_argumentsContext _localctx = new DivertIdentifierWithArguments_argumentsContext(Context, State);
|
|
EnterRule(_localctx, 16, RULE_divertIdentifierWithArguments_arguments);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 99;
|
|
Match(T__1);
|
|
State = 100;
|
|
expression();
|
|
State = 108;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
while (_la==T__2) {
|
|
{
|
|
{
|
|
State = 101;
|
|
Match(T__2);
|
|
State = 103;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 102;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 105;
|
|
expression();
|
|
}
|
|
}
|
|
State = 110;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
}
|
|
State = 111;
|
|
Match(T__3);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class IdentifierContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(InkBlotAntlrGrammarParser.IDENTIFIER, 0); }
|
|
public IdentifierContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_identifier; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterIdentifier(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitIdentifier(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitIdentifier(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public IdentifierContext identifier() {
|
|
IdentifierContext _localctx = new IdentifierContext(Context, State);
|
|
EnterRule(_localctx, 18, RULE_identifier);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 113;
|
|
Match(IDENTIFIER);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class ExpressionContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(InkBlotAntlrGrammarParser.IDENTIFIER, 0); }
|
|
public ExpressionContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_expression; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterExpression(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitExpression(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitExpression(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public ExpressionContext expression() {
|
|
ExpressionContext _localctx = new ExpressionContext(Context, State);
|
|
EnterRule(_localctx, 20, RULE_expression);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 115;
|
|
Match(IDENTIFIER);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
private static int[] _serializedATN = {
|
|
4,1,10,118,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,7,
|
|
7,7,2,8,7,8,2,9,7,9,2,10,7,10,1,0,1,0,1,1,1,1,4,1,27,8,1,11,1,12,1,28,
|
|
1,1,5,1,32,8,1,10,1,12,1,35,9,1,1,1,5,1,38,8,1,10,1,12,1,41,9,1,1,2,1,
|
|
2,1,3,3,3,46,8,3,1,3,1,3,1,4,1,4,1,4,1,4,5,4,54,8,4,10,4,12,4,57,9,4,1,
|
|
4,3,4,60,8,4,1,5,1,5,1,5,1,5,1,5,1,5,3,5,68,8,5,1,6,1,6,3,6,72,8,6,1,6,
|
|
3,6,75,8,6,1,6,3,6,78,8,6,1,7,3,7,81,8,7,1,7,1,7,3,7,85,8,7,1,7,1,7,3,
|
|
7,89,8,7,1,7,1,7,3,7,93,8,7,5,7,95,8,7,10,7,12,7,98,9,7,1,8,1,8,1,8,1,
|
|
8,3,8,104,8,8,1,8,5,8,107,8,8,10,8,12,8,110,9,8,1,8,1,8,1,9,1,9,1,10,1,
|
|
10,1,10,0,0,11,0,2,4,6,8,10,12,14,16,18,20,0,0,125,0,22,1,0,0,0,2,24,1,
|
|
0,0,0,4,42,1,0,0,0,6,45,1,0,0,0,8,59,1,0,0,0,10,67,1,0,0,0,12,69,1,0,0,
|
|
0,14,80,1,0,0,0,16,99,1,0,0,0,18,113,1,0,0,0,20,115,1,0,0,0,22,23,3,2,
|
|
1,0,23,1,1,0,0,0,24,33,3,4,2,0,25,27,5,10,0,0,26,25,1,0,0,0,27,28,1,0,
|
|
0,0,28,26,1,0,0,0,28,29,1,0,0,0,29,30,1,0,0,0,30,32,3,4,2,0,31,26,1,0,
|
|
0,0,32,35,1,0,0,0,33,31,1,0,0,0,33,34,1,0,0,0,34,39,1,0,0,0,35,33,1,0,
|
|
0,0,36,38,5,10,0,0,37,36,1,0,0,0,38,41,1,0,0,0,39,37,1,0,0,0,39,40,1,0,
|
|
0,0,40,3,1,0,0,0,41,39,1,0,0,0,42,43,3,6,3,0,43,5,1,0,0,0,44,46,5,9,0,
|
|
0,45,44,1,0,0,0,45,46,1,0,0,0,46,47,1,0,0,0,47,48,3,8,4,0,48,7,1,0,0,0,
|
|
49,50,5,5,0,0,50,60,3,12,6,0,51,52,5,6,0,0,52,54,3,12,6,0,53,51,1,0,0,
|
|
0,54,57,1,0,0,0,55,53,1,0,0,0,55,56,1,0,0,0,56,58,1,0,0,0,57,55,1,0,0,
|
|
0,58,60,3,10,5,0,59,49,1,0,0,0,59,55,1,0,0,0,60,9,1,0,0,0,61,68,5,6,0,
|
|
0,62,63,5,6,0,0,63,68,3,12,6,0,64,65,5,7,0,0,65,68,3,12,6,0,66,68,5,7,
|
|
0,0,67,61,1,0,0,0,67,62,1,0,0,0,67,64,1,0,0,0,67,66,1,0,0,0,68,11,1,0,
|
|
0,0,69,71,3,14,7,0,70,72,5,9,0,0,71,70,1,0,0,0,71,72,1,0,0,0,72,74,1,0,
|
|
0,0,73,75,3,16,8,0,74,73,1,0,0,0,74,75,1,0,0,0,75,77,1,0,0,0,76,78,5,9,
|
|
0,0,77,76,1,0,0,0,77,78,1,0,0,0,78,13,1,0,0,0,79,81,5,9,0,0,80,79,1,0,
|
|
0,0,80,81,1,0,0,0,81,82,1,0,0,0,82,84,3,18,9,0,83,85,5,9,0,0,84,83,1,0,
|
|
0,0,84,85,1,0,0,0,85,96,1,0,0,0,86,88,5,1,0,0,87,89,5,9,0,0,88,87,1,0,
|
|
0,0,88,89,1,0,0,0,89,90,1,0,0,0,90,92,3,18,9,0,91,93,5,9,0,0,92,91,1,0,
|
|
0,0,92,93,1,0,0,0,93,95,1,0,0,0,94,86,1,0,0,0,95,98,1,0,0,0,96,94,1,0,
|
|
0,0,96,97,1,0,0,0,97,15,1,0,0,0,98,96,1,0,0,0,99,100,5,2,0,0,100,108,3,
|
|
20,10,0,101,103,5,3,0,0,102,104,5,9,0,0,103,102,1,0,0,0,103,104,1,0,0,
|
|
0,104,105,1,0,0,0,105,107,3,20,10,0,106,101,1,0,0,0,107,110,1,0,0,0,108,
|
|
106,1,0,0,0,108,109,1,0,0,0,109,111,1,0,0,0,110,108,1,0,0,0,111,112,5,
|
|
4,0,0,112,17,1,0,0,0,113,114,5,8,0,0,114,19,1,0,0,0,115,116,5,8,0,0,116,
|
|
21,1,0,0,0,17,28,33,39,45,55,59,67,71,74,77,80,84,88,92,96,103,108
|
|
};
|
|
|
|
public static readonly ATN _ATN =
|
|
new ATNDeserializer().Deserialize(_serializedATN);
|
|
|
|
|
|
}
|