source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/PushGPInterpreter.cs @ 14513

namespace HeuristicLab.Algorithms.PushGP.Interpreter {
  using System;
  using System.Collections.Generic;
  using System.Threading;
  using System.Threading.Tasks;
  using HeuristicLab.Algorithms.PushGP.Expressions;
  using HeuristicLab.Algorithms.PushGP.Parser;
  using HeuristicLab.Algorithms.PushGP.Stack;

  public class PushGpInterpreter : IPushGpInterpreter {
    private Task currentTask;

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

      // setting the capacity of the stacks to max points ensures that there will be enough memory at runtime
      this.CodeStack = new PushGPStack<Expression>(this.Configuration.MaxPointsInProgram);
      this.ExecStack = new PushGPStack<Expression>(this.Configuration.MaxPointsInProgram);
      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 int ExecCounter { get; private set; }

    public bool IsPaused { get; private set; }

    public bool IsAborted { get; private set; }

    public bool IsRunning
    {
      get
      {
        return !this.ExecStack.IsEmpty &&
               !this.IsPaused &&
               !this.IsAborted &&
               (this.ExecCounter < this.Configuration.EvalPushLimit);
      }
    }

    public bool IsCompleted
    {
      get
      {
        return this.ExecStack.Count == 0;
      }
    }

    public bool CanStep
    {
      get
      {
        return !this.IsCompleted && !this.IsAborted && this.IsPaused;
      }
    }

    public Configuration Configuration { get; protected set; }

    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 bool IsNameQuoteFlagSet { get; set; }

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

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

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

      return this.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 this.currentTask;
    }

    public void Interpret(Expression program) {
      /* 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);

      if (this.Configuration.TopLevelPushCode) this.CodeStack.Insert(0, program);

      // run top expression
      this.DoStep();

      this.Interpret();
    }

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

      this.IsAborted = true;

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

    public async Task AbortAndResetAsync() {
      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 (!this.CanStep) return;
      this.DoStep();
      this.Finally();
    }

    public void Step(int count) {
      for (var i = 0; i < count; i++) this.Step();
    }

    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);
    }

    /// <summary>
    /// Clears stacks and
    /// </summary>
    public void Reset() {
      this.IsAborted = false;
      this.IsPaused = false;
      this.currentTask = null;

      this.Clear();
    }

    /// <summary>
    /// Clears stacks
    /// </summary>
    public void Clear() {
      this.ExecCounter = 0;

      this.ExecStack.Clear();
      this.CodeStack.Clear();

      this.NameStack.Clear();
      this.BooleanStack.Clear();
      this.IntegerStack.Clear();
      this.FloatStack.Clear();

      this.CustomExpressions.Clear();
    }

    private void Interpret() {
      while (this.IsRunning) {
        this.DoStep();
        this.ExecCounter++;
      }

      this.Finally();
    }

    private void Finally() {
      if (!this.IsCompleted)
        return;

      if (this.Configuration.TopLevelPopCode && (this.CodeStack.Count > 0))
        this.CodeStack.Pop();
    }

    private void DoStep() {
      this.ExecStack.Pop().Eval(this);
    }

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

      return this.currentTask;
    }

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