Entries.cs

Go to the documentation of this file.

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

namespace Mercury.Interpreting
{
//=============================================================================
//  <<  Evaluation Entries  >>
//=============================================================================

//==<<  DataEntry  >>==========================================================

    public interface DataEntry
    { }

//==<<  TextEntry  >>==========================================================

    public sealed class TextEntry : DataEntry
    {
        //--[  Internal  ]-----------------------------------------------------

        internal string   msg;
        internal object[] args;
        internal string   mem = null;

        internal TextEntry(string actname, string msg, params object[] args)
        {
            ActionName = actname;
            this.msg  = msg;
            this.args = args;
        }

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

        public string ActionName { get; internal set; }

        public string Text { get { return mem == null ? mem = string.Format(msg, args) : mem; } }
    }

//==<<  TreeEntry  >>==========================================================

    public sealed class TreeEntry<T> : DataEntry
        where T : class
    {
        //--[  Internal  ]-----------------------------------------------------

        internal List<DataEntry> Rules { get; set; }

        internal TreeEntry(Tree<Symbol> t)
        {
            Tree = t;
            Succeeded = false;
            Rules = new List<DataEntry>();
        }

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

        public Tree<Symbol> Tree { get; private set; }

        public bool Succeeded { get; internal set; }

        public IReadOnlyList<DataEntry> RuleEntries { get { return Rules; } }
    }

//==<<  MemoEntry  >>==========================================================

    public sealed class MemoEntry<T> : DataEntry
    {
        public T MemoizedValue { get; internal set; }
    }

//==<<  RuleEntry  >>==========================================================

    public sealed class RuleEntry<T> : DataEntry
        where T : class
    {
        //--[  Internal  ]-----------------------------------------------------

        internal List<DataEntry> Entries { get; set; }

        internal RuleEntry(RewriteRule<T> rwr)
        {
            RewriteRule = rwr;
            Match = false;
            Value = null;
            Error = true;
            Instances = null;
            Entries = new List<DataEntry>();
        }

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

        public RewriteRule<T> RewriteRule { get; private set; }

        public bool Match { get; internal set; }

        public T Value { get; internal set; }

        public bool Error { get; internal set; }

        public InstanceList Instances { get; internal set; }

        public IReadOnlyList<DataEntry> SubEntries { get { return Entries; } }

    }

//=============================================================================
//  EntryWriter
//=============================================================================

    public static class EntryWriter<T>
        where T : class
    {
        //--[  Private  methods  ]---------------------------------------------

        #region [  DEntry  ]

        private static void WriteDEntry(int lvl, DataEntry dentry, TextWriter o)
        {
            TreeEntry<T> tentry = dentry as TreeEntry<T>;
            if (tentry != null) WriteDEntry(lvl, tentry, o);
            else                WriteDEntry(lvl, dentry as TextEntry, o);
        }

        private static void WriteDEntry(int lvl, TreeEntry<T> tentry, TextWriter o)
        {
            var pad = new string('\t', lvl);
            o.WriteLine("{0}>>  {1}", pad, tentry.Tree);
            foreach (var rentry in tentry.RuleEntries)
                WriteREntry(lvl + 1, rentry, o);

            o.WriteLine("{0}<<  {{{1}}}", pad, tentry.Succeeded ? "SUCC" : "FAIL");
            o.WriteLine();
        }

        private static void WriteDEntry(int lvl, TextEntry tentry, TextWriter o)
        {
            var pad = new string('\t', lvl);
            o.WriteLine("{0}::  {1}: {2}", pad, tentry.ActionName, tentry.Text);
        }

        #endregion

        #region [  REntry  ]

        private static void WriteREntry(int lvl, DataEntry   dentry, TextWriter o)
        {
            var rentry = dentry as RuleEntry<T>;
            if (rentry != null) WriteREntry(lvl, rentry, o);
            else                WriteREntry(lvl, dentry as MemoEntry<T>, o);
        }

        private static void WriteREntry(int lvl, MemoEntry<T> mentry, TextWriter o)
        {
            var pad = new string('\t', lvl);
            o.WriteLine("{0}~~  {{MEMOIZED}} <{1}>", pad, 
                mentry.MemoizedValue == null ? "(null)" : mentry.MemoizedValue.ToString());
        }

        private static void WriteREntry(int lvl, RuleEntry<T> rentry, TextWriter o)
        {
            var pad = new string('\t', lvl);
            o.WriteLine("{0}->  {1}", pad, rentry.RewriteRule);
            if (rentry.Error)
                o.WriteLine("{0}    {{<EXCEPTION>}}", pad);
            else
                o.Write("{0}    {{{1}}} ", pad, rentry.Match ? "MATCH" : "no match");

            if (rentry.Match && (rentry.Instances.Count > 0))
            {
                int max = rentry.Instances.Select(x => x.Var.Name.Length).Max();
                var str = "{0,-" + max + "}";

                int ix = 0;
                foreach (var instance in rentry.Instances)
                {
                    o.Write(ix++ == 0 ? "{1} " : "{0}            ~~> ", pad, "~~>");
                    var obj = (instance.Var is Wildcard)
                        ? "{" + string.Join("; ", (instance.Value as Tree<Symbol>[]).Select(x => x.ToString(2))) + "}"
                        : (instance.Value as Tree<Symbol>).ToString(2);
                    o.WriteLine(str + " = {1}", instance.Var.Name, obj);
                }
            }
            else
                o.WriteLine();

            foreach (var tentry in rentry.SubEntries)
                WriteDEntry(lvl + 1, tentry, o);

            if (rentry.Match)
                o.WriteLine("{0}<-  ret <{1}>", pad, rentry.Value == null ? "(null)" : rentry.Value.ToString());
        }

        #endregion

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

        public static void WriteEntries(TreeEntry<T> root, TextWriter o)
        { WriteDEntry(0, root, o); }

    }

}