NTERA/NTERA.Interpreter/Interpreter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using NTERA.Core;

namespace NTERA.Interpreter
{
    public partial class Interpreter
    {
        private Lexer lex;
        private Token prevToken;
        private Token lastToken;

        public readonly Dictionary<string, Value> Variables;
        private Dictionary<string, Marker> loops;

        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;
            lex = new Lexer(input);
            Variables = new Dictionary<string, Value>();
            loops = new Dictionary<string, Marker>();
            ifcounter = 0;

            GenerateKeywordDictionary();
            GenerateFunctionDictionary();
        }

        public Value GetVar(string name)
        {
            if (!Variables.ContainsKey(name))
                throw new Exception("Variable with name " + name + " does not exist.");
            return Variables[name];
        }

        public void SetVar(string name, Value val)
        {
            if (!Variables.ContainsKey(name)) Variables.Add(name, val);
            else Variables[name] = val;
        }

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

        void Match(Token tok)
        {
            if (lastToken != tok)
                Error("Expect " + tok + " got " + lastToken);
        }

        private IEnumerator<Token> tokens;

        public void Exec()
        {
            exit = false;

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

            GetNextToken();
            while (!exit) Line();
        }

        Token GetNextToken()
        {
            prevToken = lastToken;

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

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

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

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

            lineMarker = lex.TokenMarker;
            Statment();

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

        void Statment()
        {
            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 goto default;
                        break;
                    case Token.EOF:
                        exit = true;
                        break;
                    default:
                        Error("Expect keyword got " + keyword);
                        break;
                }
            }

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

        #region Functions
        
        private Dictionary<string, BasicFunction> FunctionDictionary { get; set; }

        private void GenerateFunctionDictionary()
        {
            FunctionDictionary = new Dictionary<string, BasicFunction>(StringComparer.InvariantCultureIgnoreCase);

            foreach (var method in typeof(Interpreter).GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
            {
                var attribute = method.GetCustomAttributes(typeof(BuiltInFunctionAttribute), true).FirstOrDefault() as BuiltInFunctionAttribute;

                if (attribute == null)
                    continue;

                FunctionDictionary[attribute.Name] = args => (Value)method.Invoke(this, new object[] { args });
            }
        }

        [BuiltInFunction("abs")]
        private Value Abs(List<Value> args)
        {
            if (args.Count < 1)
                throw new ArgumentException();

            return new Value(Math.Abs(args[0].Real));
        }

        [BuiltInFunction("min")]
        private Value Min(List<Value> args)
        {
            if (args.Count < 2)
                throw new ArgumentException();

            return new Value(Math.Min(args[0].Real, args[1].Real));
        }

        [BuiltInFunction("max")]
        private Value Max(List<Value> args)
        {
            if (args.Count < 2)
                throw new ArgumentException();

            return new Value(Math.Max(args[0].Real, args[1].Real));
        }

        [BuiltInFunction("not")]
        private Value Not(List<Value> args)
        {
            if (args.Count < 1)
                throw new ArgumentException();

            return new Value(args[0].Real == 0 ? 1 : 0);
        }

        private readonly Random random = new Random();

        [BuiltInFunction("rand")]
        private Value Rand(List<Value> args)
        {
            if (args.Count < 2)
                throw new ArgumentException();

            return new Value(random.Next((int)args[0].Real, (int)args[1].Real - 1));
        }

        #endregion

        #region Keywords

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

        private void GenerateKeywordDictionary()
        {
            KeywordMethods = new Dictionary<Token, Action>();

            foreach (var method in typeof(Interpreter).GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
            {
                var attribute = method.GetCustomAttributes(typeof(KeywordMethodAttribute), true).FirstOrDefault() as KeywordMethodAttribute;

                if (attribute == null)
                    continue;

                KeywordMethods[attribute.Token] = () => method.Invoke(this, null);
            }
        }


        [KeywordMethod(Token.Print)]
        void Print()
        {
            console.Write(Expr().ToString());
        }

        [KeywordMethod(Token.PrintL)]
        void PrintL()
        {
            console.PrintSingleLine(Expr().ToString());
        }


        [KeywordMethod(Token.PrintImg)]
        void PrintImg()
        {
            console.PrintImg(Expr().ToString().Trim().Trim('"'));
        }


        [KeywordMethod(Token.PrintButton)]
        void PrintButton()
        {
            console.PrintButton(Expr().ToString(), 0);
        }

        private static readonly Regex FormRegex = new Regex("{(.*?)}");

        [KeywordMethod(Token.PrintFormL)]
        void PrintFormL()
        {
            string rawString = Expr().ToString();

            var evaluator = new MatchEvaluator(match => Variables[match.Groups[1].Value].ToString());

            console.PrintSingleLine(FormRegex.Replace(rawString, evaluator));
        }

        [KeywordMethod(Token.DrawLine)]
        void DrawLine()
        {
            console.PrintBar();
        }

        [KeywordMethod(Token.DrawLineForm)]
        void DrawLineForm()
        {
            console.printCustomBar(Expr().ToString().Trim());
        }

        [KeywordMethod(Token.If)]
        private void If()
        {
            bool result = Expr().Real == 1;

            Match(Token.Then);
            GetNextToken();

            if (result)
            {
                int i = ifcounter;
                while (true)
                {
                    if (lastToken == Token.If)
                    {
                        i++;
                    }
                    else if (lastToken == Token.Else)
                    {
                        if (i == ifcounter)
                        {
                            GetNextToken();
                            return;
                        }
                    }
                    else if (lastToken == Token.EndIf)
                    {
                        if (i == ifcounter)
                        {
                            GetNextToken();
                            return;
                        }
                        i--;
                    }
                    GetNextToken();
                }
            }
        }

        [KeywordMethod(Token.Else)]
        private void Else()
        {
            int i = ifcounter;
            while (true)
            {
                if (lastToken == Token.If)
                {
                    i++;
                }
                else if (lastToken == Token.EndIf)
                {
                    if (i == ifcounter)
                    {
                        GetNextToken();
                        return;
                    }
                    i--;
                }
                GetNextToken();
            }
        }

        [KeywordMethod(Token.EndIf)]
        private void EndIf()
        {

        }

        [KeywordMethod(Token.End)]
        private void End()
        {
            exit = true;
        }

        [KeywordMethod(Token.Let)]
        private void Let()
        {
            if (lastToken != Token.Equal)
            {
                Match(Token.Identifer);
                GetNextToken();
                Match(Token.Equal);
            }

            string id = lex.Identifer;

            GetNextToken();

            SetVar(id, Expr());
        }

        [KeywordMethod(Token.For)]
        private void For()
        {
            Match(Token.Identifer);
            string var = lex.Identifer;

            GetNextToken();
            Match(Token.Equal);

            GetNextToken();
            Value v = Expr();

            if (loops.ContainsKey(var))
            {
                loops[var] = lineMarker;
            }
            else
            {
                SetVar(var, v);
                loops.Add(var, lineMarker);
            }

            Match(Token.To);

            GetNextToken();
            v = Expr();

            if (Variables[var].Operate(v, Token.More).Real == 1)
            {
                while (true)
                {
                    while (!(GetNextToken() == Token.Identifer && prevToken == Token.Next)) ;
                    if (lex.Identifer == var)
                    {
                        loops.Remove(var);
                        GetNextToken();
                        Match(Token.NewLine);
                        break;
                    }
                }
            }
        }

        [KeywordMethod(Token.Next)]
        private void Next()
        {
            Match(Token.Identifer);
            string var = lex.Identifer;
            Variables[var] = Variables[var].Operate(new Value(1), Token.Plus);
            lex.GoTo(new Marker(loops[var].Pointer - 1, loops[var].Line, loops[var].Column - 1));
            lastToken = Token.NewLine;
        }

        [KeywordMethod(Token.Times)]
        private void Times()
        {
            Match(Token.Identifer);

            string var = lex.Identifer;

            GetNextToken();
            Match(Token.Comma);

            GetNextToken();
            var arg2 = Expr();

            Variables[var] = Variables[var].Operate(arg2, Token.Asterisk);
            
            Match(Token.NewLine);
        }

        #endregion

        void Input()
        {
            while (true)
            {
                Match(Token.Identifer);
               
                if (!Variables.ContainsKey(lex.Identifer)) Variables.Add(lex.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[lex.Identifer] = new Value(d);
                else
                    Variables[lex.Identifer] = new Value(input);
                
                GetNextToken();
                if (lastToken != 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 }
        };

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

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

                        stack.Push(FunctionDictionary[name](args));
                    }
                    else
                    {
                        Error("Undeclared variable " + lex.Identifer);
                    }
                }
                else if (lastToken == Token.LParen)
                {
                    GetNextToken();
                    stack.Push(Expr());
                    Match(Token.RParen);
                }
                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(stack, operators.Pop());
                        operators.Push(lastToken);
                    }
                }
                else
                {
                    if (i == 0)
                        Error("Empty expression");
                    break;
                }

                i++;
                GetNextToken();
            }

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

            return stack.Pop();
        }

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