redglow/inkblot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
eed28168ad0767559c086070510cfc39908abf0c
inkblot/InkBlot/Generated/InkBlotAntlrGrammarParser.cs
Mattia Belletti eed28168ad feat: temporary grammar
2025-03-01 12:30:36 +01:00

2247 lines
80 KiB
C#
Raw Blame History

//------------------------------------------------------------------------------
// <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 C:/Users/mbelletti/RiderProjects/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_topLevelStatement = 2,
RULE_knotLevelStatements = 3, RULE_stitchLevelStatements = 4, RULE_innerBlockLevelStatements = 5,
RULE_contentText = 6, RULE_mixedTextAndLogic = 7, RULE_inlineLogicOrGlueOrTagStart = 8,
RULE_inlineLogic = 9, RULE_innerLogic = 10, RULE_multiDivert = 11, RULE_multiDivert_withoutWS = 12,
RULE_multiDivertArrows_tail = 13, RULE_divertIdentifierWithArguments = 14,
RULE_divertIdentifierWithArguments_name = 15, RULE_divertIdentifierWithArguments_arguments = 16,
RULE_identifier = 17, RULE_expression = 18, RULE_sequenceTypeAnnotation = 19,
RULE_innerSequenceObjects = 20, RULE_innerMultilineSequenceObjects = 21,
RULE_singleMultilineSequenceElement = 22, RULE_innerInlineSequenceObjects = 23;
public static readonly string[] ruleNames = {
"story", "topLevelStatements", "topLevelStatement", "knotLevelStatements",
"stitchLevelStatements", "innerBlockLevelStatements", "contentText", "mixedTextAndLogic",
"inlineLogicOrGlueOrTagStart", "inlineLogic", "innerLogic", "multiDivert",
"multiDivert_withoutWS", "multiDivertArrows_tail", "divertIdentifierWithArguments",
"divertIdentifierWithArguments_name", "divertIdentifierWithArguments_arguments",
"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 = 48;
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);
}
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 = 51;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
do {
{
{
State = 50;
topLevelStatement();
}
}
State = 53;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 7341184L) != 0) );
}
}
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);
}
[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText() {
return GetRuleContext<ContentTextContext>(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 {
State = 57;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case WS:
case THREAD_ARROW:
case DIVERT_ARROW:
case TUNNEL_ARROW:
EnterOuterAlt(_localctx, 1);
{
State = 55;
multiDivert();
}
break;
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
EnterOuterAlt(_localctx, 2);
{
State = 56;
contentText();
}
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 KnotLevelStatementsContext : ParserRuleContext {
[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 MultiDivertContext[] multiDivert() {
return GetRuleContexts<MultiDivertContext>();
}
[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert(int i) {
return GetRuleContext<MultiDivertContext>(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, 6, RULE_knotLevelStatements);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 61;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
do {
{
State = 61;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
{
State = 59;
contentText();
}
break;
case WS:
case THREAD_ARROW:
case DIVERT_ARROW:
case TUNNEL_ARROW:
{
State = 60;
multiDivert();
}
break;
default:
throw new NoViableAltException(this);
}
}
State = 63;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 7341184L) != 0) );
}
}
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);
}
[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext[] multiDivert() {
return GetRuleContexts<MultiDivertContext>();
}
[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert(int i) {
return GetRuleContext<MultiDivertContext>(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, 8, RULE_stitchLevelStatements);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 67;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
do {
{
State = 67;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
{
State = 65;
contentText();
}
break;
case WS:
case THREAD_ARROW:
case DIVERT_ARROW:
case TUNNEL_ARROW:
{
State = 66;
multiDivert();
}
break;
default:
throw new NoViableAltException(this);
}
}
State = 69;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 7341184L) != 0) );
}
}
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);
}
[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext[] multiDivert() {
return GetRuleContexts<MultiDivertContext>();
}
[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert(int i) {
return GetRuleContext<MultiDivertContext>(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, 10, RULE_innerBlockLevelStatements);
try {
int _alt;
EnterOuterAlt(_localctx, 1);
{
State = 73;
ErrorHandler.Sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
State = 73;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
{
State = 71;
contentText();
}
break;
case WS:
case THREAD_ARROW:
case DIVERT_ARROW:
case TUNNEL_ARROW:
{
State = 72;
multiDivert();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
default:
throw new NoViableAltException(this);
}
State = 75;
ErrorHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(TokenStream,7,Context);
} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
}
}
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, 12, RULE_contentText);
try {
EnterOuterAlt(_localctx, 1);
{
State = 77;
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, 14, RULE_mixedTextAndLogic);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 80;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,8,Context) ) {
case 1:
{
State = 79;
contentText();
}
break;
}
State = 90;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
do {
{
State = 90;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) {
case 1:
{
State = 83;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==INLINE_LOGIC_START) {
{
State = 82;
inlineLogicOrGlueOrTagStart();
}
}
State = 85;
contentText();
}
break;
case 2:
{
State = 86;
inlineLogicOrGlueOrTagStart();
State = 88;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) {
case 1:
{
State = 87;
contentText();
}
break;
}
}
break;
}
}
State = 92;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
} while ( _la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START );
State = 94;
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, 16, RULE_inlineLogicOrGlueOrTagStart);
try {
EnterOuterAlt(_localctx, 1);
{
State = 96;
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 GetTokens(InkBlotAntlrGrammarParser.WS); }
[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
return GetToken(InkBlotAntlrGrammarParser.WS, i);
}
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, 18, RULE_inlineLogic);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 98;
Match(INLINE_LOGIC_START);
State = 100;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) {
case 1:
{
State = 99;
Match(WS);
}
break;
}
State = 102;
innerLogic();
State = 104;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==WS) {
{
State = 103;
Match(WS);
}
}
State = 106;
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, 20, RULE_innerLogic);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 109;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==WS) {
{
State = 108;
Match(WS);
}
}
State = 111;
sequenceTypeAnnotation();
State = 112;
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 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, 22, RULE_multiDivert);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 115;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==WS) {
{
State = 114;
Match(WS);
}
}
State = 117;
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, 24, RULE_multiDivert_withoutWS);
try {
int _alt;
State = 129;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case THREAD_ARROW:
_localctx = new MultiDivertThreadContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 119;
Match(THREAD_ARROW);
State = 120;
divertIdentifierWithArguments();
}
break;
case DIVERT_ARROW:
case TUNNEL_ARROW:
_localctx = new MultiDivertArrowsContext(_localctx);
EnterOuterAlt(_localctx, 2);
{
State = 125;
ErrorHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(TokenStream,17,Context);
while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
State = 121;
Match(DIVERT_ARROW);
State = 122;
divertIdentifierWithArguments();
}
}
}
State = 127;
ErrorHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(TokenStream,17,Context);
}
State = 128;
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, 26, RULE_multiDivertArrows_tail);
try {
State = 137;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) {
case 1:
_localctx = new MultiDivertArrows_tailDefaultChoiceContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 131;
Match(DIVERT_ARROW);
}
break;
case 2:
_localctx = new MultiDivertArrows_tailDivertContext(_localctx);
EnterOuterAlt(_localctx, 2);
{
State = 132;
Match(DIVERT_ARROW);
State = 133;
divertIdentifierWithArguments();
}
break;
case 3:
_localctx = new MultiDivertArrows_tailTunnelWithReplacementContext(_localctx);
EnterOuterAlt(_localctx, 3);
{
State = 134;
Match(TUNNEL_ARROW);
State = 135;
divertIdentifierWithArguments();
}
break;
case 4:
_localctx = new MultiDivertArrows_tailTunnelContext(_localctx);
EnterOuterAlt(_localctx, 4);
{
State = 136;
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 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, 28, RULE_divertIdentifierWithArguments);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 140;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) {
case 1:
{
State = 139;
Match(WS);
}
break;
}
State = 142;
divertIdentifierWithArguments_name();
State = 144;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) {
case 1:
{
State = 143;
Match(WS);
}
break;
}
State = 160;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==T__0) {
{
State = 146;
Match(T__0);
State = 147;
expression();
State = 155;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la==T__1) {
{
{
State = 148;
Match(T__1);
State = 150;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==WS) {
{
State = 149;
Match(WS);
}
}
State = 152;
expression();
}
}
State = 157;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
State = 158;
Match(T__2);
}
}
State = 163;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,25,Context) ) {
case 1:
{
State = 162;
Match(WS);
}
break;
}
}
}
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, 30, RULE_divertIdentifierWithArguments_name);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 166;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==WS) {
{
State = 165;
Match(WS);
}
}
State = 168;
identifier();
State = 170;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,27,Context) ) {
case 1:
{
State = 169;
Match(WS);
}
break;
}
State = 182;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la==T__3) {
{
{
State = 172;
Match(T__3);
State = 174;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==WS) {
{
State = 173;
Match(WS);
}
}
State = 176;
identifier();
State = 178;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) {
case 1:
{
State = 177;
Match(WS);
}
break;
}
}
}
State = 184;
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, 32, RULE_divertIdentifierWithArguments_arguments);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 185;
Match(T__0);
State = 186;
expression();
State = 194;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la==T__1) {
{
{
State = 187;
Match(T__1);
State = 189;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==WS) {
{
State = 188;
Match(WS);
}
}
State = 191;
expression();
}
}
State = 196;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
State = 197;
Match(T__2);
}
}
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, 34, RULE_identifier);
try {
EnterOuterAlt(_localctx, 1);
{
State = 199;
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, 36, RULE_expression);
try {
EnterOuterAlt(_localctx, 1);
{
State = 201;
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 {
public IToken op;
[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, 38, RULE_sequenceTypeAnnotation);
try {
State = 210;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case SEQUENCE_TYPE_SYMBOL_ANNOTATION:
EnterOuterAlt(_localctx, 1);
{
State = 203;
_localctx.op = Match(SEQUENCE_TYPE_SYMBOL_ANNOTATION);
}
break;
case ONCE:
EnterOuterAlt(_localctx, 2);
{
State = 204;
Match(ONCE);
}
break;
case CYCLE:
EnterOuterAlt(_localctx, 3);
{
State = 205;
Match(CYCLE);
}
break;
case SHUFFLE:
EnterOuterAlt(_localctx, 4);
{
State = 206;
Match(SHUFFLE);
}
break;
case STOPPING:
EnterOuterAlt(_localctx, 5);
{
State = 207;
Match(STOPPING);
}
break;
case SHUFFLE_ONCE:
EnterOuterAlt(_localctx, 6);
{
State = 208;
Match(SHUFFLE_ONCE);
}
break;
case SHUFFLE_STOPPING:
EnterOuterAlt(_localctx, 7);
{
State = 209;
Match(SHUFFLE_STOPPING);
}
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 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, 40, RULE_innerSequenceObjects);
try {
State = 215;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case NL:
EnterOuterAlt(_localctx, 1);
{
State = 212;
Match(NL);
State = 213;
innerMultilineSequenceObjects();
}
break;
case T__5:
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
case INLINE_LOGIC_START:
EnterOuterAlt(_localctx, 2);
{
State = 214;
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, 42, RULE_innerMultilineSequenceObjects);
try {
int _alt;
EnterOuterAlt(_localctx, 1);
{
State = 218;
ErrorHandler.Sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
State = 217;
singleMultilineSequenceElement();
}
}
break;
default:
throw new NoViableAltException(this);
}
State = 220;
ErrorHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(TokenStream,35,Context);
} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
}
}
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, 44, RULE_singleMultilineSequenceElement);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 223;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==WS) {
{
State = 222;
Match(WS);
}
}
State = 225;
Match(T__4);
State = 227;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) {
case 1:
{
State = 226;
Match(WS);
}
break;
}
State = 231;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case WS:
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
case THREAD_ARROW:
case DIVERT_ARROW:
case TUNNEL_ARROW:
{
State = 229;
innerBlockLevelStatements();
}
break;
case MULTILINE_WS:
{
State = 230;
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, 46, RULE_innerInlineSequenceObjects);
int _la;
try {
State = 251;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1)) {
case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
case INLINE_LOGIC_START:
EnterOuterAlt(_localctx, 1);
{
{
State = 233;
mixedTextAndLogic();
State = 240;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la==T__5) {
{
{
State = 234;
Match(T__5);
State = 236;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START) {
{
State = 235;
mixedTextAndLogic();
}
}
}
}
State = 242;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
}
}
break;
case T__5:
EnterOuterAlt(_localctx, 2);
{
State = 247;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
do {
{
{
State = 243;
Match(T__5);
State = 245;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START) {
{
State = 244;
mixedTextAndLogic();
}
}
}
}
State = 249;
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,254,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,2,19,7,19,2,20,7,20,2,21,7,21,
2,22,7,22,2,23,7,23,1,0,1,0,1,1,4,1,52,8,1,11,1,12,1,53,1,2,1,2,3,2,58,
8,2,1,3,1,3,4,3,62,8,3,11,3,12,3,63,1,4,1,4,4,4,68,8,4,11,4,12,4,69,1,
5,1,5,4,5,74,8,5,11,5,12,5,75,1,6,1,6,1,7,3,7,81,8,7,1,7,3,7,84,8,7,1,
7,1,7,1,7,3,7,89,8,7,4,7,91,8,7,11,7,12,7,92,1,7,1,7,1,8,1,8,1,9,1,9,3,
9,101,8,9,1,9,1,9,3,9,105,8,9,1,9,1,9,1,10,3,10,110,8,10,1,10,1,10,1,10,
1,11,3,11,116,8,11,1,11,1,11,1,12,1,12,1,12,1,12,5,12,124,8,12,10,12,12,
12,127,9,12,1,12,3,12,130,8,12,1,13,1,13,1,13,1,13,1,13,1,13,3,13,138,
8,13,1,14,3,14,141,8,14,1,14,1,14,3,14,145,8,14,1,14,1,14,1,14,1,14,3,
14,151,8,14,1,14,5,14,154,8,14,10,14,12,14,157,9,14,1,14,1,14,3,14,161,
8,14,1,14,3,14,164,8,14,1,15,3,15,167,8,15,1,15,1,15,3,15,171,8,15,1,15,
1,15,3,15,175,8,15,1,15,1,15,3,15,179,8,15,5,15,181,8,15,10,15,12,15,184,
9,15,1,16,1,16,1,16,1,16,3,16,190,8,16,1,16,5,16,193,8,16,10,16,12,16,
196,9,16,1,16,1,16,1,17,1,17,1,18,1,18,1,19,1,19,1,19,1,19,1,19,1,19,1,
19,3,19,211,8,19,1,20,1,20,1,20,3,20,216,8,20,1,21,4,21,219,8,21,11,21,
12,21,220,1,22,3,22,224,8,22,1,22,1,22,3,22,228,8,22,1,22,1,22,3,22,232,
8,22,1,23,1,23,1,23,3,23,237,8,23,5,23,239,8,23,10,23,12,23,242,9,23,1,
23,1,23,3,23,246,8,23,4,23,248,8,23,11,23,12,23,249,3,23,252,8,23,1,23,
0,0,24,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,
46,0,0,280,0,48,1,0,0,0,2,51,1,0,0,0,4,57,1,0,0,0,6,61,1,0,0,0,8,67,1,
0,0,0,10,73,1,0,0,0,12,77,1,0,0,0,14,80,1,0,0,0,16,96,1,0,0,0,18,98,1,
0,0,0,20,109,1,0,0,0,22,115,1,0,0,0,24,129,1,0,0,0,26,137,1,0,0,0,28,140,
1,0,0,0,30,166,1,0,0,0,32,185,1,0,0,0,34,199,1,0,0,0,36,201,1,0,0,0,38,
210,1,0,0,0,40,215,1,0,0,0,42,218,1,0,0,0,44,223,1,0,0,0,46,251,1,0,0,
0,48,49,3,2,1,0,49,1,1,0,0,0,50,52,3,4,2,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,3,1,0,0,0,55,58,3,22,11,0,56,58,3,12,6,
0,57,55,1,0,0,0,57,56,1,0,0,0,58,5,1,0,0,0,59,62,3,12,6,0,60,62,3,22,11,
0,61,59,1,0,0,0,61,60,1,0,0,0,62,63,1,0,0,0,63,61,1,0,0,0,63,64,1,0,0,
0,64,7,1,0,0,0,65,68,3,12,6,0,66,68,3,22,11,0,67,65,1,0,0,0,67,66,1,0,
0,0,68,69,1,0,0,0,69,67,1,0,0,0,69,70,1,0,0,0,70,9,1,0,0,0,71,74,3,12,
6,0,72,74,3,22,11,0,73,71,1,0,0,0,73,72,1,0,0,0,74,75,1,0,0,0,75,73,1,
0,0,0,75,76,1,0,0,0,76,11,1,0,0,0,77,78,5,10,0,0,78,13,1,0,0,0,79,81,3,
12,6,0,80,79,1,0,0,0,80,81,1,0,0,0,81,90,1,0,0,0,82,84,3,16,8,0,83,82,
1,0,0,0,83,84,1,0,0,0,84,85,1,0,0,0,85,91,3,12,6,0,86,88,3,16,8,0,87,89,
3,12,6,0,88,87,1,0,0,0,88,89,1,0,0,0,89,91,1,0,0,0,90,83,1,0,0,0,90,86,
1,0,0,0,91,92,1,0,0,0,92,90,1,0,0,0,92,93,1,0,0,0,93,94,1,0,0,0,94,95,
3,22,11,0,95,15,1,0,0,0,96,97,3,18,9,0,97,17,1,0,0,0,98,100,5,11,0,0,99,
101,5,7,0,0,100,99,1,0,0,0,100,101,1,0,0,0,101,102,1,0,0,0,102,104,3,20,
10,0,103,105,5,7,0,0,104,103,1,0,0,0,104,105,1,0,0,0,105,106,1,0,0,0,106,
107,5,12,0,0,107,19,1,0,0,0,108,110,5,7,0,0,109,108,1,0,0,0,109,110,1,
0,0,0,110,111,1,0,0,0,111,112,3,38,19,0,112,113,3,40,20,0,113,21,1,0,0,
0,114,116,5,7,0,0,115,114,1,0,0,0,115,116,1,0,0,0,116,117,1,0,0,0,117,
118,3,24,12,0,118,23,1,0,0,0,119,120,5,20,0,0,120,130,3,28,14,0,121,122,
5,21,0,0,122,124,3,28,14,0,123,121,1,0,0,0,124,127,1,0,0,0,125,123,1,0,
0,0,125,126,1,0,0,0,126,128,1,0,0,0,127,125,1,0,0,0,128,130,3,26,13,0,
129,119,1,0,0,0,129,125,1,0,0,0,130,25,1,0,0,0,131,138,5,21,0,0,132,133,
5,21,0,0,133,138,3,28,14,0,134,135,5,22,0,0,135,138,3,28,14,0,136,138,
5,22,0,0,137,131,1,0,0,0,137,132,1,0,0,0,137,134,1,0,0,0,137,136,1,0,0,
0,138,27,1,0,0,0,139,141,5,7,0,0,140,139,1,0,0,0,140,141,1,0,0,0,141,142,
1,0,0,0,142,144,3,30,15,0,143,145,5,7,0,0,144,143,1,0,0,0,144,145,1,0,
0,0,145,160,1,0,0,0,146,147,5,1,0,0,147,155,3,36,18,0,148,150,5,2,0,0,
149,151,5,7,0,0,150,149,1,0,0,0,150,151,1,0,0,0,151,152,1,0,0,0,152,154,
3,36,18,0,153,148,1,0,0,0,154,157,1,0,0,0,155,153,1,0,0,0,155,156,1,0,
0,0,156,158,1,0,0,0,157,155,1,0,0,0,158,159,5,3,0,0,159,161,1,0,0,0,160,
146,1,0,0,0,160,161,1,0,0,0,161,163,1,0,0,0,162,164,5,7,0,0,163,162,1,
0,0,0,163,164,1,0,0,0,164,29,1,0,0,0,165,167,5,7,0,0,166,165,1,0,0,0,166,
167,1,0,0,0,167,168,1,0,0,0,168,170,3,34,17,0,169,171,5,7,0,0,170,169,
1,0,0,0,170,171,1,0,0,0,171,182,1,0,0,0,172,174,5,4,0,0,173,175,5,7,0,
0,174,173,1,0,0,0,174,175,1,0,0,0,175,176,1,0,0,0,176,178,3,34,17,0,177,
179,5,7,0,0,178,177,1,0,0,0,178,179,1,0,0,0,179,181,1,0,0,0,180,172,1,
0,0,0,181,184,1,0,0,0,182,180,1,0,0,0,182,183,1,0,0,0,183,31,1,0,0,0,184,
182,1,0,0,0,185,186,5,1,0,0,186,194,3,36,18,0,187,189,5,2,0,0,188,190,
5,7,0,0,189,188,1,0,0,0,189,190,1,0,0,0,190,191,1,0,0,0,191,193,3,36,18,
0,192,187,1,0,0,0,193,196,1,0,0,0,194,192,1,0,0,0,194,195,1,0,0,0,195,
197,1,0,0,0,196,194,1,0,0,0,197,198,5,3,0,0,198,33,1,0,0,0,199,200,5,23,
0,0,200,35,1,0,0,0,201,202,5,23,0,0,202,37,1,0,0,0,203,211,5,13,0,0,204,
211,5,14,0,0,205,211,5,15,0,0,206,211,5,16,0,0,207,211,5,17,0,0,208,211,
5,18,0,0,209,211,5,19,0,0,210,203,1,0,0,0,210,204,1,0,0,0,210,205,1,0,
0,0,210,206,1,0,0,0,210,207,1,0,0,0,210,208,1,0,0,0,210,209,1,0,0,0,211,
39,1,0,0,0,212,213,5,8,0,0,213,216,3,42,21,0,214,216,3,46,23,0,215,212,
1,0,0,0,215,214,1,0,0,0,216,41,1,0,0,0,217,219,3,44,22,0,218,217,1,0,0,
0,219,220,1,0,0,0,220,218,1,0,0,0,220,221,1,0,0,0,221,43,1,0,0,0,222,224,
5,7,0,0,223,222,1,0,0,0,223,224,1,0,0,0,224,225,1,0,0,0,225,227,5,5,0,
0,226,228,5,7,0,0,227,226,1,0,0,0,227,228,1,0,0,0,228,231,1,0,0,0,229,
232,3,10,5,0,230,232,5,9,0,0,231,229,1,0,0,0,231,230,1,0,0,0,232,45,1,
0,0,0,233,240,3,14,7,0,234,236,5,6,0,0,235,237,3,14,7,0,236,235,1,0,0,
0,236,237,1,0,0,0,237,239,1,0,0,0,238,234,1,0,0,0,239,242,1,0,0,0,240,
238,1,0,0,0,240,241,1,0,0,0,241,252,1,0,0,0,242,240,1,0,0,0,243,245,5,
6,0,0,244,246,3,14,7,0,245,244,1,0,0,0,245,246,1,0,0,0,246,248,1,0,0,0,
247,243,1,0,0,0,248,249,1,0,0,0,249,247,1,0,0,0,249,250,1,0,0,0,250,252,
1,0,0,0,251,233,1,0,0,0,251,247,1,0,0,0,252,47,1,0,0,0,44,53,57,61,63,
67,69,73,75,80,83,88,90,92,100,104,109,115,125,129,137,140,144,150,155,
160,163,166,170,174,178,182,189,194,210,215,220,223,227,231,236,240,245,
249,251
};
public static readonly ATN _ATN =
new ATNDeserializer().Deserialize(_serializedATN);
}
Reference in New Issue View Git Blame Copy Permalink