C# Machine.Evaluate方法代码示例

        public object Apply(Machine machine, ValueEnvironment environment, object[] arguments)
        {
            object name = arguments[0];

            object result = machine.Evaluate(name, environment);

            Type type = null;

            if (!(result is Type))
            {
                if (name is INamed || name is string)
                    type = Utilities.GetType(name);

                if (type == null)
                    throw new ArgumentException("New should receive a type name");
            }
            else
                type = (Type)result;

            object[] parameters = new object[arguments.Length - 1];

            for (int k = 1; k < arguments.Length; k++)
                parameters[k - 1] = machine.Evaluate(arguments[k], environment);

            return Activator.CreateInstance(type, parameters);
        }

        public object ApplyToObject(object obj, Machine machine, ValueEnvironment environment, object[] arguments)
        {
            Type type = obj.GetType();
            INamed named = null;
            object[] pars = null;

            if (arguments[1] is IList)
            {
                IList parameters = (IList)arguments[1];
                named = (INamed)parameters[0];
                pars = new object[parameters.Count - 1];
                for (int k = 1; k < parameters.Count; k++)
                    pars[k - 1] = machine.Evaluate(parameters[k], environment);
            }
            else
            {
                named = (INamed)arguments[1];
                pars = new object[arguments.Length - 2];

                for (int k = 2; k < arguments.Length; k++)
                    pars[k - 2] = machine.Evaluate(arguments[k], environment);
            }

            return type.InvokeMember(named.Name, System.Reflection.BindingFlags.GetProperty | System.Reflection.BindingFlags.IgnoreCase | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.Instance, null, obj, pars);
        }

        public object Evaluate(Machine machine, ValueEnvironment environment)
        {
            // TODO get a predefined empty dictionary object
            IPersistentMap map = new DictionaryObject(new Hashtable());

            foreach (DictionaryEntry entry in this.map)
            {
                object key = machine.Evaluate(entry.Key, environment);
                object value = machine.Evaluate(entry.Value, environment);

                map = map.Associate(key, value);
            }

            return map;
        }

        public object Apply(Machine machine, ValueEnvironment environment, object[] arguments)
        {
            object result = null;
            ValueEnvironment newenv = null;

            foreach (object argument in arguments)
            {
                if (newenv == null)
                {
                    newenv = new ValueEnvironment(environment);

                    if (argument != null)
                    {
                        if (!(argument is ICollection))
                            throw new InvalidOperationException("Let must receive a list as first argument");

                        Utilities.EvaluateBindings(machine, newenv, (ICollection)argument);
                    }
                }
                else
                    result = machine.Evaluate(argument, newenv);
            }

            return result;
        }

        public object Evaluate(Machine machine, ValueEnvironment environment)
        {
            if (this.elements == null || this.elements.Count == 0)
                return null;

            IExpression formhead = (IExpression)Utilities.ToExpression(this.elements[0]);

            IFunction function = (IFunction)formhead.Evaluate(machine, environment);

            if (function == null)
            {
                if (this.elements[0] is INamed)
                    throw new InvalidOperationException(string.Format("Unknown form {0}", ((INamed)this.elements[0]).FullName));
                else
                    throw new InvalidOperationException(string.Format("Unknown form {0}", this.elements[0].ToString()));
            }

            object[] arguments = null;

            if (this.elements.Count > 1)
                arguments = new object[this.elements.Count - 1];

            if (function.IsSpecialForm)
                for (int k = 1; k < this.elements.Count; k++)
                    arguments[k - 1] = this.elements[k];
            else
                for (int k = 1; k < this.elements.Count; k++)
                    arguments[k - 1] = machine.Evaluate(this.elements[k], environment);

            return function.Apply(machine, environment, arguments);
        }

        public object Evaluate(Machine machine, ValueEnvironment environment)
        {
            IDictionary result = new Hashtable();

            foreach (object key in this.dictionary.Keys)
            {
                object value = this.dictionary[key];

                object newkey = machine.Evaluate(key, environment);

                object newvalue = machine.Evaluate(value, environment);

                result[newkey] = newvalue;
            }

            return result;
        }

        public object Apply(Machine machine, ValueEnvironment environment, object[] arguments)
        {
            object result = null;

            foreach (object argument in arguments)
                result = machine.Evaluate(argument, environment);

            return result;
        }

        public object Evaluate(Machine machine, ValueEnvironment environment)
        {
            object[] result = new object[this.vector.Count];

            for (int k = 0; k < this.vector.Length; k++)
                result[k] = machine.Evaluate(this.vector[k], environment);

            return PersistentVector.Create(result);
        }

        public object Apply(Machine machine, ValueEnvironment environment, object[] arguments)
        {
            if (arguments == null || arguments.Length < 2)
                throw new InvalidOperationException("If should receive a test and a body");
            if (arguments.Length > 3)
                throw new InvalidOperationException("Too many arguments to If");

            object result = machine.Evaluate(arguments[0], environment);

            if (Utilities.IsFalse(result))
            {
                if (arguments.Length == 3)
                    return machine.Evaluate(arguments[2], environment);
                return null;
            }
            else
                return machine.Evaluate(arguments[1], environment);
        }

        public object Apply(Machine machine, ValueEnvironment environment, object[] arguments)
        {
            if (arguments == null || arguments.Length == 0)
                return null;

            object result = null;
            ValueEnvironment newenv = null;
            string[] names = null;

            newenv = new ValueEnvironment(environment);

            object argument = arguments[0];

            if (argument != null)
            {
                if (!(argument is ICollection))
                    throw new InvalidOperationException("Let must receive a list as first argument");

                names = Utilities.EvaluateBindings(machine, newenv, (ICollection)argument);
            }

            for (int k = 1; k < arguments.Length; k++)
                result = machine.Evaluate(arguments[k], newenv);

            while (result != null && result is RecursionData)
            {
                RecursionData data = (RecursionData)result;

                if (Utilities.GetArity(data.Arguments) != Utilities.GetArity(names))
                    throw new InvalidOperationException("Invalid recursion data");

                newenv = new ValueEnvironment(environment);
                result = null;

                for (int k = 0; k < names.Length; k++)
                    newenv.SetValue(names[k], data.Arguments[k]);

                for (int k = 1; k < arguments.Length; k++)
                    result = machine.Evaluate(arguments[k], newenv);
            }

            return result;
        }

        public object Apply(Machine machine, ValueEnvironment environment, object[] arguments)
        {
            Symbol symbol = (Symbol)arguments[0];

            if (!string.IsNullOrEmpty(symbol.Namespace))
                throw new InvalidOperationException("Defined name should not have namespace");

            Variable variable = Utilities.ToVariable(machine, environment, symbol);

            object value = machine.Evaluate(arguments[1], environment);

            if (symbol.Metadata != null)
            {
                IDictionary dictionary = (IDictionary)symbol.Metadata;
                IDictionary evaluated = new Hashtable();

                foreach (object key in dictionary.Keys)
                {
                    object val = machine.Evaluate(dictionary[key], environment);
                    evaluated[key] = val;
                }

                variable.ResetMetadata(new DictionaryObject(evaluated));
            }
            else
                variable.ResetMetadata(null);

            IPersistentMap metadata = variable.Metadata;

            if (metadata != null && metadata.ContainsKey(macroKeyword))
                if ((bool)metadata.ValueAt(macroKeyword) && value is DefinedFunction)
                    value = ((DefinedFunction)value).ToMacro();

            machine.SetVariableValue(variable, value);

            if (value is IFunction && ((IFunction)value).IsSpecialForm)
                machine.Environment.SetValue(variable.Name, value, true);

            return value;
        }

        public object Apply(Machine machine, ValueEnvironment environment, object[] arguments)
        {
            object name = arguments[0];

            object result = machine.Evaluate(name, environment);

            Type type = null;

            if (name is INamed || name is string)
                type = Utilities.GetType(name);

            if (type != null)
                return this.ApplyToType(type, machine, environment, arguments);

            return this.ApplyToObject(result, machine, environment, arguments);
        }