1676 lines
58 KiB
C#
1676 lines
58 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, T__4=5, T__5=6, WS=7, NL=8, MULTILINE_WS=9,
|
|
CONTENT_TEXT_NO_ESCAPE_SIMPLE=10, INLINE_LOGIC_START=11, INLINE_LOGIC_END=12,
|
|
SEQUENCE_TYPE_SYMBOL_ANNOTATION=13, ONCE=14, CYCLE=15, SHUFFLE=16, STOPPING=17,
|
|
SHUFFLE_ONCE=18, SHUFFLE_STOPPING=19, THREAD_ARROW=20, DIVERT_ARROW=21,
|
|
TUNNEL_ARROW=22, IDENTIFIER=23;
|
|
public const int
|
|
RULE_story = 0, RULE_topLevelStatements = 1, RULE_knotLevelStatements = 2,
|
|
RULE_stitchLevelStatements = 3, RULE_innerBlockLevelStatements = 4, RULE_contentText = 5,
|
|
RULE_mixedTextAndLogic = 6, RULE_inlineLogicOrGlueOrTagStart = 7, RULE_inlineLogic = 8,
|
|
RULE_innerLogic = 9, RULE_multiDivert = 10, RULE_divertIdentifierWithArguments = 11,
|
|
RULE_identifier = 12, RULE_expression = 13, RULE_sequenceTypeAnnotation = 14,
|
|
RULE_innerSequenceObjects = 15, RULE_innerMultilineSequenceObjects = 16,
|
|
RULE_singleMultilineSequenceElement = 17, RULE_innerInlineSequenceObjects = 18;
|
|
public static readonly string[] ruleNames = {
|
|
"story", "topLevelStatements", "knotLevelStatements", "stitchLevelStatements",
|
|
"innerBlockLevelStatements", "contentText", "mixedTextAndLogic", "inlineLogicOrGlueOrTagStart",
|
|
"inlineLogic", "innerLogic", "multiDivert", "divertIdentifierWithArguments",
|
|
"identifier", "expression", "sequenceTypeAnnotation", "innerSequenceObjects",
|
|
"innerMultilineSequenceObjects", "singleMultilineSequenceElement", "innerInlineSequenceObjects"
|
|
};
|
|
|
|
private static readonly string[] _LiteralNames = {
|
|
null, "'.'", "'('", "','", "')'", "'-'", "'|'", null, null, null, null,
|
|
"'{'", "'}'", null, null, null, null, null, null, null, "'<-'", "'->'",
|
|
"'->->'"
|
|
};
|
|
private static readonly string[] _SymbolicNames = {
|
|
null, null, null, null, null, null, null, "WS", "NL", "MULTILINE_WS",
|
|
"CONTENT_TEXT_NO_ESCAPE_SIMPLE", "INLINE_LOGIC_START", "INLINE_LOGIC_END",
|
|
"SEQUENCE_TYPE_SYMBOL_ANNOTATION", "ONCE", "CYCLE", "SHUFFLE", "STOPPING",
|
|
"SHUFFLE_ONCE", "SHUFFLE_STOPPING", "THREAD_ARROW", "DIVERT_ARROW", "TUNNEL_ARROW",
|
|
"IDENTIFIER"
|
|
};
|
|
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 = 38;
|
|
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 ContentTextContext[] contentText() {
|
|
return GetRuleContexts<ContentTextContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
|
|
return GetRuleContext<ContentTextContext>(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 {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 41;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 40;
|
|
contentText();
|
|
}
|
|
}
|
|
State = 43;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==CONTENT_TEXT_NO_ESCAPE_SIMPLE );
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class KnotLevelStatementsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext[] contentText() {
|
|
return GetRuleContexts<ContentTextContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
|
|
return GetRuleContext<ContentTextContext>(i);
|
|
}
|
|
public KnotLevelStatementsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_knotLevelStatements; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterKnotLevelStatements(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitKnotLevelStatements(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitKnotLevelStatements(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public KnotLevelStatementsContext knotLevelStatements() {
|
|
KnotLevelStatementsContext _localctx = new KnotLevelStatementsContext(Context, State);
|
|
EnterRule(_localctx, 4, RULE_knotLevelStatements);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 46;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 45;
|
|
contentText();
|
|
}
|
|
}
|
|
State = 48;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==CONTENT_TEXT_NO_ESCAPE_SIMPLE );
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class StitchLevelStatementsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext[] contentText() {
|
|
return GetRuleContexts<ContentTextContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
|
|
return GetRuleContext<ContentTextContext>(i);
|
|
}
|
|
public StitchLevelStatementsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_stitchLevelStatements; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterStitchLevelStatements(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitStitchLevelStatements(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitStitchLevelStatements(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public StitchLevelStatementsContext stitchLevelStatements() {
|
|
StitchLevelStatementsContext _localctx = new StitchLevelStatementsContext(Context, State);
|
|
EnterRule(_localctx, 6, RULE_stitchLevelStatements);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 51;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 50;
|
|
contentText();
|
|
}
|
|
}
|
|
State = 53;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==CONTENT_TEXT_NO_ESCAPE_SIMPLE );
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class InnerBlockLevelStatementsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext[] contentText() {
|
|
return GetRuleContexts<ContentTextContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
|
|
return GetRuleContext<ContentTextContext>(i);
|
|
}
|
|
public InnerBlockLevelStatementsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_innerBlockLevelStatements; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterInnerBlockLevelStatements(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitInnerBlockLevelStatements(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitInnerBlockLevelStatements(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public InnerBlockLevelStatementsContext innerBlockLevelStatements() {
|
|
InnerBlockLevelStatementsContext _localctx = new InnerBlockLevelStatementsContext(Context, State);
|
|
EnterRule(_localctx, 8, RULE_innerBlockLevelStatements);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 56;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 55;
|
|
contentText();
|
|
}
|
|
}
|
|
State = 58;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==CONTENT_TEXT_NO_ESCAPE_SIMPLE );
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class ContentTextContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONTENT_TEXT_NO_ESCAPE_SIMPLE() { return GetToken(InkBlotAntlrGrammarParser.CONTENT_TEXT_NO_ESCAPE_SIMPLE, 0); }
|
|
public ContentTextContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_contentText; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterContentText(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitContentText(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitContentText(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public ContentTextContext contentText() {
|
|
ContentTextContext _localctx = new ContentTextContext(Context, State);
|
|
EnterRule(_localctx, 10, RULE_contentText);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 60;
|
|
Match(CONTENT_TEXT_NO_ESCAPE_SIMPLE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class MixedTextAndLogicContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert() {
|
|
return GetRuleContext<MultiDivertContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext[] contentText() {
|
|
return GetRuleContexts<ContentTextContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
|
|
return GetRuleContext<ContentTextContext>(i);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public InlineLogicOrGlueOrTagStartContext[] inlineLogicOrGlueOrTagStart() {
|
|
return GetRuleContexts<InlineLogicOrGlueOrTagStartContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public InlineLogicOrGlueOrTagStartContext inlineLogicOrGlueOrTagStart(int i) {
|
|
return GetRuleContext<InlineLogicOrGlueOrTagStartContext>(i);
|
|
}
|
|
public MixedTextAndLogicContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_mixedTextAndLogic; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterMixedTextAndLogic(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitMixedTextAndLogic(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitMixedTextAndLogic(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public MixedTextAndLogicContext mixedTextAndLogic() {
|
|
MixedTextAndLogicContext _localctx = new MixedTextAndLogicContext(Context, State);
|
|
EnterRule(_localctx, 12, RULE_mixedTextAndLogic);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 63;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 62;
|
|
contentText();
|
|
}
|
|
break;
|
|
}
|
|
State = 73;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
State = 73;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 66;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==INLINE_LOGIC_START) {
|
|
{
|
|
State = 65;
|
|
inlineLogicOrGlueOrTagStart();
|
|
}
|
|
}
|
|
|
|
State = 68;
|
|
contentText();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
State = 69;
|
|
inlineLogicOrGlueOrTagStart();
|
|
State = 71;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,6,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 70;
|
|
contentText();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
State = 75;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START );
|
|
State = 77;
|
|
multiDivert();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class InlineLogicOrGlueOrTagStartContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public InlineLogicContext inlineLogic() {
|
|
return GetRuleContext<InlineLogicContext>(0);
|
|
}
|
|
public InlineLogicOrGlueOrTagStartContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_inlineLogicOrGlueOrTagStart; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterInlineLogicOrGlueOrTagStart(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitInlineLogicOrGlueOrTagStart(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitInlineLogicOrGlueOrTagStart(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public InlineLogicOrGlueOrTagStartContext inlineLogicOrGlueOrTagStart() {
|
|
InlineLogicOrGlueOrTagStartContext _localctx = new InlineLogicOrGlueOrTagStartContext(Context, State);
|
|
EnterRule(_localctx, 14, RULE_inlineLogicOrGlueOrTagStart);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 79;
|
|
inlineLogic();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class InlineLogicContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INLINE_LOGIC_START() { return GetToken(InkBlotAntlrGrammarParser.INLINE_LOGIC_START, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public InnerLogicContext innerLogic() {
|
|
return GetRuleContext<InnerLogicContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INLINE_LOGIC_END() { return GetToken(InkBlotAntlrGrammarParser.INLINE_LOGIC_END, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS() { return GetToken(InkBlotAntlrGrammarParser.WS, 0); }
|
|
public InlineLogicContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_inlineLogic; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterInlineLogic(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitInlineLogic(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitInlineLogic(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public InlineLogicContext inlineLogic() {
|
|
InlineLogicContext _localctx = new InlineLogicContext(Context, State);
|
|
EnterRule(_localctx, 16, RULE_inlineLogic);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 81;
|
|
Match(INLINE_LOGIC_START);
|
|
State = 83;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 82;
|
|
Match(WS);
|
|
}
|
|
break;
|
|
}
|
|
State = 85;
|
|
innerLogic();
|
|
State = 86;
|
|
Match(INLINE_LOGIC_END);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class InnerLogicContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public SequenceTypeAnnotationContext sequenceTypeAnnotation() {
|
|
return GetRuleContext<SequenceTypeAnnotationContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public InnerSequenceObjectsContext innerSequenceObjects() {
|
|
return GetRuleContext<InnerSequenceObjectsContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS() { return GetToken(InkBlotAntlrGrammarParser.WS, 0); }
|
|
public InnerLogicContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_innerLogic; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterInnerLogic(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitInnerLogic(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitInnerLogic(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public InnerLogicContext innerLogic() {
|
|
InnerLogicContext _localctx = new InnerLogicContext(Context, State);
|
|
EnterRule(_localctx, 18, RULE_innerLogic);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 89;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 88;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 91;
|
|
sequenceTypeAnnotation();
|
|
State = 92;
|
|
innerSequenceObjects();
|
|
}
|
|
}
|
|
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 ITerminalNode THREAD_ARROW() { return GetToken(InkBlotAntlrGrammarParser.THREAD_ARROW, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext[] divertIdentifierWithArguments() {
|
|
return GetRuleContexts<DivertIdentifierWithArgumentsContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments(int i) {
|
|
return GetRuleContext<DivertIdentifierWithArgumentsContext>(i);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TUNNEL_ARROW() { return GetToken(InkBlotAntlrGrammarParser.TUNNEL_ARROW, 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 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, 20, RULE_multiDivert);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 95;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 94;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 126;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,15,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 97;
|
|
Match(THREAD_ARROW);
|
|
State = 98;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
State = 101;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 99;
|
|
Match(DIVERT_ARROW);
|
|
State = 100;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
}
|
|
State = 103;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==DIVERT_ARROW );
|
|
State = 105;
|
|
Match(TUNNEL_ARROW);
|
|
State = 106;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
State = 110;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 108;
|
|
Match(DIVERT_ARROW);
|
|
State = 109;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
}
|
|
State = 112;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==DIVERT_ARROW );
|
|
State = 114;
|
|
Match(TUNNEL_ARROW);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
State = 118;
|
|
ErrorHandler.Sync(this);
|
|
_alt = 1;
|
|
do {
|
|
switch (_alt) {
|
|
case 1:
|
|
{
|
|
{
|
|
State = 116;
|
|
Match(DIVERT_ARROW);
|
|
State = 117;
|
|
divertIdentifierWithArguments();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
State = 120;
|
|
ErrorHandler.Sync(this);
|
|
_alt = Interpreter.AdaptivePredict(TokenStream,14,Context);
|
|
} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
|
|
State = 122;
|
|
Match(DIVERT_ARROW);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
State = 124;
|
|
Match(TUNNEL_ARROW);
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
State = 125;
|
|
Match(DIVERT_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 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);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
|
|
return GetRuleContexts<ExpressionContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
|
|
return GetRuleContext<ExpressionContext>(i);
|
|
}
|
|
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, 22, RULE_divertIdentifierWithArguments);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 129;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 128;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 131;
|
|
identifier();
|
|
State = 133;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,17,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 132;
|
|
Match(WS);
|
|
}
|
|
break;
|
|
}
|
|
State = 145;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
while (_la==T__0) {
|
|
{
|
|
{
|
|
State = 135;
|
|
Match(T__0);
|
|
State = 137;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 136;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 139;
|
|
identifier();
|
|
State = 141;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 140;
|
|
Match(WS);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
State = 147;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
}
|
|
State = 149;
|
|
ErrorHandler.Sync(this);
|
|
switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) {
|
|
case 1:
|
|
{
|
|
State = 148;
|
|
Match(WS);
|
|
}
|
|
break;
|
|
}
|
|
State = 162;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==T__1) {
|
|
{
|
|
State = 151;
|
|
Match(T__1);
|
|
State = 152;
|
|
expression();
|
|
State = 157;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
while (_la==T__2) {
|
|
{
|
|
{
|
|
State = 153;
|
|
Match(T__2);
|
|
State = 154;
|
|
expression();
|
|
}
|
|
}
|
|
State = 159;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
}
|
|
State = 160;
|
|
Match(T__3);
|
|
}
|
|
}
|
|
|
|
State = 165;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 164;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
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, 24, RULE_identifier);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 167;
|
|
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, 26, RULE_expression);
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 169;
|
|
Match(IDENTIFIER);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class SequenceTypeAnnotationContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEQUENCE_TYPE_SYMBOL_ANNOTATION() { return GetToken(InkBlotAntlrGrammarParser.SEQUENCE_TYPE_SYMBOL_ANNOTATION, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ONCE() { return GetToken(InkBlotAntlrGrammarParser.ONCE, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CYCLE() { return GetToken(InkBlotAntlrGrammarParser.CYCLE, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SHUFFLE() { return GetToken(InkBlotAntlrGrammarParser.SHUFFLE, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STOPPING() { return GetToken(InkBlotAntlrGrammarParser.STOPPING, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SHUFFLE_ONCE() { return GetToken(InkBlotAntlrGrammarParser.SHUFFLE_ONCE, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SHUFFLE_STOPPING() { return GetToken(InkBlotAntlrGrammarParser.SHUFFLE_STOPPING, 0); }
|
|
public SequenceTypeAnnotationContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_sequenceTypeAnnotation; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterSequenceTypeAnnotation(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitSequenceTypeAnnotation(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitSequenceTypeAnnotation(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public SequenceTypeAnnotationContext sequenceTypeAnnotation() {
|
|
SequenceTypeAnnotationContext _localctx = new SequenceTypeAnnotationContext(Context, State);
|
|
EnterRule(_localctx, 28, RULE_sequenceTypeAnnotation);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 171;
|
|
_la = TokenStream.LA(1);
|
|
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1040384L) != 0)) ) {
|
|
ErrorHandler.RecoverInline(this);
|
|
}
|
|
else {
|
|
ErrorHandler.ReportMatch(this);
|
|
Consume();
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class InnerSequenceObjectsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NL() { return GetToken(InkBlotAntlrGrammarParser.NL, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public InnerMultilineSequenceObjectsContext innerMultilineSequenceObjects() {
|
|
return GetRuleContext<InnerMultilineSequenceObjectsContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public InnerInlineSequenceObjectsContext innerInlineSequenceObjects() {
|
|
return GetRuleContext<InnerInlineSequenceObjectsContext>(0);
|
|
}
|
|
public InnerSequenceObjectsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_innerSequenceObjects; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterInnerSequenceObjects(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitInnerSequenceObjects(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitInnerSequenceObjects(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public InnerSequenceObjectsContext innerSequenceObjects() {
|
|
InnerSequenceObjectsContext _localctx = new InnerSequenceObjectsContext(Context, State);
|
|
EnterRule(_localctx, 30, RULE_innerSequenceObjects);
|
|
try {
|
|
State = 176;
|
|
ErrorHandler.Sync(this);
|
|
switch (TokenStream.LA(1)) {
|
|
case NL:
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 173;
|
|
Match(NL);
|
|
State = 174;
|
|
innerMultilineSequenceObjects();
|
|
}
|
|
break;
|
|
case T__5:
|
|
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
|
|
case INLINE_LOGIC_START:
|
|
EnterOuterAlt(_localctx, 2);
|
|
{
|
|
State = 175;
|
|
innerInlineSequenceObjects();
|
|
}
|
|
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 InnerMultilineSequenceObjectsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public SingleMultilineSequenceElementContext[] singleMultilineSequenceElement() {
|
|
return GetRuleContexts<SingleMultilineSequenceElementContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public SingleMultilineSequenceElementContext singleMultilineSequenceElement(int i) {
|
|
return GetRuleContext<SingleMultilineSequenceElementContext>(i);
|
|
}
|
|
public InnerMultilineSequenceObjectsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_innerMultilineSequenceObjects; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterInnerMultilineSequenceObjects(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitInnerMultilineSequenceObjects(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitInnerMultilineSequenceObjects(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public InnerMultilineSequenceObjectsContext innerMultilineSequenceObjects() {
|
|
InnerMultilineSequenceObjectsContext _localctx = new InnerMultilineSequenceObjectsContext(Context, State);
|
|
EnterRule(_localctx, 32, RULE_innerMultilineSequenceObjects);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 179;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 178;
|
|
singleMultilineSequenceElement();
|
|
}
|
|
}
|
|
State = 181;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==T__4 || _la==WS );
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public partial class SingleMultilineSequenceElementContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public InnerBlockLevelStatementsContext innerBlockLevelStatements() {
|
|
return GetRuleContext<InnerBlockLevelStatementsContext>(0);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MULTILINE_WS() { return GetToken(InkBlotAntlrGrammarParser.MULTILINE_WS, 0); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
|
|
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
|
|
return GetToken(InkBlotAntlrGrammarParser.WS, i);
|
|
}
|
|
public SingleMultilineSequenceElementContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_singleMultilineSequenceElement; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterSingleMultilineSequenceElement(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitSingleMultilineSequenceElement(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitSingleMultilineSequenceElement(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public SingleMultilineSequenceElementContext singleMultilineSequenceElement() {
|
|
SingleMultilineSequenceElementContext _localctx = new SingleMultilineSequenceElementContext(Context, State);
|
|
EnterRule(_localctx, 34, RULE_singleMultilineSequenceElement);
|
|
int _la;
|
|
try {
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
State = 184;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 183;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 186;
|
|
Match(T__4);
|
|
State = 188;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==WS) {
|
|
{
|
|
State = 187;
|
|
Match(WS);
|
|
}
|
|
}
|
|
|
|
State = 192;
|
|
ErrorHandler.Sync(this);
|
|
switch (TokenStream.LA(1)) {
|
|
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
|
|
{
|
|
State = 190;
|
|
innerBlockLevelStatements();
|
|
}
|
|
break;
|
|
case MULTILINE_WS:
|
|
{
|
|
State = 191;
|
|
Match(MULTILINE_WS);
|
|
}
|
|
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 InnerInlineSequenceObjectsContext : ParserRuleContext {
|
|
[System.Diagnostics.DebuggerNonUserCode] public MixedTextAndLogicContext[] mixedTextAndLogic() {
|
|
return GetRuleContexts<MixedTextAndLogicContext>();
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode] public MixedTextAndLogicContext mixedTextAndLogic(int i) {
|
|
return GetRuleContext<MixedTextAndLogicContext>(i);
|
|
}
|
|
public InnerInlineSequenceObjectsContext(ParserRuleContext parent, int invokingState)
|
|
: base(parent, invokingState)
|
|
{
|
|
}
|
|
public override int RuleIndex { get { return RULE_innerInlineSequenceObjects; } }
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void EnterRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.EnterInnerInlineSequenceObjects(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override void ExitRule(IParseTreeListener listener) {
|
|
IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
|
|
if (typedListener != null) typedListener.ExitInnerInlineSequenceObjects(this);
|
|
}
|
|
[System.Diagnostics.DebuggerNonUserCode]
|
|
public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
|
|
IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
|
|
if (typedVisitor != null) return typedVisitor.VisitInnerInlineSequenceObjects(this);
|
|
else return visitor.VisitChildren(this);
|
|
}
|
|
}
|
|
|
|
[RuleVersion(0)]
|
|
public InnerInlineSequenceObjectsContext innerInlineSequenceObjects() {
|
|
InnerInlineSequenceObjectsContext _localctx = new InnerInlineSequenceObjectsContext(Context, State);
|
|
EnterRule(_localctx, 36, RULE_innerInlineSequenceObjects);
|
|
int _la;
|
|
try {
|
|
State = 212;
|
|
ErrorHandler.Sync(this);
|
|
switch (TokenStream.LA(1)) {
|
|
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
|
|
case INLINE_LOGIC_START:
|
|
EnterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
State = 194;
|
|
mixedTextAndLogic();
|
|
State = 201;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
while (_la==T__5) {
|
|
{
|
|
{
|
|
State = 195;
|
|
Match(T__5);
|
|
State = 197;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START) {
|
|
{
|
|
State = 196;
|
|
mixedTextAndLogic();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
State = 203;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case T__5:
|
|
EnterOuterAlt(_localctx, 2);
|
|
{
|
|
State = 208;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
State = 204;
|
|
Match(T__5);
|
|
State = 206;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
if (_la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START) {
|
|
{
|
|
State = 205;
|
|
mixedTextAndLogic();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
State = 210;
|
|
ErrorHandler.Sync(this);
|
|
_la = TokenStream.LA(1);
|
|
} while ( _la==T__5 );
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
ErrorHandler.ReportError(this, re);
|
|
ErrorHandler.Recover(this, re);
|
|
}
|
|
finally {
|
|
ExitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
private static int[] _serializedATN = {
|
|
4,1,23,215,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,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7,14,
|
|
2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,1,0,1,0,1,1,4,1,42,8,1,11,1,12,
|
|
1,43,1,2,4,2,47,8,2,11,2,12,2,48,1,3,4,3,52,8,3,11,3,12,3,53,1,4,4,4,57,
|
|
8,4,11,4,12,4,58,1,5,1,5,1,6,3,6,64,8,6,1,6,3,6,67,8,6,1,6,1,6,1,6,3,6,
|
|
72,8,6,4,6,74,8,6,11,6,12,6,75,1,6,1,6,1,7,1,7,1,8,1,8,3,8,84,8,8,1,8,
|
|
1,8,1,8,1,9,3,9,90,8,9,1,9,1,9,1,9,1,10,3,10,96,8,10,1,10,1,10,1,10,1,
|
|
10,4,10,102,8,10,11,10,12,10,103,1,10,1,10,1,10,1,10,1,10,4,10,111,8,10,
|
|
11,10,12,10,112,1,10,1,10,1,10,1,10,4,10,119,8,10,11,10,12,10,120,1,10,
|
|
1,10,1,10,1,10,3,10,127,8,10,1,11,3,11,130,8,11,1,11,1,11,3,11,134,8,11,
|
|
1,11,1,11,3,11,138,8,11,1,11,1,11,3,11,142,8,11,5,11,144,8,11,10,11,12,
|
|
11,147,9,11,1,11,3,11,150,8,11,1,11,1,11,1,11,1,11,5,11,156,8,11,10,11,
|
|
12,11,159,9,11,1,11,1,11,3,11,163,8,11,1,11,3,11,166,8,11,1,12,1,12,1,
|
|
13,1,13,1,14,1,14,1,15,1,15,1,15,3,15,177,8,15,1,16,4,16,180,8,16,11,16,
|
|
12,16,181,1,17,3,17,185,8,17,1,17,1,17,3,17,189,8,17,1,17,1,17,3,17,193,
|
|
8,17,1,18,1,18,1,18,3,18,198,8,18,5,18,200,8,18,10,18,12,18,203,9,18,1,
|
|
18,1,18,3,18,207,8,18,4,18,209,8,18,11,18,12,18,210,3,18,213,8,18,1,18,
|
|
0,0,19,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,0,1,1,0,13,
|
|
19,234,0,38,1,0,0,0,2,41,1,0,0,0,4,46,1,0,0,0,6,51,1,0,0,0,8,56,1,0,0,
|
|
0,10,60,1,0,0,0,12,63,1,0,0,0,14,79,1,0,0,0,16,81,1,0,0,0,18,89,1,0,0,
|
|
0,20,95,1,0,0,0,22,129,1,0,0,0,24,167,1,0,0,0,26,169,1,0,0,0,28,171,1,
|
|
0,0,0,30,176,1,0,0,0,32,179,1,0,0,0,34,184,1,0,0,0,36,212,1,0,0,0,38,39,
|
|
3,2,1,0,39,1,1,0,0,0,40,42,3,10,5,0,41,40,1,0,0,0,42,43,1,0,0,0,43,41,
|
|
1,0,0,0,43,44,1,0,0,0,44,3,1,0,0,0,45,47,3,10,5,0,46,45,1,0,0,0,47,48,
|
|
1,0,0,0,48,46,1,0,0,0,48,49,1,0,0,0,49,5,1,0,0,0,50,52,3,10,5,0,51,50,
|
|
1,0,0,0,52,53,1,0,0,0,53,51,1,0,0,0,53,54,1,0,0,0,54,7,1,0,0,0,55,57,3,
|
|
10,5,0,56,55,1,0,0,0,57,58,1,0,0,0,58,56,1,0,0,0,58,59,1,0,0,0,59,9,1,
|
|
0,0,0,60,61,5,10,0,0,61,11,1,0,0,0,62,64,3,10,5,0,63,62,1,0,0,0,63,64,
|
|
1,0,0,0,64,73,1,0,0,0,65,67,3,14,7,0,66,65,1,0,0,0,66,67,1,0,0,0,67,68,
|
|
1,0,0,0,68,74,3,10,5,0,69,71,3,14,7,0,70,72,3,10,5,0,71,70,1,0,0,0,71,
|
|
72,1,0,0,0,72,74,1,0,0,0,73,66,1,0,0,0,73,69,1,0,0,0,74,75,1,0,0,0,75,
|
|
73,1,0,0,0,75,76,1,0,0,0,76,77,1,0,0,0,77,78,3,20,10,0,78,13,1,0,0,0,79,
|
|
80,3,16,8,0,80,15,1,0,0,0,81,83,5,11,0,0,82,84,5,7,0,0,83,82,1,0,0,0,83,
|
|
84,1,0,0,0,84,85,1,0,0,0,85,86,3,18,9,0,86,87,5,12,0,0,87,17,1,0,0,0,88,
|
|
90,5,7,0,0,89,88,1,0,0,0,89,90,1,0,0,0,90,91,1,0,0,0,91,92,3,28,14,0,92,
|
|
93,3,30,15,0,93,19,1,0,0,0,94,96,5,7,0,0,95,94,1,0,0,0,95,96,1,0,0,0,96,
|
|
126,1,0,0,0,97,98,5,20,0,0,98,127,3,22,11,0,99,100,5,21,0,0,100,102,3,
|
|
22,11,0,101,99,1,0,0,0,102,103,1,0,0,0,103,101,1,0,0,0,103,104,1,0,0,0,
|
|
104,105,1,0,0,0,105,106,5,22,0,0,106,107,3,22,11,0,107,127,1,0,0,0,108,
|
|
109,5,21,0,0,109,111,3,22,11,0,110,108,1,0,0,0,111,112,1,0,0,0,112,110,
|
|
1,0,0,0,112,113,1,0,0,0,113,114,1,0,0,0,114,115,5,22,0,0,115,127,1,0,0,
|
|
0,116,117,5,21,0,0,117,119,3,22,11,0,118,116,1,0,0,0,119,120,1,0,0,0,120,
|
|
118,1,0,0,0,120,121,1,0,0,0,121,122,1,0,0,0,122,123,5,21,0,0,123,127,1,
|
|
0,0,0,124,127,5,22,0,0,125,127,5,21,0,0,126,97,1,0,0,0,126,101,1,0,0,0,
|
|
126,110,1,0,0,0,126,118,1,0,0,0,126,124,1,0,0,0,126,125,1,0,0,0,127,21,
|
|
1,0,0,0,128,130,5,7,0,0,129,128,1,0,0,0,129,130,1,0,0,0,130,131,1,0,0,
|
|
0,131,133,3,24,12,0,132,134,5,7,0,0,133,132,1,0,0,0,133,134,1,0,0,0,134,
|
|
145,1,0,0,0,135,137,5,1,0,0,136,138,5,7,0,0,137,136,1,0,0,0,137,138,1,
|
|
0,0,0,138,139,1,0,0,0,139,141,3,24,12,0,140,142,5,7,0,0,141,140,1,0,0,
|
|
0,141,142,1,0,0,0,142,144,1,0,0,0,143,135,1,0,0,0,144,147,1,0,0,0,145,
|
|
143,1,0,0,0,145,146,1,0,0,0,146,149,1,0,0,0,147,145,1,0,0,0,148,150,5,
|
|
7,0,0,149,148,1,0,0,0,149,150,1,0,0,0,150,162,1,0,0,0,151,152,5,2,0,0,
|
|
152,157,3,26,13,0,153,154,5,3,0,0,154,156,3,26,13,0,155,153,1,0,0,0,156,
|
|
159,1,0,0,0,157,155,1,0,0,0,157,158,1,0,0,0,158,160,1,0,0,0,159,157,1,
|
|
0,0,0,160,161,5,4,0,0,161,163,1,0,0,0,162,151,1,0,0,0,162,163,1,0,0,0,
|
|
163,165,1,0,0,0,164,166,5,7,0,0,165,164,1,0,0,0,165,166,1,0,0,0,166,23,
|
|
1,0,0,0,167,168,5,23,0,0,168,25,1,0,0,0,169,170,5,23,0,0,170,27,1,0,0,
|
|
0,171,172,7,0,0,0,172,29,1,0,0,0,173,174,5,8,0,0,174,177,3,32,16,0,175,
|
|
177,3,36,18,0,176,173,1,0,0,0,176,175,1,0,0,0,177,31,1,0,0,0,178,180,3,
|
|
34,17,0,179,178,1,0,0,0,180,181,1,0,0,0,181,179,1,0,0,0,181,182,1,0,0,
|
|
0,182,33,1,0,0,0,183,185,5,7,0,0,184,183,1,0,0,0,184,185,1,0,0,0,185,186,
|
|
1,0,0,0,186,188,5,5,0,0,187,189,5,7,0,0,188,187,1,0,0,0,188,189,1,0,0,
|
|
0,189,192,1,0,0,0,190,193,3,8,4,0,191,193,5,9,0,0,192,190,1,0,0,0,192,
|
|
191,1,0,0,0,193,35,1,0,0,0,194,201,3,12,6,0,195,197,5,6,0,0,196,198,3,
|
|
12,6,0,197,196,1,0,0,0,197,198,1,0,0,0,198,200,1,0,0,0,199,195,1,0,0,0,
|
|
200,203,1,0,0,0,201,199,1,0,0,0,201,202,1,0,0,0,202,213,1,0,0,0,203,201,
|
|
1,0,0,0,204,206,5,6,0,0,205,207,3,12,6,0,206,205,1,0,0,0,206,207,1,0,0,
|
|
0,207,209,1,0,0,0,208,204,1,0,0,0,209,210,1,0,0,0,210,208,1,0,0,0,210,
|
|
211,1,0,0,0,211,213,1,0,0,0,212,194,1,0,0,0,212,208,1,0,0,0,213,37,1,0,
|
|
0,0,35,43,48,53,58,63,66,71,73,75,83,89,95,103,112,120,126,129,133,137,
|
|
141,145,149,157,162,165,176,181,184,188,192,197,201,206,210,212
|
|
};
|
|
|
|
public static readonly ATN _ATN =
|
|
new ATNDeserializer().Deserialize(_serializedATN);
|
|
|
|
|
|
}
|