InterpreterAction.cs

Go to the documentation of this file.

using Mercury.Exceptions;
using Mercury.Nucleus.Trees;
using Mercury.Syntax;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Mercury.Interpreting
{
//=============================================================================
//  Utilities
//=============================================================================

    public delegate T RecursiveEval<T>(Tree<Symbol> tree, InterpreterContext<T> context)
        where T : class;

    //public delegate T ConvertFunc<T>(Argument[] args, RecursiveEval<T> eval, 
    //                                 InterpreterContext<T> context)
    //    where T : class;

    //public delegate T ConcatFunc<T>(T[] args)
    //    where T : class;

//=============================================================================
//  IInterpreterAction
//=============================================================================

    public abstract class InterpreterAction<T>
        where T : class
    {
        //--[  Protected methods  ]--------------------------------------------

        protected void CheckDefinition()
        {
            if (string.IsNullOrWhiteSpace(Name))
                throw new InvalidActionException(this.ToString(), "invalid action name");

            if ((Arity.Item1 < 0) || (Arity.Item2 < 0) || (Arity.Item1 > Arity.Item2))
                throw new InvalidActionException(this.ToString(), "invalid arity ({0}, {1})", Arity.Item1, Arity.Item2);

            if ((ArgumentTypes.Length == 0) && ((Arity.Item1 != 0) || (Arity.Item2 != 0)))
                throw new InvalidActionException(this.ToString(), "argument type list is empty");

            for (int ix = 0; ix < ArgumentTypes.Length; ++ix)
                if ((ArgumentTypes[ix] & ArgumentType.Any) == ArgumentType.None)
                    throw new InvalidActionException(this.ToString(), "argument type {0}, {1} is not a valid type", ix, ArgumentTypes[ix].ToString());
        }

        //--[  Constructors  ]-------------------------------------------------

        public InterpreterAction(string name, Tuple<int, int> arity, ArgumentType[] argtypes, 
            bool allowswild = true)
        {
            if (name     == null) throw new ArgumentNullException("name");
            if (arity    == null) throw new ArgumentNullException("arity");
            if (argtypes == null) throw new ArgumentNullException("argtypes");

            Name           = name;
            Arity          = arity;
            ArgumentTypes  = argtypes;
            ReturnType     = ArgumentType.TValue;
            AllowsWildcard = allowswild;

            CheckDefinition();
        }

        //--[  Properties  ]---------------------------------------------------

        public string Name { get; internal set; }

        public Tuple<int, int> Arity { get; internal set; }

        public ArgumentType ReturnType { get; internal set; }

        public ArgumentType[] ArgumentTypes { get; internal set; }

        public bool AllowsWildcard { get; internal set; }

        public abstract object Invoke(Argument[] arguments, RecursiveEval<T> eval, 
                                      InterpreterContext<T> context);
    }

//=============================================================================
//  InterpreterAction
//=============================================================================

    public abstract class InterpreterAction<T, U> : InterpreterAction<T>
        where T : class
    {
        //--[  Constructor  ]--------------------------------------------------

        public InterpreterAction(string name, Tuple<int, int> arity, 
            ArgumentType[] argtypes, bool allowswild = true)
            : base(name, arity, argtypes, allowswild)
        {
            ReturnType = Defaults.TypeToArgType<T, U>();
            var rtp    = Defaults.TypeToArgType<T, T>();

            if ((ReturnType & rtp) != ArgumentType.None)
                ReturnType |= ArgumentType.TValue;

            CheckDefinition();
        }

        //--[  Methods  ]------------------------------------------------------

        public abstract U Evaluate(Argument[] arguments, RecursiveEval<T> eval, 
                                   InterpreterContext<T> context);

        //--[  Interface implementation  ]-------------------------------------

        #region [  IInterpreterAction  ]

        public override object Invoke(Argument[] arguments, RecursiveEval<T> eval, 
                                      InterpreterContext<T> context)
        { return Evaluate(arguments, eval, context); }

        #endregion

    }

//=============================================================================
//  GenericAction
//=============================================================================

    public abstract class GenericAction<T> : InterpreterAction<T>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public GenericAction(string name, Tuple<int, int> arity, 
                             ArgumentType[] argtypes, bool allowswild = true)
            : base(name, arity, argtypes, allowswild)
        { ReturnType = ArgumentType.None; }

        //--[  Methods  ]------------------------------------------------------

        public abstract ArgumentType InferReturnType(ArgumentType expected, ArgumentType[] actual);
    }

}