public static Object Try(Cons args, Environment environment)
{
try
{
return(Runtime.Eval(args.First(), environment));
}
catch (Exception e)
{
environment.AssignLocal(Symbol.IT, e);
// If a catch form is specified then evaluate it
if (args.Second() as Symbol == Symbol.NULL)
{
throw;
}
return(Runtime.Eval(args.Second(), environment));
}
finally
{
// If a finally form was specified then evaluate it
if (args.Length() > 2)
{
Runtime.Eval(args.Third(), environment);
}
}
}
public static Object DefClass(Cons args, Environment environment)
{
string className = args.First().ToString();
Cons superClasses = args.Cadr() as Cons;
string superClass = null;
string interfaces = null;
if (superClasses != null)
{
superClass = superClasses.First().ToString();
if (superClasses.Length() >= 2)
{
StringBuilder b = new StringBuilder();
b.Append(superClasses.Second());
foreach (object item in (Cons)superClasses.Cddr())
{
b.Append(", " + item);
}
interfaces = b.ToString();
}
}
return(ClassBuilder.CreateClass(className, superClass, interfaces));
}
public static Object Assoc(Cons args, Environment environment)
{
/*
*
* (defun assoc (item lst)
* (= m null)
* (each c lst
* (and
* (== m null)
* (== item (car c))
* (= m c)))
* m)
*
*/
object item = args.First();
Cons list = (Cons)args.Second();
foreach (Cons c in list)
{
if (c.Car().Equals(item))
{
return(c);
}
}
return(null);
}
public static Object Cond(Cons args, Environment environment)
{
Cons clauses = args;
while (clauses.Length() > 0)
{
if (clauses.Length() == 1)
{
// This is a default (else) clause, so just execute it
return(Runtime.Eval(clauses.First(), environment));
}
if (clauses.Length() >= 2)
{
if (Conversions.ObjectToBoolean(Runtime.Eval(clauses.First(), environment)))
{
return(Runtime.Eval(clauses.Second(), environment));
}
else
{
clauses = (Cons)clauses.Cddr();
}
}
}
return(null);
}
public static object BackQuoteExpand(Object form, Environment environment)
{
if (!(form is Cons))
{
return(form);
}
Cons expression = (Cons)form;
Cons result = null;
foreach (object item in expression)
{
if (item is Cons)
{
Cons list = (Cons)item;
Symbol sym = list.First() as Symbol;
if (sym == Symbol.BACKQUOTE)
{
result = new Cons(BackQuoteExpand(list.Second(), environment), result);
}
else if (sym == Symbol.UNQUOTE)
{
result = new Cons(Runtime.Eval(BackQuoteExpand(list.Second(), environment), environment), result);
}
else if (sym == Symbol.SPLICE)
{
Cons l = (Cons)Runtime.Eval(BackQuoteExpand(list.Second(), environment), environment);
foreach (object o in l)
{
result = new Cons(o, result);
}
}
else
{
result = new Cons(BackQuoteExpand(item, environment), result);
}
}
else
{
result = new Cons(item, result);
}
}
return(result.Reverse());
}
public static Object Is(Cons args, Environment environment)
{
object obj = args.Second();
string typeName = args.First().ToString();
Type type = TypeCache.FindType(typeName);
object result = (((Type)type).IsInstanceOfType(obj));
return(result);
}
public static Object Map(Cons args, Environment environment)
{
Cons temp = null;
foreach (object o in (IEnumerable)args.Second())
{
temp = new Cons(
Runtime.Apply(args.First(), new Cons(o), environment),
temp);
}
return(temp.Reverse());
}
public static Object Setq(Cons args, Environment environment)
{
object v = null;
while (args != null)
{
Symbol s = (Symbol)args.First();
v = Runtime.Eval(args.Second(), environment);
environment.Assign(s, v);
args = (Cons)args.Cddr();
}
return(v);
}
/// <summary>
/// Converts a list to a SortedList
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static SortedList ConsToSortedList(Object o)
{
SortedList sortedList = new SortedList();
Object temp = o;
while (temp != null)
{
Cons element = (Cons)((Cons)temp).First();
sortedList.Add(element.First(), element.Second());
temp = ((Cons)temp).Rest();
}
return(sortedList);
}
public static Object Read(Cons args, Environment environment)
{
ReadTable readTable = (ReadTable)environment.GetValue(Symbol.FromName("*readtable*"));
TextReader textReader = args.First() as TextReader;
object eofValue = Reader.EOFVALUE;
if (args.Length() > 1)
{
eofValue = args.Second();
}
return(Reader.Read(textReader, readTable, eofValue));
}
public static Object Let(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
localEnvironment.AssignLocal((Symbol)args.First(), Runtime.Eval(args.Second(), environment));
object result = null;
foreach (object item in (Cons)args.Cddr())
{
result = Runtime.Eval(item, localEnvironment);
}
//return Runtime.Eval(args.Third(),localEnvironment);
return(result);
}
/// <summary>
/// Converts a list to a Hashtable
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static Hashtable ConsToHashtable(Object o)
{
Hashtable hashtable = new Hashtable();
Object temp = o;
while (temp != null)
{
Cons element = (Cons)((Cons)temp).First();
hashtable[element.First()] = element.Second();
temp = ((Cons)temp).Rest();
}
return(hashtable);
}
public static Object To(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
localEnvironment.AssignLocal((Symbol)args.First(), 0);
int endStop = int.Parse(Runtime.Eval(args.Second(), localEnvironment).ToString());
while ((int)localEnvironment.GetValue((Symbol)args.First()) < endStop)
{
foreach (object item in (Cons)args.Cddr())
{
Runtime.Eval(item, localEnvironment);
}
localEnvironment.AssignLocal((Symbol)args.First(), ((int)Runtime.Eval(args.First(), localEnvironment)) + 1);
}
return(null);
}
public static Object For(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
Runtime.Eval(args.First(), localEnvironment);
object test;
while ((Conversions.ObjectToBoolean(test = Runtime.Eval(args.Second(), localEnvironment))))
{
foreach (object item in (Cons)args.Cdddr())
{
Runtime.Eval(item, localEnvironment);
}
Runtime.Eval(args.Third(), localEnvironment);
}
return(test);
}
public static Object If(Cons args, Environment environment)
{
if (Conversions.ObjectToBoolean(Runtime.Eval(args.First(), environment)))
{
// Evaluate the then part
return(Runtime.Eval(args.Second(), environment));
}
else
if (args.Length() > 2)
{
// Evaluate the optional else part
return(Runtime.Eval(args.Third(), environment));
}
else
{
return(null);
}
}
public static Object ForEach(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
Symbol variable = (Symbol)args.First();
Object list = Runtime.Eval(args.Second(), localEnvironment);
foreach (object o in (System.Collections.IEnumerable)list)
{
localEnvironment.AssignLocal(variable, o);
//Runtime.Eval(args.Third(),localEnvironment);
foreach (object item in (Cons)args.Cddr())
{
Runtime.Eval(item, localEnvironment);
}
}
return(null);
}
public static Object With(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
Cons bindings = (Cons)args.First();
while ((bindings != null) && (bindings.Length() > 1))
{
localEnvironment.AssignLocal((Symbol)bindings.First(), Runtime.Eval(bindings.Second(), environment));
bindings = (Cons)bindings.Cddr();
}
object result = null;
foreach (object item in (Cons)args.Cdr())
{
result = Runtime.Eval(item, localEnvironment);
}
return(result);
}
public static Object Nth(Cons args, Environment environment)
{
int index = (int)args.First();
object o = args.Second();
if (o is IEnumerable)
{
IEnumerator e = ((IEnumerable)o).GetEnumerator();
for (int i = 0; i <= index; i++)
{
if (!e.MoveNext())
{
throw new IndexOutOfRangeException();
}
}
return(e.Current);
}
else
{
throw new LSharpException(string.Format("Nth: {0} is not IEnumerable", o));
}
}
/// <summary>
/// (is type expression)
/// Used to check whether the run-time type of an object is
/// compatible with a given type.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Is(Cons args, Environment environment)
{
object obj = args.Second();
TypeCache typeCache = TypeCache.Instance();
string typeName = args.First().ToString();
Type type = typeCache.FindType(typeName);
object result = (((Type)type).IsInstanceOfType (obj));
return result;
}
//converts args[0] to type of args[1]
public static object Coerce(Cons args, Environment e)
{
object o = args.First();
object t = args.Second();
Type type;
if (t is String)
type =(Type) TypeOf(new Cons(t), e);
else
type = (Type)t;
return Convert.ChangeType(o, type, System.Globalization.CultureInfo.InvariantCulture);
}
/// <summary>
/// (assoc item alist)
/// return the first cons in alist whose car is equal to item,
/// or nil if no such cons is found.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Assoc(Cons args, Environment environment)
{
object item = args.First();
Cons list = (Cons) args.Second();
foreach (Cons c in list)
{
if (c.Car().Equals (item))
return c;
}
return null;
}
/// <summary>
/// (compile expression filename)
/// This compiles to "expression" to "filename"
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Compile(Cons args, Environment environment)
{
return Compiler.Compile(args.First().ToString(), args.Second().ToString(), Compiler.OutputType.Exe);
}
/// <summary>
/// (to variable limit expression)
/// Starting at 0, assigns variable to succesive integers upto and
/// including limit. Executes expression on each iteration.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object To(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
localEnvironment.AssignLocal((Symbol) args.First(), 0);
int endStop = int.Parse(Runtime.Eval(args.Second(),localEnvironment).ToString());
while ((int)localEnvironment.GetValue((Symbol) args.First()) < endStop)
{
foreach (object item in (Cons)args.Cddr())
{
Runtime.Eval(item, localEnvironment);
}
localEnvironment.AssignLocal((Symbol) args.First(), ((int)Runtime.Eval(args.First(), localEnvironment)) + 1);
}
return null;
}
/// <summary>
/// (spawn expression) is like eval except that the expression
/// is evaluated on a new thread. Returns immediately with
/// the new thread object, but execution of expressions
/// continues synchronously. Experimental.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Spawn(Cons args, Environment environment)
{
if (args.Length() == 1)
return ThreadAdapter.Fork(args.First(), environment, System.Threading.ApartmentState.MTA);
else if (args.Length() == 2)
return ThreadAdapter.Fork(args.First(), environment,
(System.Threading.ApartmentState) Runtime.Eval(args.Second(), environment));
else
throw new LSharpException("Incorrect arguments given to spawn");
}
/// <summary>
/// (let symbol value expression*)
/// Binds a new local variable symbol to value in a new local lexical environment,
/// before evaluating expressions. Similar to with, but often more convenient for
/// decalring a single local variable.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Let(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
localEnvironment.AssignLocal((Symbol) args.First(), Runtime.Eval(args.Second(),environment));
object result = null;
foreach (object item in (Cons)args.Cddr())
{
result = Runtime.Eval(item, localEnvironment);
}
//return Runtime.Eval(args.Third(),localEnvironment);
return result;
}
/// <summary>
/// (apply function list)
/// Applies function to a list of arguments. function may be a built-in lsharp function,
/// a closure defined by fn a macro defined by macro or the name of a method in the
/// .NET framework.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Apply(Cons args, Environment environment)
{
return Runtime.Apply(args.First(), args.Second(),environment);
}
/// <summary>
/// (let symbol value expression*)
/// </summary>
public static Object Let(Cons args, LSharp.Environment environment)
{
string v = //"//(let " + Printer.ConsToString(args) + ")" + NewLine +
"{" + NewLine;
LSharp.Environment localEnvironment = new LSharp.Environment(environment);
v += GenerateAssignLocal((Symbol) args.First(), Generate(args.Second(),environment), localEnvironment);
foreach (object item in (Cons)args.Cddr())
{
v += Generate(item, localEnvironment);
}
return v + "}" + NewLine;
}
/// <summary>
/// (= { symbol value}*)
/// </summary>
public static Object Setq(Cons args, LSharp.Environment environment)
{
string v = "";//"//(setq " + Printer.ConsToString(args) + ")" + NewLine;
while (args != null)
{
Symbol s = (Symbol)args.First();
Cons sec = args.Second() as Cons;
if (sec != null)
{
Symbol ss = sec.First() as Symbol;
if (ss == Symbol.FromName("fn"))
{
Closure c = Runtime.Eval(sec, environment) as Closure;
environment.Assign(s, c);
extracode += Closure( new Cons(s), environment);
args = (Cons)args.Cddr();
continue;
}
if (ss == Symbol.FromName("macro"))
{
Macro m = Runtime.Eval(sec, environment) as Macro;
environment.Assign(s, m);
args = (Cons)args.Cddr();
continue;
}
}
v += GenerateAssign(s,Generate(args.Second(),environment), environment);
args = (Cons)args.Cddr();
}
return v;
}
public static Object The(Cons args, Environment environment)
{
Type o = TypeCache.FindType(args.First().ToString());
return(Conversions.The(o, Runtime.Eval(args.Second(), environment)));
}
/// <summary>
/// (the type value)
/// </summary>
public static Object The(Cons args, LSharp.Environment environment)
{
string v = "";// "//(the " + Printer.ConsToString(args) + ")" + NewLine;
Type o = TypeCache.FindType(args.First().ToString());
v += Generate(args.Second(),environment);
return v + string.Format("retval = LSharp.Conversions.The(typeof({0}), retval);", o) + NewLine;
}
/// <summary>
/// (to variable limit expression)
/// </summary>
public static Object To(Cons args, LSharp.Environment environment)
{
string v = //"//(to " + Printer.ConsToString(args) + ")" + NewLine +
"{" + NewLine;
LSharp.Environment localEnvironment = new LSharp.Environment(environment);
v += GenerateAssignLocal(args.First() as Symbol, 0, localEnvironment);
v += Generate(args.Second(),environment);
string lbl = MakeUnique("endstop");
v += string.Format(@"
int {1} = (int)retval;
while ({0} < {1})
{{
", localEnvironment.GetValue(args.First() as Symbol), lbl);
foreach (object item in (Cons)args.Cddr())
{
v += Generate(item, localEnvironment);
}
v += localEnvironment.GetValue(args.First() as Symbol) + "++;";
v += "}" + NewLine;
v += string.Format(@"
retval = null;
");
return v + "}" + NewLine;
}
/// <summary>
/// (call method object argument*)
/// </summary>
public static Object Call(Cons args, LSharp.Environment environment)
{
string v = //"//(call " + Printer.ConsToString(args) + ")" + NewLine +
"{" + NewLine;
ArrayList argtypes = new ArrayList();
ArrayList argz = new ArrayList();
if (args.Length() > 2)
{
foreach (object arg in (args.Cddr() as Cons))
{
if (Primitives.IsAtom(arg))
{
argz.Add(Printer.WriteToString(arg));
}
else
{
string argn = MakeUnique("arg");
string sv = Generate(arg, environment);
sv += string.Format(@"{0} {1} = ({0}) retval;
", typeof(object) , argn);
argz.Add(argn);
v += sv;
}
argtypes.Add(typeof(object));
}
}
string typemethname = args.Car().ToString();
string methname = typemethname;
string typename = string.Empty;
Type type = typeof(object);
int i = methname.LastIndexOf(".");
if (i >= 0)
{
methname = methname.Substring(i + 1);
typename = typemethname.Substring(0, i);
type = TypeCache.FindType(typename);
}
MethodInfo mi = null;
mi = type.GetMethod(methname, BindingFlags.IgnoreCase
| BindingFlags.Public | BindingFlags.Instance, binder, argtypes.ToArray(typeof(Type)) as Type[], null);
string objn = string.Empty;
if (mi == null)
{
type = TypeCache.FindType(args.Second().ToString());
mi = type.GetMethod(methname, BindingFlags.IgnoreCase
| BindingFlags.Public | BindingFlags.Static, binder, argtypes.ToArray(typeof(Type)) as Type[], null);
if (mi == null)
{
// use reflection
v += Generate(args.Second(), environment);
v += string.Format(@"retval = retval.GetType().InvokeMember(""{0}"",
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance, null, retval,
new object[]{{", methname) +
string.Join(", ", argz.ToArray(typeof(string)) as string[]) + @"});
}
";
return v;
}
else
{
objn = type.ToString();
}
}
else
{
objn = MakeUnique("obj");
v += Generate(args.Second(), environment);
v += string.Format(@"{0} {1} = ({0}) retval;
", type, objn);
}
v += "retval = " + (mi.ReturnType == typeof(void) ? @"null;
" : "") + objn + "." + mi.Name + "(" +
string.Join(", ", argz.ToArray(typeof(string)) as string[]);
return v + @");
}
";
}
/// <summary>
/// (if test then [else])
/// The if special form corresponds to the if-then-else construct found in
/// most algebraic programming languages. First the form test is evauated,
/// if true then the form then is evaluated.Otherwise, optionally the form
/// else is evaluated.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object If(Cons args, Environment environment)
{
if (Conversions.ObjectToBoolean(Runtime.Eval(args.First(),environment)))
// Evaluate the then part
return Runtime.Eval(args.Second(),environment);
else
if (args.Length() > 2)
// Evaluate the optional else part
return Runtime.Eval(args.Third(),environment);
else
return null;
}
/// <summary>
/// (if test then [else])
/// </summary>
public static Object If(Cons args, LSharp.Environment environment)
{
string v = //"//(if " + Printer.ConsToString(args) + ")" + NewLine +
Generate(args.First(),environment) +
string.Format(@"
if (LSharp.Conversions.ObjectToBoolean(retval))
{{ // Evaluate the then part
{0}
}}
", Generate(args.Second(),environment));
if (args.Length() > 2)
{
// Evaluate the optional else part
v += string.Format(@"
else
{{
{0}
}}
", Generate(args.Third(),environment));
}
return v;
}
/// <summary>
/// (= { symbol value}*)
/// Setq (Set Quote) is the variable assignment operator.
/// Sets each variable symbol to value in the current environment.
/// The abbreviation = is more commonly used in L Sharp.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Setq(Cons args, Environment environment)
{
object v = null;
while (args != null)
{
Symbol s = (Symbol)args.First();
v = Runtime.Eval(args.Second(),environment);
environment.Assign(s,v);
args = (Cons)args.Cddr();
}
return v;
}
/// <summary>
/// (each symbol IEnumerable expression)
/// </summary>
public static Object ForEach(Cons args, LSharp.Environment environment)
{
//string v = "//(each " + Printer.ConsToString(args) + ")" + NewLine;
string v = "";
LSharp.Environment localEnvironment = new LSharp.Environment(environment);
Symbol variable = (Symbol) args.First();
string vn = localEnvironment.AssignLocal(variable, MakeUnique(variable.Name)) as string;
v += Generate(args.Second(),environment) +
string.Format(@"
foreach (object {0} in (System.Collections.IEnumerable)retval)
{{", vn);
foreach (object item in (Cons)args.Cddr())
{
v += Generate(item, localEnvironment);
}
v += "}" + NewLine;
return v;
}
/// <summary>
/// (the type value)
/// Returns value converted or cast to an object of the specified type.
/// Throws an exception is the cast is not achievable.
/// The allows type casting and type conversion. This is much more than
/// a wrapper for the System.Convert class, it has special meaning for
/// conversions to and from Lists and certain common .NET data structures.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object The(Cons args, Environment environment)
{
Type o = TypeCache.FindType(args.First().ToString());
return Conversions.The (o, Runtime.Eval(args.Second(),environment));
}
/// <summary>
/// (for initialiser test iterator statement)
/// </summary>
public static Object For(Cons args, LSharp.Environment environment)
{
//string v = "//(for " + Printer.ConsToString(args) + ")" + NewLine + "{" + NewLine;
string v = "{" + NewLine;
LSharp.Environment localEnvironment = new LSharp.Environment(environment);
v += Generate(args.First(),localEnvironment);
v += Generate(args.Second(),localEnvironment);
v += @"while ((Conversions.ObjectToBoolean(retval))
{
";
foreach (object item in (Cons)args.Cdddr())
{
v += Generate(item, localEnvironment);
}
v += Generate(args.Third(),localEnvironment);
v += Generate(args.Second(),localEnvironment);
v += @"}
";
return v + "}" + NewLine;
}
/// <summary>
/// (try expression catch [finally])
/// The try special form corresponds to the try-catch-finally construct found
/// in C#. If catch is null then there is deemed to be no catch block
/// at all. If an exception occurs, the variable "it" is bound to the Exception
/// object in the local environment.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Try(Cons args, Environment environment)
{
try
{
return Runtime.Eval(args.First(),environment);
}
catch (Exception e)
{
environment.AssignLocal(Symbol.IT,e);
// If a catch form is specified then evaluate it
if (args.Second() == Symbol.NULL)
throw;
return Runtime.Eval(args.Second(),environment);
}
finally
{
// If a finally form was specified then evaluate it
if (args.Length() > 2)
Runtime.Eval(args.Third(),environment);
}
}
/// <summary>
/// Creates a dynamic class
/// (defclass "classname" "inheritsfrom" [defmethod])
/// e.g. (defclass "class1" "Object" DefinedMethods*)
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object DefClass(Cons args, Environment environment)
{
string className = args.First().ToString();
string superClass = args.Second().ToString();
DefinedMethod[] methods = new DefinedMethod[args.Length() - 2];
for (int i = 2; i < args.Length(); i++)
{
try {
Symbol toFind = (Symbol) args.Nth(i);
object foundMethod = environment.GetValue(toFind);
methods[i - 2] = (DefinedMethod) foundMethod;
} catch (Exception e ) {
Console.WriteLine("DEFCLASS ERROR: " + e.Message + " " + e.StackTrace);
}
}
return ClassBuilder.CreateClass(className, superClass, "", methods);
}
/// <summary>
/// (nth n list) Returns the (n+1)th element of list.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Nth(Cons args, Environment environment)
{
int index = (int)args.First();
object o = args.Second();
if (o is IEnumerable)
{
IEnumerator e = ((IEnumerable) o).GetEnumerator();
for (int i = 0; i <= index; i ++ )
{
e.MoveNext();
}
return e.Current;
}
throw new LSharpException(string.Format("Nth: {0} is not IEnumerable",o));
}
/// <summary>
/// (defmethod name "arg1 arg2" "(expression1)" "(expression 2)" [...])
/// Created methods used for DefClass <br />
/// </summary>
/// <param name="args"></param>
/// <param name="e"></param>
/// <returns></returns>
public static object DefMethod(Cons args, Environment e)
{
string name;
string[] _args;
string commands = "";
name = args.First().ToString();
_args = args.Second().ToString().Split(new string[] {" "}, StringSplitOptions.None);;
for (int i = 2; i < args.Length(); i++)
commands += args.Nth(i) + " ";
commands = commands.Replace("\\", "\\\\");
commands = commands.Replace("\"", "\\\"");
//FIXME:
//code = code.Replace("\n", "\\n");
DefinedMethod ret = new DefinedMethod(commands, name, _args);
e.AssignLocal(Symbol.FromName(name), ret);
Console.WriteLine("Assigned '" + ret.Name + "' as a DefinedMethod");
return ret;
}
/// <summary>
/// (read TextReader [eof])
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Read(Cons args, Environment environment)
{
ReadTable readTable = (ReadTable)environment.GetValue(Symbol.FromName("*readtable*"));
TextReader textReader = (TextReader)args.First();
object eofValue = null;
if (args.Length() > 1)
eofValue = args.Second();
return Reader.Read(textReader, readTable, eofValue);
}
/// <summary>
/// (for initialiser test iterator statement)
/// The for special form corresponds to the for construct found in most algebraic
/// programming languages. The initialiser is executed. The statement is executed
/// while test is true. The iterator is executed at the end of each statement execution.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object For(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
Runtime.Eval(args.First(),localEnvironment);
object test;
while ((Conversions.ObjectToBoolean(test = Runtime.Eval(args.Second(),localEnvironment))))
{
foreach (object item in (Cons)args.Cdddr())
{
Runtime.Eval(item, localEnvironment);
}
Runtime.Eval(args.Third(),localEnvironment);
}
return test;
}
/// <summary>
/// (handle-event target eventName handler)
/// Sets up a new event handler for events named eventName on target. The
/// handler is an LSharp closure with two arguments, the sender and the
/// event arguments (defun fn (sender args) (prl "Event Handled")).
/// Experimental.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object HandleEvent(Cons args, Environment environment)
{
return EventAdapter.AddEventHandler(args.First(), (string)args.Second(), (Closure)args.Third());
}
/// <summary>
/// (each symbol IEnumerable expression)
/// Iterates over any object which impelements IEnumerablewith succesive
/// elements being assigned to a variable named symbol; exceutes expression
/// on each iteration. Cons (LSharp lists), as well as many .NET collections
/// are IEnumerable. Foreach is a synonym for each.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object ForEach(Cons args, Environment environment)
{
Environment localEnvironment = new Environment(environment);
Symbol variable = (Symbol) args.First();
Object list = Runtime.Eval(args.Second(),localEnvironment);
foreach (object o in (System.Collections.IEnumerable)list)
{
localEnvironment.AssignLocal(variable, o);
//Runtime.Eval(args.Third(),localEnvironment);
foreach (object item in (Cons)args.Cddr())
{
Runtime.Eval(item, localEnvironment);
}
}
return null;
}
/// <summary>
/// (map function list) Maps function to each element in list return a new
/// list of return values.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Map(Cons args, Environment environment)
{
if (args.Second() == null)
return null;
Cons temp = null;
foreach (object o in (IEnumerable)args.Second())
{
temp = new Cons(
Runtime.Apply( args.First(),new Cons(o),environment),
temp);
}
return temp.Reverse();
}
public static Object Apply(Cons args, Environment environment)
{
return(Runtime.Apply(args.First(), args.Second(), environment));
}
/// <summary>
/// (member item list)
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Member(Cons args, Environment environment)
{
object value = args.First();
object list = args.Second();
// TODO potential speed ups if list is IList or IDictionary
foreach (object o in (IEnumerable)list)
{
if (Primitives.Eql(o,value))
return o;
}
return null;
}
/// <summary>
/// (when test expression*)
/// </summary>
public static Object When(Cons args, LSharp.Environment environment)
{
string v = //"//(when " + Printer.ConsToString(args) + ")" + NewLine +
Generate(args.First(),environment) +
string.Format(@"
if (LSharp.Conversions.ObjectToBoolean(retval))
{{ // Evaluate the then part
{0}
}}
", Generate(args.Second(),environment));
return v;
}
