source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/DefineExpressions.cs @ 14875

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
  using System;
  using System.Collections.Generic;

  using Attributes;
  using Interpreter;
  using Stack;

  /// <summary>
  ///     Defines the name on top of the NAME stack as an instruction that will push the top item of the T stack onto the
  ///     EXEC stack.
  /// </summary>
  /// <typeparam name="T">Stacktype</typeparam>
  public abstract class DefineExpression<T> : StatelessExpression {
    protected bool Eval(
      IPushStack<T> stack,
      IPushStack<string> nameStack,
      IDictionary<string, Expression> customExpressions,
      Func<T, Expression> creator) {
      // not enough arguments on stack
      if ((nameStack.Count == 0) || (stack.Count < 1)) return false;

      var name = nameStack.Pop();
      var expression = creator(stack.Top);

      if (customExpressions.ContainsKey(name)) customExpressions[name] = expression;
      else customExpressions.Add(name, expression);

      return true;
    }
  }

  [PushExpression(StackTypes.Code, "CODE.DEFINE", StackTypes.Name)]
  public class CodeDefineExpression : DefineExpression<Expression> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      if (interpreter.Configuration.TopLevelPushCode && (interpreter.CodeStack.Count < 2)) return false;

      this.Eval(
        interpreter.CodeStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new ExecPushExpression(v));

      interpreter.CodeStack.Pop();

      return true;
    }
  }

  [PushExpression(StackTypes.Exec, "EXEC.DEFINE", StackTypes.Name)]
  public class ExecDefineExpression : DefineExpression<Expression> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      if (interpreter.ExecStack.Count < 2) return false;

      var noop = this.Eval(
        interpreter.ExecStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new ExecPushExpression(v));

      if (!noop)
        interpreter.ExecStack.Pop();

      return noop;
    }
  }

  [PushExpression(StackTypes.Float, "FLOAT.DEFINE", StackTypes.Name)]
  public class FloatDefineExpression : DefineExpression<double> {

    public override bool Eval(IInternalPushInterpreter interpreter) {
      return this.Eval(
        interpreter.FloatStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new FloatPushExpression(v));
    }
  }

  [PushExpression(StackTypes.Integer, "INTEGER.DEFINE", StackTypes.Name)]
  public class IntegerDefineExpression : DefineExpression<long> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      return this.Eval(
        interpreter.IntegerStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new IntegerPushExpression(v));
    }
  }

  [PushExpression(StackTypes.Boolean, "BOOLEAN.DEFINE", StackTypes.Name)]
  public class BooleanDefineExpression : DefineExpression<bool> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      return this.Eval(
        interpreter.BooleanStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new BooleanPushExpression(v));
    }
  }

  [PushExpression(StackTypes.Char, "CHAR.DEFINE", StackTypes.Name)]
  public class CharDefineExpression : DefineExpression<char> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      return Eval(
        interpreter.CharStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new CharPushExpression(v));
    }
  }

  [PushExpression(StackTypes.String, "STRING.DEFINE", StackTypes.Name)]
  public class StringDefineExpression : DefineExpression<string> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      return Eval(
        interpreter.StringStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new StringPushExpression(v));
    }
  }

  [PushExpression(StackTypes.IntegerVector, "INTEGER[].DEFINE", StackTypes.Name)]
  public class IntegerVectorDefineExpression : DefineExpression<List<long>> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      return Eval(
        interpreter.IntegerVectorStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new IntegerVectorPushExpression(v));
    }
  }

  [PushExpression(StackTypes.FloatVector, "FLOAT[].DEFINE", StackTypes.Name)]
  public class FloatVectorDefineExpression : DefineExpression<List<double>> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      return Eval(
        interpreter.FloatVectorStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new FloatVectorPushExpression(v));
    }
  }

  [PushExpression(StackTypes.BooleanVector, "BOOLEAN[].DEFINE", StackTypes.Name)]
  public class BooleanVectorDefineExpression : DefineExpression<List<bool>> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      return Eval(
        interpreter.BooleanVectorStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new BooleanVectorPushExpression(v));
    }
  }

  [PushExpression(StackTypes.StringVector, "STRING[].DEFINE", StackTypes.Name)]
  public class StringVectorDefineExpression : DefineExpression<List<string>> {
    public override bool Eval(IInternalPushInterpreter interpreter) {
      return Eval(
        interpreter.StringVectorStack,
        interpreter.NameStack,
        interpreter.CustomExpressions,
        v => new StringVectorPushExpression(v));
    }
  }
}