NTERA/NTERA.Interpreter/Interpreter.cs

using System;
using System.Collections.Generic;
using NTERA.Core;

namespace NTERA.Interpreter
{
    public partial class Interpreter
    {
        protected Lexer Lexer { get; set; }
        private Token prevToken;
        private Token lastToken;

        public VariableDictionary Variables { get; } = new VariableDictionary();
        protected Dictionary<string, Marker> Loops { get; } = new Dictionary<string, Marker>();

        public delegate Value BasicFunction(List<Value> args);

        private readonly IConsole console;

        private int ifcounter;

        private Marker lineMarker;

        private bool exit;

        public Interpreter(IConsole console, string input)
        {
            this.console = console;
            Lexer = new Lexer(input);
            ifcounter = 0;

            GenerateKeywordDictionary();
            GenerateFunctionDictionary();
        }

        private void Error(string text)
        {
            throw new Exception(text + " at line: " + lineMarker.Line);
        }

        protected bool TryAssertToken(Token tok, bool pullNext = true)
        {
            if (pullNext)
                GetNextToken();

            return lastToken == tok;
        }

        protected void AssertToken(Token tok, bool pullNext = true)
        {
            if (!TryAssertToken(tok, pullNext))
                Error("Expect " + tok + " got " + lastToken);
        }

        private IEnumerator<Token> tokens;

        public void Exec()
        {
            exit = false;

            tokens = Lexer.GetTokens().GetEnumerator();

            GetNextToken();

            while (!exit)
                Line();
        }

        protected Token GetNextToken()
        {
            prevToken = lastToken;

            tokens.MoveNext();
            lastToken = tokens.Current;

            if (lastToken == Token.EOF && prevToken == Token.EOF)
                Error("Unexpected end of file");
            
            return lastToken;
        }

        private void Line()
        {
            while (lastToken == Token.NewLine)
                GetNextToken();

            if (lastToken == Token.EOF)
            {
                exit = true;
                return;
            }

            lineMarker = Lexer.TokenMarker;
            Statement();

            if (lastToken != Token.NewLine && lastToken != Token.EOF)
                Error("Expect new line got " + lastToken);
        }

        private void Statement()
        {
            while (true)
            {
                Token keyword = lastToken;
                GetNextToken();

                if (KeywordMethods.ContainsKey(keyword))
                    KeywordMethods[keyword]();
                else
                {
                    switch (keyword)
                    {
                        case Token.Input:
                            Input();
                            break;

                        case Token.Function:
                        case Token.Global:
                        case Token.Dim:
                        case Token.Const:
                            while (GetNextToken() != Token.NewLine) { }
                            break;

                        case Token.Identifer:
                            if (lastToken == Token.Equal)
                                Let();
                            else
                                Error("Expected assignment got " + lastToken);
                            break;
                        case Token.EOF:
                            exit = true;
                            break;
                        default:
                            Error("Expect keyword got " + keyword);
                            break;
                    }
                }

                if (lastToken == Token.Colon)
                {
                    GetNextToken();
                    continue;
                }

                break;
            }
        }

        public Dictionary<string, BasicFunction> FunctionDictionary { get; protected set; }

        public Dictionary<Token, Action> KeywordMethods { get; set; }


        private void Input()
        {
            while (true)
            {
                AssertToken(Token.Identifer);
               
                if (!Variables.ContainsKey(Lexer.Identifer)) Variables.Add(Lexer.Identifer, new Value());

                console.WaitInput(new Core.Interop.InputRequest() { InputType = Core.Interop.InputType.StrValue });
                string input = console.LastInput;
                double d;
                if (double.TryParse(input, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out d))
                    Variables[Lexer.Identifer] = new Value(d);
                else
                    Variables[Lexer.Identifer] = new Value(input);
                
                if (!TryAssertToken(Token.Comma))
                    break;

                GetNextToken();
            }
        }

        private static readonly Dictionary<Token, int> OrderOfOps = new Dictionary<Token, int>
        {
            { Token.Or, 0 }, { Token.And, 0 },
            { Token.Equal, 1 }, { Token.NotEqual, 1 },
            { Token.Less, 1 }, { Token.More, 1 }, { Token.LessEqual, 1 },  { Token.MoreEqual, 1 },
            { Token.Plus, 2 }, { Token.Minus, 2 },
            { Token.Asterisk, 3 }, {Token.Slash, 3 },
            { Token.Caret, 4 }
        };

        private Value RealExpression()
        {
            Stack<Value> stack = new Stack<Value>();
            Stack<Token> operators = new Stack<Token>();

            void Operation(Token token)
            {
                Value b = stack.Pop();
                Value a = stack.Pop();
                Value result = a.Operate(b, token);
                stack.Push(result);
            }

            int i = 0;
            while (true)
            {
                if (lastToken == Token.Value)
                {
                    stack.Push(Lexer.Value);
                }
                else if (lastToken == Token.Identifer)
                {
                    if (Variables.ContainsKey(Lexer.Identifer))
                    {
                        stack.Push(Variables[Lexer.Identifer]);
                    }
                    else if (FunctionDictionary.ContainsKey(Lexer.Identifer))
                    {
                        string name = Lexer.Identifer;
                        List<Value> args = new List<Value>();
                        GetNextToken();
                        AssertToken(Token.LParen, false);
                        
                        while (!TryAssertToken(Token.RParen))
                        {
                            args.Add(RealExpression());
                            if (lastToken != Token.Comma)
                                break;
                        }

                        stack.Push(FunctionDictionary[name](args));
                    }
                    else
                    {
                        Error("Undeclared variable " + Lexer.Identifer);
                    }
                }
                else if (lastToken == Token.LParen)
                {
                    GetNextToken();
                    stack.Push(RealExpression());
                    AssertToken(Token.RParen, false);
                }
                else if (lastToken.IsArithmetic())
                {
                    if (lastToken.IsUnary() && (i == 0 || prevToken == Token.LParen))
                    {
                        stack.Push(0);
                        operators.Push(lastToken);
                    }
                    else
                    {
                        while (operators.Count > 0 && OrderOfOps[lastToken] <= OrderOfOps[operators.Peek()])
                            Operation(operators.Pop());
                        operators.Push(lastToken);
                    }
                }
                else
                {
                    if (i == 0)
                        Error("Empty expression");
                    break;
                }

                i++;
                GetNextToken();
            }

            while (operators.Count > 0)
                Operation(operators.Pop());

            return stack.Pop();
        }

        private Value StringExpression()
        {
            foreach (var t in Lexer.ReturnAsLine(Token.Unknown)) { }

            lastToken = Token.NewLine;
            return Lexer.Value;
        }
    }
}