|
public AddBinding ( |
||
| symbol | ||
| type | IScheminType | |
| Résultat | void | |
public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
{
ScheminAtom symbol = (ScheminAtom) args.Car;
ScheminLambda definition = (ScheminLambda) args.ElementAt(1);
ScheminRewriter rewriter = new ScheminRewriter(definition, env);
if (env.bindings.ContainsKey(symbol.Name))
{
env.RemoveBinding(symbol);
env.AddBinding(symbol, rewriter);
}
else
{
env.AddBinding(symbol, rewriter);
}
return new ScheminPair();
}
public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
{
bool deffun = false;
if ((args.Car as ScheminPair) != null)
{
deffun = true;
}
if (!deffun)
{
ScheminAtom symbol = (ScheminAtom) args.ElementAt(0);
IScheminType definition = args.ElementAt(1);
if (env.bindings.ContainsKey(symbol.Name))
{
env.RemoveBinding(symbol);
env.AddBinding(symbol, definition);
}
else
{
env.AddBinding(symbol, definition);
}
return new ScheminPair();
}
else
{
ScheminPair arguments = (ScheminPair) args.Car;
ScheminPair expression = args.ListCdr();
ScheminAtom name = (ScheminAtom) arguments.Car;
IScheminType lamParams = arguments.Cdr;
if (lamParams == null)
lamParams = new ScheminPair();
ScheminPair lamArgs = new ScheminPair(lamParams, expression);
ScheminLambda lam = new ScheminLambda(lamArgs, env);
if (env.bindings.ContainsKey(name.Name))
{
env.RemoveBinding(name);
env.AddBinding(name, lam);
}
else
{
env.AddBinding(name, lam);
}
return new ScheminPair();
}
}
public Environment MakeEnvironment(ScheminPair values, Evaluator eval)
{
if ((this.Arguments as ScheminPair) != null)
{
var argBindings = ExtractArguments(values, (ScheminPair) this.Arguments);
Environment args = new Environment();
args.parent = this.Closure;
foreach (KeyValuePair<ScheminAtom, IScheminType> binding in argBindings)
{
args.AddBinding(binding.Key, binding.Value);
}
return args;
}
else
{
Environment args = new Environment();
args.parent = this.Closure;
args.AddBinding((ScheminAtom) this.Arguments, values);
return args;
}
}
private void DefinePrimitives(Environment env)
{
foreach (KeyValuePair<string, Primitive> kvp in PrimitiveFactory.Primitives)
{
ScheminAtom symbol = new ScheminAtom(kvp.Key);
ScheminPrimitive prim = new ScheminPrimitive(kvp.Key);
env.AddBinding(symbol, prim);
}
var prebound_schemin = new List<string>();
prebound_schemin.Add(ScheminPrimitives.Map);
prebound_schemin.Add(ScheminPrimitives.Filter);
prebound_schemin.Add(ScheminPrimitives.Foldl);
prebound_schemin.Add(ScheminPrimitives.Foldr);
prebound_schemin.Add(ScheminPrimitives.Not);
prebound_schemin.Add(ScheminPrimitives.Id);
prebound_schemin.Add(ScheminPrimitives.Flip);
prebound_schemin.Add(ScheminPrimitives.Fold);
prebound_schemin.Add(ScheminPrimitives.Unfold);
prebound_schemin.Add(ScheminPrimitives.Reverse);
prebound_schemin.Add(ScheminPrimitives.Curry);
prebound_schemin.Add(ScheminPrimitives.Compose);
prebound_schemin.Add(ScheminPrimitives.Zero);
prebound_schemin.Add(ScheminPrimitives.Positive);
prebound_schemin.Add(ScheminPrimitives.Negative);
prebound_schemin.Add(ScheminPrimitives.Odd);
prebound_schemin.Add(ScheminPrimitives.Even);
prebound_schemin.Add(ScheminPrimitives.CallWithCC);
prebound_schemin.Add(ScheminPrimitives.Error);
prebound_schemin.Add(ScheminPrimitives.Sum);
prebound_schemin.Add(ScheminPrimitives.Product);
prebound_schemin.Add(ScheminPrimitives.Max);
prebound_schemin.Add(ScheminPrimitives.Min);
prebound_schemin.Add(ScheminPrimitives.Caddr);
prebound_schemin.Add(ScheminPrimitives.DefineMacro);
Tokenize.Tokenizer t = new Tokenize.Tokenizer();
Schemin.Parse.Parser p = new Parse.Parser();
foreach (string primitive in prebound_schemin)
{
var tokens = t.Tokenize(primitive);
var ast = p.Parse(tokens, false);
Evaluate(ast);
}
}
public override IScheminType Execute(Environment env, Evaluator eval, ScheminList args)
{
bool deffun = false;
if ((args.Car() as ScheminList) != null)
{
deffun = true;
}
if (!deffun)
{
ScheminAtom symbol = (ScheminAtom) args.Car();
IScheminType definition = args.Cdr().Car();
if (env.bindings.ContainsKey(symbol.Name))
{
env.RemoveBinding(symbol);
env.AddBinding(symbol, definition);
}
else
{
env.AddBinding(symbol, definition);
}
return new ScheminList(false);
}
else
{
ScheminList arguments = (ScheminList) args.Car();
ScheminList expression = args.Cdr();
ScheminAtom name = (ScheminAtom) arguments.Car();
ScheminList argSymbols = arguments.Cdr();
ScheminList lamArgs = new ScheminList(argSymbols, expression);
lamArgs.UnQuote();
ScheminLambda lam = new ScheminLambda(lamArgs, env);
if (env.bindings.ContainsKey(name.Name))
{
env.RemoveBinding(name);
env.AddBinding(name, lam);
}
else
{
env.AddBinding(name, lam);
}
return new ScheminList(false);
}
}
public Environment MakeEnvironment(ScheminList values, Evaluator eval)
{
if ((this.Arguments as ScheminList) != null)
{
ScheminList argslist = (ScheminList) this.Arguments;
IScheminType first = argslist.Car();
ScheminList rest = argslist.Cdr();
IScheminType firstArg = values.Car();
ScheminList restArgs = values.Cdr();
Environment args = new Environment();
args.parent = this.Closure;
for (; ;)
{
if (first.GetType() == typeof(ScheminList))
{
ScheminList tempFirst = (ScheminList) first;
if (tempFirst.Empty)
{
break;
}
}
ScheminAtom atom = (ScheminAtom) first;
if (atom.Name == ".")
{
restArgs.Cons(firstArg);
restArgs.Quote();
args.AddBinding((ScheminAtom) rest.Car(), restArgs);
break;
}
args.AddBinding((ScheminAtom) first, firstArg);
first = rest.Car();
firstArg = restArgs.Car();
rest = rest.Cdr();
restArgs = restArgs.Cdr();
}
return args;
}
else
{
Environment args = new Environment();
args.parent = this.Closure;
values.Quote();
args.AddBinding((ScheminAtom) this.Arguments, values);
return args;
}
}
