MiniScript version 3 parser code

MiniScriptParser.cs

//------------------------------------------------------------------------------
// <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 MiniScript.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 MiniScriptParser : 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, IF=7, ELSE=8, LOOP=9, 
		FOR=10, VAR=11, BREAK=12, CONTINUE=13, NOT=14, EXCLAMATION=15, ASSIGN=16, 
		PLUS=17, MINUS=18, MUL=19, DIV=20, MOD=21, POW=22, LPAREN=23, RPAREN=24, 
		LBRACE=25, RBRACE=26, COMMA=27, SEMICOLON=28, DOT=29, LBRACKET=30, RBRACKET=31, 
		COLON=32, STRING=33, FLOAT=34, NUMBER=35, BOOLEAN=36, IDENTIFIER=37, WS=38, 
		COMMENT=39, MULTILINE_COMMENT=40;
	public const int
		RULE_program = 0, RULE_statement = 1, RULE_variableDeclaration = 2, RULE_assignment = 3, 
		RULE_ifStatement = 4, RULE_loopStatement = 5, RULE_forStatement = 6, RULE_breakStatement = 7, 
		RULE_continueStatement = 8, RULE_expressionStatement = 9, RULE_functionCallStatement = 10, 
		RULE_block = 11, RULE_expression = 12, RULE_comparisonExpression = 13, 
		RULE_additiveExpression = 14, RULE_multiplicativeExpression = 15, RULE_powerExpression = 16, 
		RULE_unaryExpression = 17, RULE_primaryExpression = 18, RULE_functionCall = 19, 
		RULE_qualifiedIdentifier = 20, RULE_arrayLiteral = 21, RULE_arrayAccess = 22;
	public static readonly string[] ruleNames = {
		"program", "statement", "variableDeclaration", "assignment", "ifStatement", 
		"loopStatement", "forStatement", "breakStatement", "continueStatement", 
		"expressionStatement", "functionCallStatement", "block", "expression", 
		"comparisonExpression", "additiveExpression", "multiplicativeExpression", 
		"powerExpression", "unaryExpression", "primaryExpression", "functionCall", 
		"qualifiedIdentifier", "arrayLiteral", "arrayAccess"
	};

	private static readonly string[] _LiteralNames = {
		null, "'>'", "'<'", "'>='", "'<='", "'=='", "'!='", "'if'", "'else'", 
		"'loop'", "'for'", "'var'", "'break'", "'continue'", "'not'", "'!'", "'='", 
		"'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'('", "')'", "'{'", "'}'", 
		"','", "';'", "'.'", "'['", "']'", "':'"
	};
	private static readonly string[] _SymbolicNames = {
		null, null, null, null, null, null, null, "IF", "ELSE", "LOOP", "FOR", 
		"VAR", "BREAK", "CONTINUE", "NOT", "EXCLAMATION", "ASSIGN", "PLUS", "MINUS", 
		"MUL", "DIV", "MOD", "POW", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "COMMA", 
		"SEMICOLON", "DOT", "LBRACKET", "RBRACKET", "COLON", "STRING", "FLOAT", 
		"NUMBER", "BOOLEAN", "IDENTIFIER", "WS", "COMMENT", "MULTILINE_COMMENT"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

	[NotNull]
	public override IVocabulary Vocabulary
	{
		get
		{
			return DefaultVocabulary;
		}
	}

	public override string GrammarFileName { get { return "MiniScript.g4"; } }

	public override string[] RuleNames { get { return ruleNames; } }

	public override int[] SerializedAtn { get { return _serializedATN; } }

	static MiniScriptParser() {
		decisionToDFA = new DFA[_ATN.NumberOfDecisions];
		for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
			decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
		}
	}

		public MiniScriptParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }

		public MiniScriptParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
		: base(input, output, errorOutput)
	{
		Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
	}

	public partial class ProgramContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(MiniScriptParser.Eof, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext[] statement() {
			return GetRuleContexts<StatementContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext statement(int i) {
			return GetRuleContext<StatementContext>(i);
		}
		public ProgramContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_program; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitProgram(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ProgramContext program() {
		ProgramContext _localctx = new ProgramContext(Context, State);
		EnterRule(_localctx, 0, RULE_program);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 49;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 267370561152L) != 0)) {
				{
				{
				State = 46;
				statement();
				}
				}
				State = 51;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 52;
			Match(Eof);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class StatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public VariableDeclarationContext variableDeclaration() {
			return GetRuleContext<VariableDeclarationContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssignmentContext assignment() {
			return GetRuleContext<AssignmentContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IfStatementContext ifStatement() {
			return GetRuleContext<IfStatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public LoopStatementContext loopStatement() {
			return GetRuleContext<LoopStatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ForStatementContext forStatement() {
			return GetRuleContext<ForStatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public BreakStatementContext breakStatement() {
			return GetRuleContext<BreakStatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ContinueStatementContext continueStatement() {
			return GetRuleContext<ContinueStatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionStatementContext expressionStatement() {
			return GetRuleContext<ExpressionStatementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FunctionCallStatementContext functionCallStatement() {
			return GetRuleContext<FunctionCallStatementContext>(0);
		}
		public StatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_statement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StatementContext statement() {
		StatementContext _localctx = new StatementContext(Context, State);
		EnterRule(_localctx, 2, RULE_statement);
		try {
			State = 63;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 54;
				variableDeclaration();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 55;
				assignment();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 56;
				ifStatement();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 57;
				loopStatement();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 58;
				forStatement();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 59;
				breakStatement();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 60;
				continueStatement();
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 61;
				expressionStatement();
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 62;
				functionCallStatement();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class VariableDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VAR() { return GetToken(MiniScriptParser.VAR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(MiniScriptParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(MiniScriptParser.SEMICOLON, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(MiniScriptParser.ASSIGN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public VariableDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_variableDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariableDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VariableDeclarationContext variableDeclaration() {
		VariableDeclarationContext _localctx = new VariableDeclarationContext(Context, State);
		EnterRule(_localctx, 4, RULE_variableDeclaration);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 65;
			Match(VAR);
			State = 66;
			Match(IDENTIFIER);
			State = 69;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==ASSIGN) {
				{
				State = 67;
				Match(ASSIGN);
				State = 68;
				expression();
				}
			}

			State = 71;
			Match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AssignmentContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(MiniScriptParser.ASSIGN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(MiniScriptParser.SEMICOLON, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(MiniScriptParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ArrayAccessContext arrayAccess() {
			return GetRuleContext<ArrayAccessContext>(0);
		}
		public AssignmentContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assignment; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAssignment(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AssignmentContext assignment() {
		AssignmentContext _localctx = new AssignmentContext(Context, State);
		EnterRule(_localctx, 6, RULE_assignment);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 75;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,3,Context) ) {
			case 1:
				{
				State = 73;
				Match(IDENTIFIER);
				}
				break;
			case 2:
				{
				State = 74;
				arrayAccess();
				}
				break;
			}
			State = 77;
			Match(ASSIGN);
			State = 78;
			expression();
			State = 79;
			Match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IfStatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IF() { return GetToken(MiniScriptParser.IF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(MiniScriptParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(MiniScriptParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public BlockContext[] block() {
			return GetRuleContexts<BlockContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public BlockContext block(int i) {
			return GetRuleContext<BlockContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELSE() { return GetToken(MiniScriptParser.ELSE, 0); }
		public IfStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_ifStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIfStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public IfStatementContext ifStatement() {
		IfStatementContext _localctx = new IfStatementContext(Context, State);
		EnterRule(_localctx, 8, RULE_ifStatement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 81;
			Match(IF);
			State = 82;
			Match(LPAREN);
			State = 83;
			expression();
			State = 84;
			Match(RPAREN);
			State = 85;
			block();
			State = 88;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==ELSE) {
				{
				State = 86;
				Match(ELSE);
				State = 87;
				block();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class LoopStatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LOOP() { return GetToken(MiniScriptParser.LOOP, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(MiniScriptParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(MiniScriptParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public BlockContext block() {
			return GetRuleContext<BlockContext>(0);
		}
		public LoopStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_loopStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLoopStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public LoopStatementContext loopStatement() {
		LoopStatementContext _localctx = new LoopStatementContext(Context, State);
		EnterRule(_localctx, 10, RULE_loopStatement);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 90;
			Match(LOOP);
			State = 91;
			Match(LPAREN);
			State = 92;
			expression();
			State = 93;
			Match(RPAREN);
			State = 94;
			block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ForStatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FOR() { return GetToken(MiniScriptParser.FOR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(MiniScriptParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] SEMICOLON() { return GetTokens(MiniScriptParser.SEMICOLON); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON(int i) {
			return GetToken(MiniScriptParser.SEMICOLON, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(MiniScriptParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public BlockContext block() {
			return GetRuleContext<BlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public VariableDeclarationContext variableDeclaration() {
			return GetRuleContext<VariableDeclarationContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssignmentContext[] assignment() {
			return GetRuleContexts<AssignmentContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssignmentContext assignment(int i) {
			return GetRuleContext<AssignmentContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ForStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_forStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitForStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ForStatementContext forStatement() {
		ForStatementContext _localctx = new ForStatementContext(Context, State);
		EnterRule(_localctx, 12, RULE_forStatement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 96;
			Match(FOR);
			State = 97;
			Match(LPAREN);
			State = 100;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case VAR:
				{
				State = 98;
				variableDeclaration();
				}
				break;
			case IDENTIFIER:
				{
				State = 99;
				assignment();
				}
				break;
			case SEMICOLON:
				break;
			default:
				break;
			}
			State = 102;
			Match(SEMICOLON);
			State = 104;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 267370545152L) != 0)) {
				{
				State = 103;
				expression();
				}
			}

			State = 106;
			Match(SEMICOLON);
			State = 108;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==IDENTIFIER) {
				{
				State = 107;
				assignment();
				}
			}

			State = 110;
			Match(RPAREN);
			State = 111;
			block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BreakStatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BREAK() { return GetToken(MiniScriptParser.BREAK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(MiniScriptParser.SEMICOLON, 0); }
		public BreakStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_breakStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBreakStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public BreakStatementContext breakStatement() {
		BreakStatementContext _localctx = new BreakStatementContext(Context, State);
		EnterRule(_localctx, 14, RULE_breakStatement);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 113;
			Match(BREAK);
			State = 114;
			Match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ContinueStatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONTINUE() { return GetToken(MiniScriptParser.CONTINUE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(MiniScriptParser.SEMICOLON, 0); }
		public ContinueStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_continueStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitContinueStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ContinueStatementContext continueStatement() {
		ContinueStatementContext _localctx = new ContinueStatementContext(Context, State);
		EnterRule(_localctx, 16, RULE_continueStatement);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 116;
			Match(CONTINUE);
			State = 117;
			Match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExpressionStatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(MiniScriptParser.SEMICOLON, 0); }
		public ExpressionStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expressionStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpressionStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExpressionStatementContext expressionStatement() {
		ExpressionStatementContext _localctx = new ExpressionStatementContext(Context, State);
		EnterRule(_localctx, 18, RULE_expressionStatement);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 119;
			expression();
			State = 120;
			Match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FunctionCallStatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public FunctionCallContext functionCall() {
			return GetRuleContext<FunctionCallContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(MiniScriptParser.SEMICOLON, 0); }
		public FunctionCallStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_functionCallStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFunctionCallStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FunctionCallStatementContext functionCallStatement() {
		FunctionCallStatementContext _localctx = new FunctionCallStatementContext(Context, State);
		EnterRule(_localctx, 20, RULE_functionCallStatement);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 122;
			functionCall();
			State = 123;
			Match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BlockContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACE() { return GetToken(MiniScriptParser.LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACE() { return GetToken(MiniScriptParser.RBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext[] statement() {
			return GetRuleContexts<StatementContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public StatementContext statement(int i) {
			return GetRuleContext<StatementContext>(i);
		}
		public BlockContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_block; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBlock(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public BlockContext block() {
		BlockContext _localctx = new BlockContext(Context, State);
		EnterRule(_localctx, 22, RULE_block);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 125;
			Match(LBRACE);
			State = 129;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 267370561152L) != 0)) {
				{
				{
				State = 126;
				statement();
				}
				}
				State = 131;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 132;
			Match(RBRACE);
			}
		}
		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 ComparisonExpressionContext comparisonExpression() {
			return GetRuleContext<ComparisonExpressionContext>(0);
		}
		public ExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<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, 24, RULE_expression);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 134;
			comparisonExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ComparisonExpressionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AdditiveExpressionContext[] additiveExpression() {
			return GetRuleContexts<AdditiveExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public AdditiveExpressionContext additiveExpression(int i) {
			return GetRuleContext<AdditiveExpressionContext>(i);
		}
		public ComparisonExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_comparisonExpression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitComparisonExpression(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ComparisonExpressionContext comparisonExpression() {
		ComparisonExpressionContext _localctx = new ComparisonExpressionContext(Context, State);
		EnterRule(_localctx, 26, RULE_comparisonExpression);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 136;
			additiveExpression();
			State = 139;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 126L) != 0)) {
				{
				State = 137;
				_la = TokenStream.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 126L) != 0)) ) {
				ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				State = 138;
				additiveExpression();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AdditiveExpressionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MultiplicativeExpressionContext[] multiplicativeExpression() {
			return GetRuleContexts<MultiplicativeExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultiplicativeExpressionContext multiplicativeExpression(int i) {
			return GetRuleContext<MultiplicativeExpressionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] PLUS() { return GetTokens(MiniScriptParser.PLUS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS(int i) {
			return GetToken(MiniScriptParser.PLUS, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] MINUS() { return GetTokens(MiniScriptParser.MINUS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MINUS(int i) {
			return GetToken(MiniScriptParser.MINUS, i);
		}
		public AdditiveExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_additiveExpression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAdditiveExpression(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AdditiveExpressionContext additiveExpression() {
		AdditiveExpressionContext _localctx = new AdditiveExpressionContext(Context, State);
		EnterRule(_localctx, 28, RULE_additiveExpression);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 141;
			multiplicativeExpression();
			State = 146;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==PLUS || _la==MINUS) {
				{
				{
				State = 142;
				_la = TokenStream.LA(1);
				if ( !(_la==PLUS || _la==MINUS) ) {
				ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				State = 143;
				multiplicativeExpression();
				}
				}
				State = 148;
				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 MultiplicativeExpressionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public PowerExpressionContext[] powerExpression() {
			return GetRuleContexts<PowerExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public PowerExpressionContext powerExpression(int i) {
			return GetRuleContext<PowerExpressionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] MUL() { return GetTokens(MiniScriptParser.MUL); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MUL(int i) {
			return GetToken(MiniScriptParser.MUL, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DIV() { return GetTokens(MiniScriptParser.DIV); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIV(int i) {
			return GetToken(MiniScriptParser.DIV, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] MOD() { return GetTokens(MiniScriptParser.MOD); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MOD(int i) {
			return GetToken(MiniScriptParser.MOD, i);
		}
		public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_multiplicativeExpression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiplicativeExpression(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MultiplicativeExpressionContext multiplicativeExpression() {
		MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(Context, State);
		EnterRule(_localctx, 30, RULE_multiplicativeExpression);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 149;
			powerExpression();
			State = 154;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 3670016L) != 0)) {
				{
				{
				State = 150;
				_la = TokenStream.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 3670016L) != 0)) ) {
				ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				State = 151;
				powerExpression();
				}
				}
				State = 156;
				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 PowerExpressionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public UnaryExpressionContext unaryExpression() {
			return GetRuleContext<UnaryExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode POW() { return GetToken(MiniScriptParser.POW, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public PowerExpressionContext powerExpression() {
			return GetRuleContext<PowerExpressionContext>(0);
		}
		public PowerExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_powerExpression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPowerExpression(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PowerExpressionContext powerExpression() {
		PowerExpressionContext _localctx = new PowerExpressionContext(Context, State);
		EnterRule(_localctx, 32, RULE_powerExpression);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 157;
			unaryExpression();
			State = 160;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==POW) {
				{
				State = 158;
				Match(POW);
				State = 159;
				powerExpression();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class UnaryExpressionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public UnaryExpressionContext unaryExpression() {
			return GetRuleContext<UnaryExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(MiniScriptParser.PLUS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MINUS() { return GetToken(MiniScriptParser.MINUS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NOT() { return GetToken(MiniScriptParser.NOT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXCLAMATION() { return GetToken(MiniScriptParser.EXCLAMATION, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public PrimaryExpressionContext primaryExpression() {
			return GetRuleContext<PrimaryExpressionContext>(0);
		}
		public UnaryExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_unaryExpression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitUnaryExpression(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public UnaryExpressionContext unaryExpression() {
		UnaryExpressionContext _localctx = new UnaryExpressionContext(Context, State);
		EnterRule(_localctx, 34, RULE_unaryExpression);
		int _la;
		try {
			State = 165;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case NOT:
			case EXCLAMATION:
			case PLUS:
			case MINUS:
				EnterOuterAlt(_localctx, 1);
				{
				State = 162;
				_la = TokenStream.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 442368L) != 0)) ) {
				ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				State = 163;
				unaryExpression();
				}
				break;
			case LPAREN:
			case LBRACKET:
			case STRING:
			case FLOAT:
			case NUMBER:
			case BOOLEAN:
			case IDENTIFIER:
				EnterOuterAlt(_localctx, 2);
				{
				State = 164;
				primaryExpression();
				}
				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 PrimaryExpressionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NUMBER() { return GetToken(MiniScriptParser.NUMBER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT() { return GetToken(MiniScriptParser.FLOAT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOLEAN() { return GetToken(MiniScriptParser.BOOLEAN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(MiniScriptParser.STRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public FunctionCallContext functionCall() {
			return GetRuleContext<FunctionCallContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ArrayAccessContext arrayAccess() {
			return GetRuleContext<ArrayAccessContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(MiniScriptParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(MiniScriptParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(MiniScriptParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ArrayLiteralContext arrayLiteral() {
			return GetRuleContext<ArrayLiteralContext>(0);
		}
		public PrimaryExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_primaryExpression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPrimaryExpression(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PrimaryExpressionContext primaryExpression() {
		PrimaryExpressionContext _localctx = new PrimaryExpressionContext(Context, State);
		EnterRule(_localctx, 36, RULE_primaryExpression);
		try {
			State = 179;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,14,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 167;
				Match(NUMBER);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 168;
				Match(FLOAT);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 169;
				Match(BOOLEAN);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 170;
				Match(STRING);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 171;
				functionCall();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 172;
				arrayAccess();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 173;
				Match(IDENTIFIER);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 174;
				Match(LPAREN);
				State = 175;
				expression();
				State = 176;
				Match(RPAREN);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 178;
				arrayLiteral();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FunctionCallContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public QualifiedIdentifierContext qualifiedIdentifier() {
			return GetRuleContext<QualifiedIdentifierContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(MiniScriptParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(MiniScriptParser.RPAREN, 0); }
		[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[] COMMA() { return GetTokens(MiniScriptParser.COMMA); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) {
			return GetToken(MiniScriptParser.COMMA, i);
		}
		public FunctionCallContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_functionCall; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFunctionCall(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FunctionCallContext functionCall() {
		FunctionCallContext _localctx = new FunctionCallContext(Context, State);
		EnterRule(_localctx, 38, RULE_functionCall);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 181;
			qualifiedIdentifier();
			State = 182;
			Match(LPAREN);
			State = 191;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 267370545152L) != 0)) {
				{
				State = 183;
				expression();
				State = 188;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==COMMA) {
					{
					{
					State = 184;
					Match(COMMA);
					State = 185;
					expression();
					}
					}
					State = 190;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				}
			}

			State = 193;
			Match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class QualifiedIdentifierContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] IDENTIFIER() { return GetTokens(MiniScriptParser.IDENTIFIER); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER(int i) {
			return GetToken(MiniScriptParser.IDENTIFIER, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DOT() { return GetTokens(MiniScriptParser.DOT); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DOT(int i) {
			return GetToken(MiniScriptParser.DOT, i);
		}
		public QualifiedIdentifierContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_qualifiedIdentifier; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitQualifiedIdentifier(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public QualifiedIdentifierContext qualifiedIdentifier() {
		QualifiedIdentifierContext _localctx = new QualifiedIdentifierContext(Context, State);
		EnterRule(_localctx, 40, RULE_qualifiedIdentifier);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 195;
			Match(IDENTIFIER);
			State = 200;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==DOT) {
				{
				{
				State = 196;
				Match(DOT);
				State = 197;
				Match(IDENTIFIER);
				}
				}
				State = 202;
				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 ArrayLiteralContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET() { return GetToken(MiniScriptParser.LBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MiniScriptParser.RBRACKET, 0); }
		[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[] COMMA() { return GetTokens(MiniScriptParser.COMMA); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) {
			return GetToken(MiniScriptParser.COMMA, i);
		}
		public ArrayLiteralContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_arrayLiteral; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitArrayLiteral(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ArrayLiteralContext arrayLiteral() {
		ArrayLiteralContext _localctx = new ArrayLiteralContext(Context, State);
		EnterRule(_localctx, 42, RULE_arrayLiteral);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 203;
			Match(LBRACKET);
			State = 212;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 267370545152L) != 0)) {
				{
				State = 204;
				expression();
				State = 209;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==COMMA) {
					{
					{
					State = 205;
					Match(COMMA);
					State = 206;
					expression();
					}
					}
					State = 211;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				}
			}

			State = 214;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ArrayAccessContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(MiniScriptParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET() { return GetToken(MiniScriptParser.LBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MiniScriptParser.RBRACKET, 0); }
		public ArrayAccessContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_arrayAccess; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IMiniScriptVisitor<TResult> typedVisitor = visitor as IMiniScriptVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitArrayAccess(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ArrayAccessContext arrayAccess() {
		ArrayAccessContext _localctx = new ArrayAccessContext(Context, State);
		EnterRule(_localctx, 44, RULE_arrayAccess);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 216;
			Match(IDENTIFIER);
			State = 217;
			Match(LBRACKET);
			State = 218;
			expression();
			State = 219;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	private static int[] _serializedATN = {
		4,1,40,222,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,1,0,5,0,48,8,0,10,0,12,0,51,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,
		1,1,1,1,1,1,1,1,3,1,64,8,1,1,2,1,2,1,2,1,2,3,2,70,8,2,1,2,1,2,1,3,1,3,
		3,3,76,8,3,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,89,8,4,1,5,
		1,5,1,5,1,5,1,5,1,5,1,6,1,6,1,6,1,6,3,6,101,8,6,1,6,1,6,3,6,105,8,6,1,
		6,1,6,3,6,109,8,6,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,9,1,9,1,9,1,10,
		1,10,1,10,1,11,1,11,5,11,128,8,11,10,11,12,11,131,9,11,1,11,1,11,1,12,
		1,12,1,13,1,13,1,13,3,13,140,8,13,1,14,1,14,1,14,5,14,145,8,14,10,14,12,
		14,148,9,14,1,15,1,15,1,15,5,15,153,8,15,10,15,12,15,156,9,15,1,16,1,16,
		1,16,3,16,161,8,16,1,17,1,17,1,17,3,17,166,8,17,1,18,1,18,1,18,1,18,1,
		18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,180,8,18,1,19,1,19,1,19,1,19,
		1,19,5,19,187,8,19,10,19,12,19,190,9,19,3,19,192,8,19,1,19,1,19,1,20,1,
		20,1,20,5,20,199,8,20,10,20,12,20,202,9,20,1,21,1,21,1,21,1,21,5,21,208,
		8,21,10,21,12,21,211,9,21,3,21,213,8,21,1,21,1,21,1,22,1,22,1,22,1,22,
		1,22,1,22,0,0,23,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,
		40,42,44,0,4,1,0,1,6,1,0,17,18,1,0,19,21,2,0,14,15,17,18,233,0,49,1,0,
		0,0,2,63,1,0,0,0,4,65,1,0,0,0,6,75,1,0,0,0,8,81,1,0,0,0,10,90,1,0,0,0,
		12,96,1,0,0,0,14,113,1,0,0,0,16,116,1,0,0,0,18,119,1,0,0,0,20,122,1,0,
		0,0,22,125,1,0,0,0,24,134,1,0,0,0,26,136,1,0,0,0,28,141,1,0,0,0,30,149,
		1,0,0,0,32,157,1,0,0,0,34,165,1,0,0,0,36,179,1,0,0,0,38,181,1,0,0,0,40,
		195,1,0,0,0,42,203,1,0,0,0,44,216,1,0,0,0,46,48,3,2,1,0,47,46,1,0,0,0,
		48,51,1,0,0,0,49,47,1,0,0,0,49,50,1,0,0,0,50,52,1,0,0,0,51,49,1,0,0,0,
		52,53,5,0,0,1,53,1,1,0,0,0,54,64,3,4,2,0,55,64,3,6,3,0,56,64,3,8,4,0,57,
		64,3,10,5,0,58,64,3,12,6,0,59,64,3,14,7,0,60,64,3,16,8,0,61,64,3,18,9,
		0,62,64,3,20,10,0,63,54,1,0,0,0,63,55,1,0,0,0,63,56,1,0,0,0,63,57,1,0,
		0,0,63,58,1,0,0,0,63,59,1,0,0,0,63,60,1,0,0,0,63,61,1,0,0,0,63,62,1,0,
		0,0,64,3,1,0,0,0,65,66,5,11,0,0,66,69,5,37,0,0,67,68,5,16,0,0,68,70,3,
		24,12,0,69,67,1,0,0,0,69,70,1,0,0,0,70,71,1,0,0,0,71,72,5,28,0,0,72,5,
		1,0,0,0,73,76,5,37,0,0,74,76,3,44,22,0,75,73,1,0,0,0,75,74,1,0,0,0,76,
		77,1,0,0,0,77,78,5,16,0,0,78,79,3,24,12,0,79,80,5,28,0,0,80,7,1,0,0,0,
		81,82,5,7,0,0,82,83,5,23,0,0,83,84,3,24,12,0,84,85,5,24,0,0,85,88,3,22,
		11,0,86,87,5,8,0,0,87,89,3,22,11,0,88,86,1,0,0,0,88,89,1,0,0,0,89,9,1,
		0,0,0,90,91,5,9,0,0,91,92,5,23,0,0,92,93,3,24,12,0,93,94,5,24,0,0,94,95,
		3,22,11,0,95,11,1,0,0,0,96,97,5,10,0,0,97,100,5,23,0,0,98,101,3,4,2,0,
		99,101,3,6,3,0,100,98,1,0,0,0,100,99,1,0,0,0,100,101,1,0,0,0,101,102,1,
		0,0,0,102,104,5,28,0,0,103,105,3,24,12,0,104,103,1,0,0,0,104,105,1,0,0,
		0,105,106,1,0,0,0,106,108,5,28,0,0,107,109,3,6,3,0,108,107,1,0,0,0,108,
		109,1,0,0,0,109,110,1,0,0,0,110,111,5,24,0,0,111,112,3,22,11,0,112,13,
		1,0,0,0,113,114,5,12,0,0,114,115,5,28,0,0,115,15,1,0,0,0,116,117,5,13,
		0,0,117,118,5,28,0,0,118,17,1,0,0,0,119,120,3,24,12,0,120,121,5,28,0,0,
		121,19,1,0,0,0,122,123,3,38,19,0,123,124,5,28,0,0,124,21,1,0,0,0,125,129,
		5,25,0,0,126,128,3,2,1,0,127,126,1,0,0,0,128,131,1,0,0,0,129,127,1,0,0,
		0,129,130,1,0,0,0,130,132,1,0,0,0,131,129,1,0,0,0,132,133,5,26,0,0,133,
		23,1,0,0,0,134,135,3,26,13,0,135,25,1,0,0,0,136,139,3,28,14,0,137,138,
		7,0,0,0,138,140,3,28,14,0,139,137,1,0,0,0,139,140,1,0,0,0,140,27,1,0,0,
		0,141,146,3,30,15,0,142,143,7,1,0,0,143,145,3,30,15,0,144,142,1,0,0,0,
		145,148,1,0,0,0,146,144,1,0,0,0,146,147,1,0,0,0,147,29,1,0,0,0,148,146,
		1,0,0,0,149,154,3,32,16,0,150,151,7,2,0,0,151,153,3,32,16,0,152,150,1,
		0,0,0,153,156,1,0,0,0,154,152,1,0,0,0,154,155,1,0,0,0,155,31,1,0,0,0,156,
		154,1,0,0,0,157,160,3,34,17,0,158,159,5,22,0,0,159,161,3,32,16,0,160,158,
		1,0,0,0,160,161,1,0,0,0,161,33,1,0,0,0,162,163,7,3,0,0,163,166,3,34,17,
		0,164,166,3,36,18,0,165,162,1,0,0,0,165,164,1,0,0,0,166,35,1,0,0,0,167,
		180,5,35,0,0,168,180,5,34,0,0,169,180,5,36,0,0,170,180,5,33,0,0,171,180,
		3,38,19,0,172,180,3,44,22,0,173,180,5,37,0,0,174,175,5,23,0,0,175,176,
		3,24,12,0,176,177,5,24,0,0,177,180,1,0,0,0,178,180,3,42,21,0,179,167,1,
		0,0,0,179,168,1,0,0,0,179,169,1,0,0,0,179,170,1,0,0,0,179,171,1,0,0,0,
		179,172,1,0,0,0,179,173,1,0,0,0,179,174,1,0,0,0,179,178,1,0,0,0,180,37,
		1,0,0,0,181,182,3,40,20,0,182,191,5,23,0,0,183,188,3,24,12,0,184,185,5,
		27,0,0,185,187,3,24,12,0,186,184,1,0,0,0,187,190,1,0,0,0,188,186,1,0,0,
		0,188,189,1,0,0,0,189,192,1,0,0,0,190,188,1,0,0,0,191,183,1,0,0,0,191,
		192,1,0,0,0,192,193,1,0,0,0,193,194,5,24,0,0,194,39,1,0,0,0,195,200,5,
		37,0,0,196,197,5,29,0,0,197,199,5,37,0,0,198,196,1,0,0,0,199,202,1,0,0,
		0,200,198,1,0,0,0,200,201,1,0,0,0,201,41,1,0,0,0,202,200,1,0,0,0,203,212,
		5,30,0,0,204,209,3,24,12,0,205,206,5,27,0,0,206,208,3,24,12,0,207,205,
		1,0,0,0,208,211,1,0,0,0,209,207,1,0,0,0,209,210,1,0,0,0,210,213,1,0,0,
		0,211,209,1,0,0,0,212,204,1,0,0,0,212,213,1,0,0,0,213,214,1,0,0,0,214,
		215,5,31,0,0,215,43,1,0,0,0,216,217,5,37,0,0,217,218,5,30,0,0,218,219,
		3,24,12,0,219,220,5,31,0,0,220,45,1,0,0,0,20,49,63,69,75,88,100,104,108,
		129,139,146,154,160,165,179,188,191,200,209,212
	};

	public static readonly ATN _ATN =
		new ATNDeserializer().Deserialize(_serializedATN);


}