source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DoTimesExpressions.cs @ 14744

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;

  public abstract class DoTimesExpression : LoopExpression {
    protected DoTimesExpression() { }
    protected DoTimesExpression(LoopState state) : base(state) { }
    protected override bool HasInsufficientArguments(IPushInterpreter interpreter, IStack<Expression> sourceStack) {
      return (interpreter.IntegerStack.Count < 1) || (sourceStack.Count == 0) || (interpreter.IntegerStack.Top <= 0);
    }

    protected override LoopState InitState(IPushInterpreter interpreter, IStack<Expression> sourceStack) {
      return new LoopState(
        body: sourceStack.Pop(),
        currentIndex: 1,
        destinationIndex: interpreter.IntegerStack.Pop(),
        incrementor: 1);
    }

    protected override void PushIteration(IPushInterpreter interpreter) {
      var newState = new LoopState(State.Body, State.CurrentIndex + this.State.Incrementor, State.DestinationIndex, State.Incrementor);
      var nextLoopExpression = Clone(newState);

      interpreter.ExecStack.Push(nextLoopExpression, this.State.Body);
    }

    protected override void PushLastIteration(IPushInterpreter interpreter) {
      interpreter.ExecStack.Push(this.State.Body);
    }
  }

  /// <summary>
  ///     Like CODE.DO*COUNT but does not push the loop counter.
  ///     This should be implemented as a macro that expands into CODE.DO*RANGE, similarly to the implementation
  ///     of CODE.DO*COUNT, except that a call to INTEGER.POP should be tacked on to the front of the loop body code
  ///     in the call to CODE.DO*RANGE.
  /// </summary>
  [PushExpression(StackType.Code, "CODE.DO*TIMES")]
  public class CodeDoTimesExpression : DoTimesExpression {
    public CodeDoTimesExpression() { }
    public CodeDoTimesExpression(LoopState state) : base(state) { }

    public override bool Eval(IPushInterpreter interpreter) {
      return this.Eval(interpreter, interpreter.CodeStack);
    }

    protected override LoopExpression Clone(LoopState state) {
      return new CodeDoTimesExpression(state);
    }
  }

  /// <summary>
  ///     Like EXEC.DO*COUNT but does not push the loop counter. This should be implemented as a macro that expands into
  ///     EXEC.DO*RANGE,
  ///     similarly to the implementation of EXEC.DO*COUNT, except that a call to INTEGER.POP should be tacked on to the
  ///     front of the
  ///     loop body code in the call to EXEC.DO*RANGE. This call to INTEGER.POP will remove the loop counter, which will have
  ///     been
  ///     pushed by EXEC.DO*RANGE, prior to the execution of the loop body.
  /// </summary>
  [PushExpression(StackType.Exec, "EXEC.DO*TIMES")]
  public class ExecDoTimesExpression : DoTimesExpression {
    public ExecDoTimesExpression() { }
    public ExecDoTimesExpression(LoopState state) : base(state) { }

    public override bool Eval(IPushInterpreter interpreter) {
      return this.Eval(interpreter, interpreter.ExecStack);
    }

    protected override LoopExpression Clone(LoopState state) {
      return new ExecDoTimesExpression(state);
    }
  }
}