Exemple #1
0
        public override SValue Clone()
        {
            SClosure ret = new SClosure(InnerEnv, Arguments, Body);

            SValue.CopyAttributes(ret, this);
            return(ret);
        }
Exemple #2
0
        private SValue execLoop(SClosure body, SValue v, Decimal idx)
        {
            var newEnv = new ExecEnvironment();

            if (body.Arguments.Count >= 1)
            {
                newEnv[body.Arguments[0]] = v;
            }

            if (body.Arguments.Count == 2)
            {
                newEnv[body.Arguments[1]] = new SNumber(idx);
            }

            newEnv.ParentEnv = body.InnerEnv;
            return(body.Body.Evaluate(newEnv));
        }
Exemple #3
0
        public override SValue Evaluate(ExecEnvironment env)
        {
            var      newEnv = new ExecEnvironment();
            SValue   _closure;
            SClosure closure = null;

            if (lambdaObject == null)
            {
                if (env.ContainsKey(closureName))
                {
                    _closure = env[closureName].Evaluate(env);
                    closure  = _closure as SClosure;
                }
                else
                {
                    _closure         = new SString(closureName);
                    env[closureName] = _closure;
                }
            }
            else
            {
                _closure = lambdaObject.Evaluate(env);
                closure  = _closure as SClosure;
            }

            List <SValue> arguments = SExpression.EvalSExpressions(this.arguments, env);

            if (closure == null)
            {
                List <SValue> ret = new List <SValue>();
                ret.Add(_closure);
                foreach (var a in arguments)
                {
                    ret.Add(a);
                }

                return(new SList(ret));
            }

            if (closure.Arguments.Count() > arguments.Count())
            {
                var argNames = closure.Arguments.Skip(arguments.Count);
                return(new SClosure(
                           env, argNames.ToList(), new SECall(
                               closure,
                               arguments.ConvertAll(a => (SExpression)a)
                               .Concat(argNames.Select(a => new SEVariable(a, headAtom, tailCompound))).ToList(),
                               headAtom, tailCompound
                               )
                           ));
            }

            // prepare the executing environment
            for (int i = 0; i < closure.Arguments.Count(); i++)
            {
                string argName = closure.Arguments[i];

                if (argName.Length > 3 && argName.Substring(argName.Length - 3) == "...")
                {
                    argName         = argName.Substring(0, argName.Length - 3);
                    newEnv[argName] = new SList(arguments.Skip(i).ToList());
                    break;
                }
                else
                {
                    newEnv[argName] = arguments[i];
                }
            }

            newEnv["~parent"] = new SDict(closure.InnerEnv);
            newEnv["~atom"]   = new SObject(headAtom);

            newEnv.ParentEnv = closure.InnerEnv;
            return(closure.Body.Evaluate(newEnv));
        }