source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DoCountExpressions.cs @ 14513

namespace HeuristicLab.Algorithms.PushGP.Expressions {
  using HeuristicLab.Algorithms.PushGP.Interpreter;
  using HeuristicLab.Algorithms.PushGP.Stack;

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

    protected override void InitState(IPushGpInterpreter interpreter, IStack<Expression> sourceStack) {
      this.State.Body = sourceStack.Pop();
      this.State.DestinationIndex = interpreter.IntegerStack.Top;
      this.State.CurrentIndex = 1;
      this.State.Incrementor = 1;

      interpreter.IntegerStack.SetTop(0);
    }
  }

  /// <summary>
  ///     An iteration instruction that performs a loop (the body of which is taken from the CODE stack) the number of times
  ///     indicated by
  ///     the INTEGER argument, pushing an index (which runs from zero to one less than the number of iterations) onto the
  ///     INTEGER stack
  ///     prior to each execution of the loop body. This should be implemented as a macro that expands into a call to
  ///     CODE.DO*RANGE.
  ///     CODE.DO*COUNT takes a single INTEGER argument (the number of times that the loop will be executed) and a single
  ///     CODE argument
  ///     (the body of the loop). If the provided INTEGER argument is negative or zero then this becomes a NOOP. Otherwise it
  ///     expands into:
  ///     ( 0 '1 - IntegerArg>' CODE.QUOTE 'CodeArg' CODE.DO*RANGE )
  /// </summary>
  public class CodeDoCountExpression : DoCountExpression {
    protected override string InitStringRepresentation() {
      return "CODE.DO*COUNT";
    }

    public override void Eval(IPushGpInterpreter interpreter) {
      this.Eval(interpreter, interpreter.CodeStack);
    }
  }

  /// <summary>
  ///     An iteration instruction that performs a loop (the body of which is taken from the EXEC stack) the number of times
  ///     indicated
  ///     by the INTEGER argument, pushing an index (which runs from zero to one less than the number of iterations) onto the
  ///     INTEGER
  ///     stack prior to each execution of the loop body. This is similar to CODE.DO*COUNT except that it takes its code
  ///     argument from
  ///     the EXEC stack. This should be implemented as a macro that expands into a call to EXEC.DO*RANGE. EXEC.DO*COUNT
  ///     takes a single
  ///     INTEGER argument (the number of times that the loop will be executed) and a single EXEC argument (the body of the
  ///     loop). If
  ///     the provided INTEGER argument is negative or zero then this becomes a NOOP. Otherwise it expands into:
  ///     ( 0 '1 - IntegerArg' EXEC.DO* RANGE'ExecArg' )
  /// </summary>
  public class ExecDoCountExpression : DoCountExpression {
    protected override string InitStringRepresentation() {
      return "EXEC.DO*COUNT";
    }

    public override void Eval(IPushGpInterpreter interpreter) {
      this.Eval(interpreter, interpreter.ExecStack);
    }
  }
}