source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Interpreter.cs @ 14328

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using HeuristicLab.Algorithms.PushGP.Expressions;
using HeuristicLab.Algorithms.PushGP.Stack;

namespace HeuristicLab.Algorithms.PushGP.Interpreter
{
    public class PushGPInterpreter : IInterpreter
    {
        private Task currentTask;

        public PushGPInterpreter(Configuration config = null)
        {
            this.Configuration = config ?? new Configuration();

            this.CodeStack = new PushGPStack<Expression>(128);
            this.ExecStack = new PushGPStack<Expression>(128);
            this.NameStack = new PushGPStack<string>(16);
            this.BooleanStack = new PushGPStack<bool>(16);
            this.IntegerStack = new PushGPStack<long>(16);
            this.FloatStack = new PushGPStack<double>(16);

            this.CustomExpressions = new Dictionary<string, Expression>();
        }

        public Configuration Configuration { get; private set; }

        public bool IsPaused { get; private set; }
        public bool IsAborted { get; private set; }
        public bool IsRunning { get { return this.ExecStack.Count > 0 && !IsPaused && !IsAborted; } }
        public bool IsCompleted { get { return this.ExecStack.Count == 0; } }
        public bool CanStep { get { return !IsCompleted && !IsAborted && IsPaused; } }

        public IStack<Expression> CodeStack { get; private set; }
        public IStack<Expression> ExecStack { get; private set; }
        public IStack<string> NameStack { get; private set; }
        public IStack<bool> BooleanStack { get; private set; }
        public IStack<long> IntegerStack { get; private set; }
        public IStack<double> FloatStack { get; private set; }

        public IDictionary<string, Expression> CustomExpressions { get; private set; }

        public void Reset()
        {
            this.IsAborted = false;
            this.IsPaused = false;
            this.currentTask = null;

            this.Clear();
        }

        public void Clear()
        {
            this.ExecStack.Clear();
            this.CodeStack.Clear();
            this.NameStack.Clear();
            this.BooleanStack.Clear();
            this.IntegerStack.Clear();
            this.FloatStack.Clear();

            this.CustomExpressions.Clear();
        }

        public void Interpret(string code)
        {
            var program = Encode(code);
            this.Interpret(program);
        }

        public Task InterpretAsync(string code, bool paused = false, CancellationToken token = default(CancellationToken))
        {
            var program = Encode(code);

            this.currentTask = this.InterpretAsync(program, paused, token);

            return currentTask;
        }

        public Task InterpretAsync(Expression program, bool paused = false, CancellationToken token = default(CancellationToken))
        {
            this.IsPaused = paused;
            this.currentTask = Task.Run(() => this.Interpret(program), token);

            return currentTask;
        }

        public void Interpret(Expression program)
        {
            this.IsAborted = false;

            /* Push top expression so the loop is able to enter
             * If the top expression is a single statement then the loop has nothing to do
             * Otherwise the expand expression will be evaluated and pushes code onto the EXEC stack */
            this.ExecStack.Push(program);
            this.CodeStack.Push(program);

            // run top expression
            this.ExecStack.Pop().Eval(this);

            this.Interpret();
        }

        private void Interpret()
        {
            if (!IsRunning)
            {
                return;
            }

            while (IsRunning)
            {
                this.DoStep();
            }

            if (this.Configuration.TopLevelPushCode)
            {
                this.CodeStack.Pop();
            }
        }

        private void DoStep()
        {
            var expression = this.ExecStack.Pop();

            if (!expression.IsCodeOp)
            {
                this.CodeStack.Push(expression);
            }

            expression.Eval(this);

            if (!expression.IsCodeOp)
            {
                CodeStack.Pop();
            }
        }

        private Task InterpreteAsync()
        {
            this.currentTask = Task.Run(() => this.Interpret());

            return this.currentTask;
        }

        public async Task AbortAsync()
        {
            if (this.IsAborted || this.IsCompleted)
                return;

            this.IsAborted = true;

            if (this.currentTask != null)
            {
                await this.currentTask;
            }
        }

        public async Task AbortAndReset()
        {
            await this.AbortAsync();
            this.Reset();
        }

        public async Task PauseAsync()
        {
            if (this.IsPaused || this.IsCompleted)
                return;

            this.IsPaused = true;

            if (this.currentTask != null)
            {
                await this.currentTask;
            }
        }

        public Task ResumeAsync()
        {
            if (this.IsPaused || !this.IsAborted)
            {
                this.IsPaused = false;
                return this.InterpreteAsync();
            }

            return this.currentTask;
        }

        public void Step()
        {
            if (CanStep)
            {
                DoStep();

                if (IsCompleted && this.Configuration.TopLevelPopCode)
                {
                    this.CodeStack.Pop();
                }
            }
        }

        public static Expression Encode(string code)
        {
            return Parser.Parse(code);
        }

        public static Task<Expression> EncodeAsync(string code, CancellationToken token = default(CancellationToken))
        {
            return Task.Run(() => Encode(code), token);
        }

        public static string Decode(Expression expression)
        {
            return string.Concat(expression.ToString());
        }

        public static Task<string> DecodeAsync(Expression expression, CancellationToken token = default(CancellationToken))
        {
            return Task.Run(() => Decode(expression), token);
        }

        public void PrintStacks()
        {
            this.PrintStack("EXEC", this.ExecStack);
            this.PrintStack("CODE", this.CodeStack);
            this.PrintStack("NAME", this.NameStack);
            this.PrintStack("BOOLEAN", this.BooleanStack);
            this.PrintStack("FLOAT", this.FloatStack);
            this.PrintStack("INTEGER", this.IntegerStack);
        }

        private void PrintStack<T>(string name, IStack<T> stack)
        {
            Console.WriteLine(string.Format(
                "--- {0} ---\n{1}\n---------------------------------------------------",
                name,
                stack));
        }
    }
}