/CatExecutor.cs

/// Dedicated to the public domain by Christopher Diggins

/// http://creativecommons.org/licenses/publicdomain/



using System;

using System.Reflection;

using System.Reflection.Emit;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Diagnostics;

using System.ComponentModel;

using System.Text.RegularExpressions;



namespace Cat

{

    public interface INameLookup

    {

        Function Lookup(string s);

        Function ThrowingLookup(string s);

    }



    public class Executor : INameLookup

    {

        public TextReader input = Console.In;

        public TextWriter output = Console.Out;

        private Dictionary<string, Function> dictionary = new Dictionary<string, Function>();

        INameLookup otherNames;

        List<Object> stack = new List<Object>();



        public int testCount = 0;

        public bool bTrace = false;



        public Executor()

        {

        }



        public Executor(INameLookup other)

        {

            otherNames = other;

        }

        

        public Object Peek()

        {

            if (stack.Count == 0)

                throw new Exception("stack underflow occured");

            return stack[stack.Count - 1];

        }



        public void Push(Object o)

        {

            stack.Add(o);

        }



        public Object Pop()

        {

            Object o = Peek();

            stack.RemoveAt(stack.Count - 1);

            return o;

        }



        public Object PeekBelow(int n)

        {

            if (stack.Count <= n)

                throw new Exception("stack underflow occured");

            return stack[stack.Count - 1 - n];

        }



        public int Count()

        {

            return stack.Count;

        }



        public Object[] GetStackAsArray()

        {

            return stack.ToArray();

        }



        public void Dup()

        {

            if (Peek() is CatList)

                Push((Peek() as CatList).Clone());

            else

                Push(Peek());

        }



        public void Swap()

        {

            if (stack.Count < 2)

                throw new Exception("stack underflow occured");

            Object tmp = stack[stack.Count - 2];

            stack[stack.Count - 2] = stack[stack.Count - 1];

            stack[stack.Count - 1] = tmp;

        }



        public bool IsEmpty()

        {

            return Count() == 0;

        }



        public void Clear()

        {

            stack.Clear();

        }



        public string StackToString()

        {

            if (IsEmpty()) return "_empty_";

            string s = "";

            int nMax = 5;

            if (Count() > nMax) s = "...";

            if (Count() < nMax) nMax = Count();

            for (int i = nMax - 1; i >= 0; --i)

            {

                Object o = PeekBelow(i);

                s += Output.ObjectToString(o) + " ";

            }

            return s;

        }



        public T TypedPop<T>()

        {

            T result = TypedPeek<T>();

            Pop();

            return result;

        }



        public T TypedPeek<T>()

        {

            Object o = Peek();



            if (!(o is T))

                throw new Exception("Expected type " + typeof(T).Name + " but instead found " + o.GetType().Name);



            return (T)o;

        }



        public void PushInt(int n)

        {

            Push(n);

        }



        public void PushBool(bool x)

        {

            Push(x);

        }



        public void PushString(string x)

        {

            Push(x);

        }



        public void PushFxn(Function x)

        {

            Push(x);

        }



        public int PopInt()

        {

            return TypedPop<int>();

        }



        public bool PopBool()

        {

            return TypedPop<bool>();

        }



        public QuotedFunction PopFxn()

        {

            return TypedPop<QuotedFunction>();

        }



        public String PopString()

        {

            return TypedPop<String>();

        }



        public CatList PopList()

        {

            return TypedPop<CatList>();

        }



        public Function PeekFxn()

        {

            return TypedPeek<Function>();

        }



        public String PeekString()

        {

            return TypedPeek<String>();

        }



        public int PeekInt()

        {

            return TypedPeek<int>();

        }



        public bool PeekBool()

        {

            return TypedPeek<bool>();

        }



        public CatList PeekList()

        {

            return TypedPeek<CatList>();

        }



        public void Import()

        {

            LoadModule(PopString());

        }



        public void LoadModule(string s)

        {

            bool b1 = Config.gbVerboseInference;

            bool b2 = Config.gbShowInferredType;

            Config.gbVerboseInference = Config.gbVerboseInferenceOnLoad;

            Config.gbShowInferredType = false;

            try

            {

                Execute(Util.FileToString(s));

            }

            catch (Exception e)

            {

                Output.WriteLine("Failed to load \"" + s + "\" with message: " + e.Message);

            }

            Config.gbVerboseInference = b1;

            Config.gbShowInferredType = b2;

        }



        public void Execute(string s)

        {

            List<CatAstNode> nodes = CatParser.Parse(s + "\n");

            Execute(nodes);

        }



        public void OutputStack()

        {

            Output.WriteLine("stack: " + StackToString());

        }



        public Function LiteralToFunction(string name, AstLiteral literal)

        {

            switch (literal.GetLabel())

            {

                case AstLabel.Int:

                    {

                        AstInt tmp = literal as AstInt;

                        return new PushInt(tmp.GetValue());

                    }

                case AstLabel.Bin:

                    {

                        AstBin tmp = literal as AstBin;

                        return new PushInt(tmp.GetValue());

                    }

                case AstLabel.Char:

                    {

                        AstChar tmp = literal as AstChar;

                        return new PushValue<char>(tmp.GetValue());

                    }

                case AstLabel.String:

                    {

                        AstString tmp = literal as AstString;

                        return new PushValue<string>(tmp.GetValue());

                    }

                case AstLabel.Float:

                    {

                        AstFloat tmp = literal as AstFloat;

                        return new PushValue<double>(tmp.GetValue());

                    }

                case AstLabel.Hex:

                    {

                        AstHex tmp = literal as AstHex;

                        return new PushInt(tmp.GetValue());

                    }

                case AstLabel.Quote:

                    {

                        AstQuote tmp = literal as AstQuote;

                        CatExpr fxns = NodesToFxns(name, tmp.GetTerms());

                        if (Config.gbOptimizeQuotations)

                            MetaCat.ApplyMacros(this, fxns);

                        return new PushFunction(fxns);

                    }

                case AstLabel.Lambda:

                    {

                        AstLambda tmp = literal as AstLambda;

                        CatLambdaConverter.Convert(tmp);

                        CatExpr fxns = NodesToFxns(name, tmp.GetTerms());

                        if (Config.gbOptimizeLambdas) 

                            MetaCat.ApplyMacros(this, fxns);

                        return new PushFunction(fxns);

                    }

                default:

                    throw new Exception("unhandled literal " + literal.ToString());

            }

        }



        void Trace(string s)

        {

            if (bTrace) Output.WriteLine("trace: " + s);

        }

        

        /// <summary>

        /// This function is optimized to handle tail-calls with increasing the stack size.

        /// </summary>

        /// <param name="fxns"></param>

        public void Execute(CatExpr fxns)

        {

            int i = 0;

            while (i < fxns.Count)

            {

                Function f = fxns[i];

                

                // Check if this is a tail call

                // if so then we are going to avoid creating a new stack frame

                if (i == fxns.Count - 1 && f.GetSubFxns() != null)

                {

                    Trace("tail-call of '" + f.GetName() + "' function");

                    fxns = f.GetSubFxns();

                    i = 0;

                }                   

                else if (i == fxns.Count - 1 && f is Primitives.If)

                {

                    Trace("tail-call of 'if' function");

                    QuotedFunction onfalse = PopFxn();

                    QuotedFunction ontrue = PopFxn();



                    if (PopBool())

                        fxns = ontrue.GetSubFxns(); else

                        fxns = onfalse.GetSubFxns();



                    i = 0;

                }

                else if (i == fxns.Count - 1 && f is Primitives.ApplyFxn)

                {

                    Trace("tail-call of 'apply' function");

                    QuotedFunction q = PopFxn();

                    fxns = q.GetSubFxns();

                    i = 0;

                }

                else

                {

                    Trace(f.ToString());

                    f.Eval(this);

                    ++i;

                }

            }

        }



        public CatExpr NodesToFxns(string name, List<CatAstNode> nodes)

        {

            CatExpr result = new CatExpr(); 

            for (int i = 0; i < nodes.Count; ++i)

            {

                CatAstNode node = nodes[i];

                if (node.GetLabel().Equals(AstLabel.Name))

                {

                    string s = node.ToString();

                    if (s.Equals(name))

                        result.Add(new SelfFunction(name));

                    else

                        result.Add(ThrowingLookup(s));

                }

                else if (node is AstLiteral)

                {

                    result.Add(LiteralToFunction(name, node as AstLiteral));

                }

                else if (node is AstDef)

                {

                    MakeFunction(node as AstDef);

                }

                else if (node is AstMacro)

                {

                    MetaCat.AddMacro(node as AstMacro);

                }

                else

                {

                    throw new Exception("unable to convert node to function: " + node.ToString());

                }

            }

            return result;

        }

        

        public void Execute(List<CatAstNode> nodes)

        {

            Execute(NodesToFxns("self", nodes));

        }



        public void ClearTo(int n)

        {

            while (Count() > n)

                Pop();

        }



        public CatList GetStackAsList()

        {

            return new CatList(stack);

        }



        #region dictionary management

        public void RegisterType(Type t)

        {

            foreach (Type memberType in t.GetNestedTypes())

            {

                // Is is it a function object

                if (typeof(Function).IsAssignableFrom(memberType))

                {

                    ConstructorInfo ci = memberType.GetConstructor(new Type[] { });

                    Object o = ci.Invoke(null);

                    if (!(o is Function))

                        throw new Exception("Expected only function objects in " + t.ToString());

                    Function f = o as Function;

                    AddFunction(f);

                }

                else

                {

                    RegisterType(memberType);

                }

            }

            foreach (MemberInfo mi in t.GetMembers())

            {

                if (mi is MethodInfo)

                {

                    MethodInfo meth = mi as MethodInfo;

                    if (meth.IsStatic) {

                        Function f = AddMethod(null, meth);

                        if (f != null)

                            f.msTags = "level2";

                    }

                }

            }

        }



        /// <summary>

        /// Creates an ObjectBoundMethod for each public function in the object

        /// </summary>

        /// <param name="o"></param>

        public void RegisterObject(Object o)

        {

            foreach (MemberInfo mi in o.GetType().GetMembers())

            {

                if (mi is MethodInfo)

                {

                    MethodInfo meth = mi as MethodInfo;

                    AddMethod(o, meth);

                }

            }

        }



        #region INameLookup implementation

        public Function Lookup(string s)

        {

            if (s.Length < 1)

                throw new Exception("trying to lookup a function with no name");



            if (dictionary.ContainsKey(s))

                return dictionary[s];



            if (otherNames != null)

                return otherNames.Lookup(s);



            return null;

        }



        public Function ThrowingLookup(string s)

        {

            Function f = Lookup(s);

            if (f == null)

                throw new Exception("could not find function " + s);

            return f;

        }

        #endregion



        /// <summary>

        /// Methods allow overloading of function definitions.

        /// </summary>

        public Function AddMethod(Object o, MethodInfo mi)

        {

            // Does not add public methods. 

            if (!mi.IsPublic)

                return null;                



            if (mi.IsStatic)

                o = null;



            Method f = new Method(o, mi);

            AddFunction(f);

            return f;

        }



        public List<Function> GetAllFunctions()

        {

            List<Function> fxns = new List<Function>(dictionary.Values);

            fxns.Sort(delegate(Function x, Function y) { 

                return x.GetName().CompareTo(y.GetName()); 

            });

            return fxns;

        }



        public Dictionary<string, List<Function>> GetFunctionsByTag()

        {

            Dictionary<string, List<Function> > ret = new Dictionary<string, List<Function>>();

            foreach (Function f in GetAllFunctions()) 

            {

                foreach (string s in f.GetTags()) 

                {

                    string s2 = s.Trim();

                    if (s.Length > 0)

                    {

                        if (!ret.ContainsKey(s2))

                            ret.Add(s2, new List<Function>());

                        ret[s2].Add(f);

                    }

                }

            }

            return ret;

        }





        public bool TestFunction(Function f)

        {

            bool bRet = true;

            testCount += 1;

            CatMetaDataBlock md = f.GetMetaData();

            if (md != null)

            {

                List<CatMetaData> tests = md.FindAll("test");

                foreach (CatMetaData test in tests)

                {

                    CatMetaData input = test.Find("in");

                    CatMetaData output = test.Find("out");

                    if (input == null || output == null)

                    {

                        Output.WriteLine("ill-formed test in " + f.GetName());

                        return false;

                    }

                    try

                    {

                        Executor aux = new Executor(this);

                        aux.Execute(input.GetContent());

                        CatList listInput = aux.GetStackAsList();

                        aux.Clear();

                        aux.Execute(output.GetContent());

                        CatList listOutput = aux.GetStackAsList();

                        aux.Clear();

                        

                        if (!listInput.Equals(listOutput))

                        {

                            Output.WriteLine("failed test for instruction " + f.GetName());

                            Output.WriteLine("test input program = " + input.GetContent());

                            Output.WriteLine("test output program = " + output.GetContent());

                            Output.WriteLine("input program result = " + listInput.ToString());

                            Output.WriteLine("output program result = " + listOutput.ToString());

                            bRet = false;

                        }

                    }

                    catch (Exception e)

                    {

                        Output.WriteLine("failed test for instruction " + f.GetName());

                        Output.WriteLine("exception occured: " + e.Message);

                        bRet = false;

                    }

                }

            }

            return bRet;

        }



        public Function MakeFunction(AstDef def) 

        {

            bool bLambda = def.mParams.Count > 0 || def.mLocals.Count > 0;

            if (bLambda)

                CatLambdaConverter.Convert(def);

            CatExpr fxns = NodesToFxns(def.mName, def.mTerms);

            Function ret = new DefinedFunction(def.mName, fxns);

            if (def.mpMetaData != null) {

                ret.SetMetaData(new CatMetaDataBlock(def.mpMetaData));

            }

            if (bLambda && Config.gbOptimizeLambdas)

                MetaCat.ApplyMacros(this, fxns);



            AddFunction(ret);

            return ret;

        }



        public Function AddFunction(Function f)

        {

            string s = f.GetName();

            if (dictionary.ContainsKey(s))

            {

                if (!Config.gbAllowRedefines)

                    throw new Exception("can not overload functions " + s);

                dictionary[s] = f;

            }

            else

            {

                dictionary.Add(s, f);

            }

            return f;

        }



        #endregion

    }

}