RewriteRule.cs

Go to the documentation of this file.

using Mercury.Exceptions;
using Mercury.Nucleus.Collections;
using Mercury.Syntax;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Mercury.Interpreting
{
//=============================================================================
//  RewriteRuleValidator
//=============================================================================

    internal static class RewriteRuleValidator<T>
        where T : class
    {
        //--[  Private  ]------------------------------------------------------

        #region [  Variables check  ]

        private static void Variables(RewriteRule<T> rule, 
            out Dictionary<string, Variable> vars)
        {
            vars  = new Dictionary<string, Variable>();

            foreach (IElement element in rule.LHS.Where(x =>
                (x.Type == ElementType.Variable || x.Type == ElementType.Wildcard)))
            {
                var xvar = element as Variable;
                if (vars.ContainsKey(xvar.Name))
                    throw new InvalidRewriteRuleException(rule.ToString(),
                        "multiple declarations of variable '{0}'", xvar.Name);

                vars.Add(xvar.Name, xvar);
            }
        }

        #endregion

        #region [  Type resolution  ]

        private static ArgumentType ResolveType(RewriteRule<T> rule, ActionCall<T> call,
            Dictionary<string, Variable> vars, ArgumentType erttp)
        {
            int argtix = 0;
            List<ArgumentType> types = new List<ArgumentType>();

            for (int ix = 0; ix < call.FormalParameters.Count; ++ix)
            {
                ParameterType ptype    = call.FormalParameters[ix].Type;
                ArgumentType  expected = call.Action.ArgumentTypes[argtix] & ArgumentType.Any;
                ArgumentType  actual   = (ptype == ParameterType.ActionCall)
                    ? ResolveType(rule, call.FormalParameters[ix] as ActionCall<T>, vars, expected)
                    : Defaults.ParamToArgType(ptype);

                if ((actual & expected) == ArgumentType.None)
                    throw new InvalidActionArgumentException(rule.ToString(), call.ToString(), ix,
                        "got {0} of type {1} but {2} was expected", ptype, actual, expected);

                if (ptype == ParameterType.Variable)
                {
                    var vp = call.FormalParameters[ix] as VariableParameter;
                    if (!vars.ContainsKey(vp.Name))
                        throw new InvalidRewriteRuleException(rule.ToString(), "undefined variable '{0}'", vp.Name);

                    var vv = vars[vp.Name];
                    if (vv.Type == ElementType.Wildcard)
                    {
                        if (!call.Action.AllowsWildcard)
                            throw new InvalidActionArgumentException(rule.ToString(), call.ToString(), ix,
                                "the action does not allow wildcard arguments");

                        if (call.Action.Arity.Item2 != int.MaxValue)
                            throw new InvalidActionArgumentException(rule.ToString(), call.ToString(), ix,
                                "action arity is unsuitable for wildcards");

                        if (ix < call.Action.ArgumentTypes.Length - 1)
                            throw new InvalidActionArgumentException(rule.ToString(), call.ToString(), ix,
                                "the wildcard must be specifiet at least at position {0}",
                                call.Action.ArgumentTypes.Length - 1);

                        if ((call.Action.ArgumentTypes[call.Action.ArgumentTypes.Length - 1]
                            & ArgumentType.ParserEntity) == ArgumentType.None)
                            throw new InvalidActionArgumentException(rule.ToString(), call.ToString(), ix,
                                "unsuitable wildcard type");
                    }
                }

                types.Add(actual);
                argtix = Math.Min(call.Action.ArgumentTypes.Length - 1, ++argtix);
            }

            // generic type inference
            var action = call.Action as GenericAction<T>;
            if (action != null)
            {
                var inferred = action.InferReturnType(erttp, types.ToArray());
                var rtp      = Defaults.TypeToArgType<T, T>();
                action.ReturnType = inferred;

                // removes TValue flag if T is one of 
                // { object/dynamic, int, double, string, bool, Tree<Symbol>, Symbol }
                if ((rtp != ArgumentType.TValue) && ((rtp & inferred) == inferred))
                    inferred &= ~ArgumentType.TValue;

                // removes Real if inferred type is Integer | Real (coercion)
                if (inferred == (ArgumentType.Integer | ArgumentType.Real))
                    inferred = ArgumentType.Integer;

                // actual type check
                if ((inferred & ArgumentType.Any) == ArgumentType.None)
                    throw new InvalidActionCallException(call.ToString(), "generic return type inference failed");
            }

            if ((call.Action.ReturnType & erttp) == ArgumentType.None)
                throw new InvalidActionCallException(call.ToString(), 
                    "invalid return type; expected {0}; got {1}", erttp, call.Action.ReturnType);

            return call.Action.ReturnType;
        }

        #endregion

        //--[  Public methods  ]-----------------------------------------------

        public static void Validate(RewriteRule<T> rule)
        {
            if (rule == null) throw new ArgumentNullException("rule");

            Dictionary<string, Variable> vars;
            Variables(rule, out vars);
            ResolveType(rule, rule.RHS, vars, Defaults.TypeToArgType<T, T>());
        }
    }

//=============================================================================
//  RewriteRule
//=============================================================================

    public class RewriteRule<T> : IEquatable<RewriteRule<T>>
        where T : class
    {
        //--[  Constructors  ]-------------------------------------------------

        public RewriteRule(Structure lhs, ActionCall<T> rhs)
        {
            if (lhs == null) throw new ArgumentNullException("lhs");
            if (rhs == null) throw new ArgumentNullException("rhs");

            Head = lhs.Value;
            LHS  = lhs;
            RHS  = rhs;

            RewriteRuleValidator<T>.Validate(this);
        }

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

        public IElement Head { get; private set; }

        public Structure LHS  { get; private set; }

        public ActionCall<T> RHS  { get; private set; }

        public IReadOnlyList<Variable> Variables { get; private set; }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  Object      ]

        public override bool Equals(object obj)
        {
            RewriteRule<T> other = obj as RewriteRule<T>;
            return other == null ? false : Equals(other);
        }

        public override int GetHashCode()
        { return 17 * LHS.GetHashCode() + 41 * RHS.GetHashCode(); }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(LHS).Append(" ==> ").Append(RHS);

            return sb.ToString();
        }

        #endregion

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

        #region [  IEquatable  ]

        public bool Equals(RewriteRule<T> other)
        {
            return (other         != null)
                && (GetHashCode() == other.GetHashCode())
                && (LHS.Equals(other.LHS))
                && (RHS.Equals(other.RHS));
        }

        #endregion

    }
}