source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/DefineExpressions.cs @ 14392

using System;
using System.Collections.Generic;
using HeuristicLab.Algorithms.PushGP.Interpreter;
using HeuristicLab.Algorithms.PushGP.Stack;

namespace HeuristicLab.Algorithms.PushGP.Expressions
{
    /// <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> : Expression
    {
        public DefineExpression(string stringRepresentation) : base(stringRepresentation)
        { }

        protected void Eval(IStack<T> stack, IStack<string> nameStack, IDictionary<string, Expression> customExpressions, Func<T, Expression> creator)
        {
            // not enough arguments on stack
            if (nameStack.Count == 0 ||
                stack.Count < 1)
                return;

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

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

    public class CodeDefineExpression : DefineExpression<Expression>
    {
        public CodeDefineExpression() : base("CODE.DEFINE")
        {
        }

        public override void Eval(IInterpreter interpreter)
        {
            if (interpreter.Configuration.TopLevelPushCode &&
                interpreter.CodeStack.Count < 2)
                return;

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

            interpreter.CodeStack.Pop();
        }
    }

    public class ExecDefineExpression : DefineExpression<Expression>
    {
        public ExecDefineExpression() : base("EXEC.DEFINE")
        {
        }

        public override void Eval(IInterpreter interpreter)
        {
            if (interpreter.ExecStack.Count < 2)
                return;

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

            interpreter.ExecStack.Pop();
        }
    }

    public class FloatDefineExpression : DefineExpression<double>
    {
        public FloatDefineExpression() : base("FLOAT.DEFINE")
        {
        }

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

    public class IntegerDefineExpression : DefineExpression<long>
    {
        public IntegerDefineExpression() : base("INTEGER.DEFINE")
        {
        }

        public override void Eval(IInterpreter interpreter)
        {
            this.Eval(
                interpreter.IntegerStack,
                interpreter.NameStack,
                interpreter.CustomExpressions,
                v => new IntegerPushExpression(v));
        }
    }

    public class BooleanDefineExpression : DefineExpression<bool>
    {
        public BooleanDefineExpression() : base("BOOLENA.DEFINE")
        {
        }

        public override void Eval(IInterpreter interpreter)
        {
            this.Eval(
                interpreter.BooleanStack,
                interpreter.NameStack,
                interpreter.CustomExpressions,
                v => new BooleanPushExpression(v));
        }
    }
}