FipParser.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     ANTLR Version: 4.13.1
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

// Generated from Fip.g4 by ANTLR 4.13.1

// 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.1")]
[System.CLSCompliant(false)]
public partial class FipParser : Parser {
	protected static DFA[] decisionToDFA;
	protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
	public const int
		T__0=1, T__1=2, COMMENT=3, MULTILINE_COMMENT=4, CONCAT=5, SEMICOLON=6, 
		ASTERISK=7, SLASH=8, PLUS=9, MINUS=10, EQUALS=11, NOTEQUALS=12, LESS=13, 
		GREATER=14, LESSEQUALS=15, GREATEREQUALS=16, ASSIGN=17, VALUETYPE=18, 
		SET=19, PRINT=20, UPDATE=21, MEM=22, FREEMEM=23, BOOL=24, STRING=25, IDENTIFIER=26, 
		REFERENCE=27, DOUBLE=28, INTEGER=29, NEWLINE=30, WHITESPACE=31;
	public const int
		RULE_file = 0, RULE_commandline = 1, RULE_command = 2, RULE_mem = 3, RULE_freemem = 4, 
		RULE_print = 5, RULE_update = 6, RULE_assignment = 7, RULE_expression = 8;
	public static readonly string[] ruleNames = {
		"file", "commandline", "command", "mem", "freemem", "print", "update", 
		"assignment", "expression"
	};

	private static readonly string[] _LiteralNames = {
		null, "'('", "')'", null, null, "'.'", "';'", "'*'", "'/'", "'+'", "'-'", 
		"'=='", "'!='", "'<'", "'>'", "'<='", "'>='", "'='", null, "'set'", "'print'", 
		"'mod'", "'mem'", "'freemem'", null, null, null, null, null, null, null, 
		"' '"
	};
	private static readonly string[] _SymbolicNames = {
		null, null, null, "COMMENT", "MULTILINE_COMMENT", "CONCAT", "SEMICOLON", 
		"ASTERISK", "SLASH", "PLUS", "MINUS", "EQUALS", "NOTEQUALS", "LESS", "GREATER", 
		"LESSEQUALS", "GREATEREQUALS", "ASSIGN", "VALUETYPE", "SET", "PRINT", 
		"UPDATE", "MEM", "FREEMEM", "BOOL", "STRING", "IDENTIFIER", "REFERENCE", 
		"DOUBLE", "INTEGER", "NEWLINE", "WHITESPACE"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

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

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

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

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

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

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

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

	public partial class FileContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(FipParser.Eof, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CommandlineContext[] commandline() {
			return GetRuleContexts<CommandlineContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CommandlineContext commandline(int i) {
			return GetRuleContext<CommandlineContext>(i);
		}
		public FileContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_file; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterFile(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitFile(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFile(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FileContext file() {
		FileContext _localctx = new FileContext(Context, State);
		EnterRule(_localctx, 0, RULE_file);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 21;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 16252928L) != 0)) {
				{
				{
				State = 18;
				commandline();
				}
				}
				State = 23;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 24;
			Match(Eof);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CommandlineContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CommandContext command() {
			return GetRuleContext<CommandContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NEWLINE() { return GetToken(FipParser.NEWLINE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(FipParser.Eof, 0); }
		public CommandlineContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_commandline; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterCommandline(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitCommandline(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCommandline(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CommandlineContext commandline() {
		CommandlineContext _localctx = new CommandlineContext(Context, State);
		EnterRule(_localctx, 2, RULE_commandline);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 26;
			command();
			State = 27;
			_la = TokenStream.LA(1);
			if ( !(_la==Eof || _la==NEWLINE) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CommandContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AssignmentContext assignment() {
			return GetRuleContext<AssignmentContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PrintContext print() {
			return GetRuleContext<PrintContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public UpdateContext update() {
			return GetRuleContext<UpdateContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MemContext mem() {
			return GetRuleContext<MemContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FreememContext freemem() {
			return GetRuleContext<FreememContext>(0);
		}
		public CommandContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_command; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterCommand(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitCommand(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCommand(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CommandContext command() {
		CommandContext _localctx = new CommandContext(Context, State);
		EnterRule(_localctx, 4, RULE_command);
		try {
			State = 34;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case SET:
				EnterOuterAlt(_localctx, 1);
				{
				State = 29;
				assignment();
				}
				break;
			case PRINT:
				EnterOuterAlt(_localctx, 2);
				{
				State = 30;
				print();
				}
				break;
			case UPDATE:
				EnterOuterAlt(_localctx, 3);
				{
				State = 31;
				update();
				}
				break;
			case MEM:
				EnterOuterAlt(_localctx, 4);
				{
				State = 32;
				mem();
				}
				break;
			case FREEMEM:
				EnterOuterAlt(_localctx, 5);
				{
				State = 33;
				freemem();
				}
				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 MemContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MEM() { return GetToken(FipParser.MEM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(FipParser.SEMICOLON, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REFERENCE() { return GetToken(FipParser.REFERENCE, 0); }
		public MemContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_mem; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterMem(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitMem(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMem(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MemContext mem() {
		MemContext _localctx = new MemContext(Context, State);
		EnterRule(_localctx, 6, RULE_mem);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 36;
			Match(MEM);
			State = 38;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==REFERENCE) {
				{
				State = 37;
				Match(REFERENCE);
				}
			}

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

	public partial class FreememContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FREEMEM() { return GetToken(FipParser.FREEMEM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(FipParser.SEMICOLON, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REFERENCE() { return GetToken(FipParser.REFERENCE, 0); }
		public FreememContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_freemem; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterFreemem(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitFreemem(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFreemem(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FreememContext freemem() {
		FreememContext _localctx = new FreememContext(Context, State);
		EnterRule(_localctx, 8, RULE_freemem);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 42;
			Match(FREEMEM);
			State = 44;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==REFERENCE) {
				{
				State = 43;
				Match(REFERENCE);
				}
			}

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

	public partial class PrintContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PRINT() { return GetToken(FipParser.PRINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(FipParser.SEMICOLON, 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[] CONCAT() { return GetTokens(FipParser.CONCAT); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONCAT(int i) {
			return GetToken(FipParser.CONCAT, i);
		}
		public PrintContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_print; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterPrint(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitPrint(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPrint(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PrintContext print() {
		PrintContext _localctx = new PrintContext(Context, State);
		EnterRule(_localctx, 10, RULE_print);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 48;
			Match(PRINT);
			State = 53;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				{
				State = 49;
				expression(0);
				State = 51;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==CONCAT) {
					{
					State = 50;
					Match(CONCAT);
					}
				}

				}
				}
				State = 55;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 1056964610L) != 0) );
			State = 57;
			Match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class UpdateContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UPDATE() { return GetToken(FipParser.UPDATE, 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 ASSIGN() { return GetToken(FipParser.ASSIGN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(FipParser.SEMICOLON, 0); }
		public UpdateContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_update; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterUpdate(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitUpdate(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitUpdate(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public UpdateContext update() {
		UpdateContext _localctx = new UpdateContext(Context, State);
		EnterRule(_localctx, 12, RULE_update);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 59;
			Match(UPDATE);
			State = 60;
			expression(0);
			State = 61;
			Match(ASSIGN);
			State = 62;
			expression(0);
			State = 63;
			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 SET() { return GetToken(FipParser.SET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUETYPE() { return GetToken(FipParser.VALUETYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(FipParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSIGN() { return GetToken(FipParser.ASSIGN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMICOLON() { return GetToken(FipParser.SEMICOLON, 0); }
		public AssignmentContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assignment; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterAssignment(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitAssignment(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<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, 14, RULE_assignment);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 65;
			Match(SET);
			State = 66;
			Match(VALUETYPE);
			State = 67;
			Match(IDENTIFIER);
			State = 68;
			Match(ASSIGN);
			State = 69;
			expression(0);
			State = 70;
			Match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExpressionContext : ParserRuleContext {
		public ExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expression; } }
	 
		public ExpressionContext() { }
		public virtual void CopyFrom(ExpressionContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class StringAtomExpContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(FipParser.STRING, 0); }
		public StringAtomExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterStringAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitStringAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStringAtomExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class MulDivExpContext : ExpressionContext {
		[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 ASTERISK() { return GetToken(FipParser.ASTERISK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SLASH() { return GetToken(FipParser.SLASH, 0); }
		public MulDivExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterMulDivExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitMulDivExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMulDivExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ComparisonExpContext : ExpressionContext {
		[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 EQUALS() { return GetToken(FipParser.EQUALS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NOTEQUALS() { return GetToken(FipParser.NOTEQUALS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LESS() { return GetToken(FipParser.LESS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode GREATER() { return GetToken(FipParser.GREATER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LESSEQUALS() { return GetToken(FipParser.LESSEQUALS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode GREATEREQUALS() { return GetToken(FipParser.GREATEREQUALS, 0); }
		public ComparisonExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterComparisonExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitComparisonExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitComparisonExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class BoolAtomExpContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOL() { return GetToken(FipParser.BOOL, 0); }
		public BoolAtomExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterBoolAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitBoolAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBoolAtomExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class DoubleAtomExpContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DOUBLE() { return GetToken(FipParser.DOUBLE, 0); }
		public DoubleAtomExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterDoubleAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitDoubleAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDoubleAtomExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class IntegerAtomExpContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER() { return GetToken(FipParser.INTEGER, 0); }
		public IntegerAtomExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterIntegerAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitIntegerAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIntegerAtomExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ParenthesisExpContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ParenthesisExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterParenthesisExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitParenthesisExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitParenthesisExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class IdentifierAtomExpContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(FipParser.IDENTIFIER, 0); }
		public IdentifierAtomExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterIdentifierAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitIdentifierAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIdentifierAtomExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class AddSubExpContext : ExpressionContext {
		[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 PLUS() { return GetToken(FipParser.PLUS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MINUS() { return GetToken(FipParser.MINUS, 0); }
		public AddSubExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterAddSubExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitAddSubExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAddSubExp(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ReferenceAtomExpContext : ExpressionContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REFERENCE() { return GetToken(FipParser.REFERENCE, 0); }
		public ReferenceAtomExpContext(ExpressionContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.EnterReferenceAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IFipListener typedListener = listener as IFipListener;
			if (typedListener != null) typedListener.ExitReferenceAtomExp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IFipVisitor<TResult> typedVisitor = visitor as IFipVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitReferenceAtomExp(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExpressionContext expression() {
		return expression(0);
	}

	private ExpressionContext expression(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		ExpressionContext _localctx = new ExpressionContext(Context, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 16;
		EnterRecursionRule(_localctx, 16, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 83;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__0:
				{
				_localctx = new ParenthesisExpContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;

				State = 73;
				Match(T__0);
				State = 74;
				expression(0);
				State = 75;
				Match(T__1);
				}
				break;
			case IDENTIFIER:
				{
				_localctx = new IdentifierAtomExpContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 77;
				Match(IDENTIFIER);
				}
				break;
			case REFERENCE:
				{
				_localctx = new ReferenceAtomExpContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 78;
				Match(REFERENCE);
				}
				break;
			case STRING:
				{
				_localctx = new StringAtomExpContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 79;
				Match(STRING);
				}
				break;
			case DOUBLE:
				{
				_localctx = new DoubleAtomExpContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 80;
				Match(DOUBLE);
				}
				break;
			case INTEGER:
				{
				_localctx = new IntegerAtomExpContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 81;
				Match(INTEGER);
				}
				break;
			case BOOL:
				{
				_localctx = new BoolAtomExpContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 82;
				Match(BOOL);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			Context.Stop = TokenStream.LT(-1);
			State = 96;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,8,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 94;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) {
					case 1:
						{
						_localctx = new ComparisonExpContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 85;
						if (!(Precpred(Context, 9))) throw new FailedPredicateException(this, "Precpred(Context, 9)");
						State = 86;
						_la = TokenStream.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 129024L) != 0)) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 87;
						expression(10);
						}
						break;
					case 2:
						{
						_localctx = new MulDivExpContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 88;
						if (!(Precpred(Context, 8))) throw new FailedPredicateException(this, "Precpred(Context, 8)");
						State = 89;
						_la = TokenStream.LA(1);
						if ( !(_la==ASTERISK || _la==SLASH) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 90;
						expression(9);
						}
						break;
					case 3:
						{
						_localctx = new AddSubExpContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 91;
						if (!(Precpred(Context, 7))) throw new FailedPredicateException(this, "Precpred(Context, 7)");
						State = 92;
						_la = TokenStream.LA(1);
						if ( !(_la==PLUS || _la==MINUS) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 93;
						expression(8);
						}
						break;
					}
					} 
				}
				State = 98;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,8,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 8: return expression_sempred((ExpressionContext)_localctx, predIndex);
		}
		return true;
	}
	private bool expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return Precpred(Context, 9);
		case 1: return Precpred(Context, 8);
		case 2: return Precpred(Context, 7);
		}
		return true;
	}

	private static int[] _serializedATN = {
		4,1,31,100,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,1,0,5,0,20,8,0,10,0,12,0,23,9,0,1,0,1,0,1,1,1,1,1,1,1,2,1,
		2,1,2,1,2,1,2,3,2,35,8,2,1,3,1,3,3,3,39,8,3,1,3,1,3,1,4,1,4,3,4,45,8,4,
		1,4,1,4,1,5,1,5,1,5,3,5,52,8,5,4,5,54,8,5,11,5,12,5,55,1,5,1,5,1,6,1,6,
		1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,
		8,1,8,1,8,1,8,1,8,3,8,84,8,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,5,8,95,
		8,8,10,8,12,8,98,9,8,1,8,0,1,16,9,0,2,4,6,8,10,12,14,16,0,4,1,1,30,30,
		1,0,11,16,1,0,7,8,1,0,9,10,108,0,21,1,0,0,0,2,26,1,0,0,0,4,34,1,0,0,0,
		6,36,1,0,0,0,8,42,1,0,0,0,10,48,1,0,0,0,12,59,1,0,0,0,14,65,1,0,0,0,16,
		83,1,0,0,0,18,20,3,2,1,0,19,18,1,0,0,0,20,23,1,0,0,0,21,19,1,0,0,0,21,
		22,1,0,0,0,22,24,1,0,0,0,23,21,1,0,0,0,24,25,5,0,0,1,25,1,1,0,0,0,26,27,
		3,4,2,0,27,28,7,0,0,0,28,3,1,0,0,0,29,35,3,14,7,0,30,35,3,10,5,0,31,35,
		3,12,6,0,32,35,3,6,3,0,33,35,3,8,4,0,34,29,1,0,0,0,34,30,1,0,0,0,34,31,
		1,0,0,0,34,32,1,0,0,0,34,33,1,0,0,0,35,5,1,0,0,0,36,38,5,22,0,0,37,39,
		5,27,0,0,38,37,1,0,0,0,38,39,1,0,0,0,39,40,1,0,0,0,40,41,5,6,0,0,41,7,
		1,0,0,0,42,44,5,23,0,0,43,45,5,27,0,0,44,43,1,0,0,0,44,45,1,0,0,0,45,46,
		1,0,0,0,46,47,5,6,0,0,47,9,1,0,0,0,48,53,5,20,0,0,49,51,3,16,8,0,50,52,
		5,5,0,0,51,50,1,0,0,0,51,52,1,0,0,0,52,54,1,0,0,0,53,49,1,0,0,0,54,55,
		1,0,0,0,55,53,1,0,0,0,55,56,1,0,0,0,56,57,1,0,0,0,57,58,5,6,0,0,58,11,
		1,0,0,0,59,60,5,21,0,0,60,61,3,16,8,0,61,62,5,17,0,0,62,63,3,16,8,0,63,
		64,5,6,0,0,64,13,1,0,0,0,65,66,5,19,0,0,66,67,5,18,0,0,67,68,5,26,0,0,
		68,69,5,17,0,0,69,70,3,16,8,0,70,71,5,6,0,0,71,15,1,0,0,0,72,73,6,8,-1,
		0,73,74,5,1,0,0,74,75,3,16,8,0,75,76,5,2,0,0,76,84,1,0,0,0,77,84,5,26,
		0,0,78,84,5,27,0,0,79,84,5,25,0,0,80,84,5,28,0,0,81,84,5,29,0,0,82,84,
		5,24,0,0,83,72,1,0,0,0,83,77,1,0,0,0,83,78,1,0,0,0,83,79,1,0,0,0,83,80,
		1,0,0,0,83,81,1,0,0,0,83,82,1,0,0,0,84,96,1,0,0,0,85,86,10,9,0,0,86,87,
		7,1,0,0,87,95,3,16,8,10,88,89,10,8,0,0,89,90,7,2,0,0,90,95,3,16,8,9,91,
		92,10,7,0,0,92,93,7,3,0,0,93,95,3,16,8,8,94,85,1,0,0,0,94,88,1,0,0,0,94,
		91,1,0,0,0,95,98,1,0,0,0,96,94,1,0,0,0,96,97,1,0,0,0,97,17,1,0,0,0,98,
		96,1,0,0,0,9,21,34,38,44,51,55,83,94,96
	};

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


}