public static Object Append(Cons args, Environment environment)
{
if (args.Rest() == null)
{
return(args.First());
}
else
{
Cons result = ((Cons)args.First()).CopyList();
((Cons)result.Last()).Rplacd(Append((Cons)args.Rest(), environment));
return(result);
}
}
public static Object MacroExpand(Cons args, Environment environment)
{
Macro macro = (Macro)args.First();
Cons arguments = (Cons)args.Rest();
return(macro.Expand(arguments));
}
public static Object LogXor(Cons args, Environment environment)
{
Type type = args.First().GetType();
object result = args.First();
foreach (Object item in (Cons)args.Rest())
{
// The integral types dont define operator overload methods
// for performace reasons, so we have to implement this
// operator on each integral type
if (type == typeof(sbyte))
{
result = (sbyte)result ^ (sbyte)(item);
}
else if (type == typeof(byte))
{
result = (byte)result ^ (byte)(item);
}
else if (type == typeof(char))
{
result = (char)result ^ (char)(item);
}
else if (type == typeof(short))
{
result = (short)result ^ (short)(item);
}
else if (type == typeof(ushort))
{
result = (ushort)result ^ (ushort)(item);
}
else if (type == typeof(int))
{
result = (int)result ^ (int)(item);
}
else if (type == typeof(uint))
{
result = (uint)result ^ (uint)(item);
}
else if (type == typeof(long))
{
result = (long)result ^ (long)(item);
}
else if (type == typeof(ulong))
{
result = (ulong)result ^ (ulong)(item);
}
else
{
return(Runtime.Call("op_ExclusiveOr", args));
}
}
return(Convert.ChangeType(result, type));
}
public static bool Eq(Cons args)
{
object last = args.First();
foreach (object item in (Cons)args.Rest())
{
if (!(object.ReferenceEquals(last,item)))
return false;
last = item;
}
return true;
}
// TODO
public static Object Append(Cons args, Environment environment)
{
if (args.Rest() == null)
{
return args.First();
}
else
{
Cons result;
if (args.First() == null)
{
result = (Cons)Append((Cons)args.Rest(), environment);
}
else
{
result = ((Cons)args.First()).CopyList();
((Cons)result.Last()).Rplacd(Append((Cons)args.Rest(), environment));
}
return result;
}
}
public static Object While(Cons args, Environment environment)
{
object test;
while ((Conversions.ObjectToBoolean(test = Runtime.Eval(args.First(), environment))))
{
foreach (object item in (Cons)args.Rest())
{
Runtime.Eval(item, environment);
}
}
return(test);
}
public static Object Cons(Cons args, Environment environment)
{
int l = args.Length();
if (l == 0)
{
return(null);
}
if (l == 1)
{
return(args.First());
}
return(new Cons(args.First(), Cons((Cons)args.Rest(), environment)));
}
public static bool Eq(Cons args)
{
object last = args.First();
foreach (object item in (Cons)args.Rest())
{
if (!(object.ReferenceEquals(last, item)))
{
return(false);
}
last = item;
}
return(true);
}
public static Object LessThanEqual(Cons args, Environment environment)
{
Double last = Convert.ToDouble(args.First());
foreach (object item in (Cons)args.Rest())
{
Double current = Convert.ToDouble(item);
if (!(last <= current))
{
return(false);
}
last = current;
}
return(true);
}
public static Object Divide(Cons args, Environment environment)
{
Type type = args.First().GetType();
Double result = Convert.ToDouble(args.First());
foreach (object item in (Cons)args.Rest())
{
if (item is Double)
{
type = item.GetType();
}
result /= Convert.ToDouble(item);
}
return(Convert.ChangeType(result, type));
}
public static Object Trace(Cons args, Environment environment)
{
string filename = (String)Runtime.Eval(args.First(), environment);
try
{
Runtime.Profiler = new XmlTracer(filename);
object result = null;;
foreach (object item in (Cons)args.Rest())
{
result = Runtime.Eval(item, environment);
}
return(result);
}
finally
{
Runtime.Profiler.Close();
Runtime.Profiler = new DefaultProfiler();
}
}
public static Object MacroExpand(Cons args, Environment environment)
{
Macro macro = (Macro)args.First();
Cons arguments = (Cons)args.Rest();
return macro.Expand(arguments);
}
/// <summary>
/// (^ expression*)
/// Performs a bitwise logical exclusive or operation on its arguments
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object LogXor(Cons args, Environment environment)
{
Type type = args.First().GetType();
object result = args.First();
foreach (Object item in (Cons)args.Rest())
{
// The integral types dont define operator overload methods
// for performace reasons, so we have to implement this
// operator on each integral type
if (type == typeof(sbyte))
result = (sbyte)result ^ (sbyte)(item);
else if (type == typeof(byte))
result = (byte)result ^ (byte)(item);
else if (type == typeof(char))
result = (char)result ^ (char)(item);
else if (type == typeof(short))
result = (short)result ^ (short)(item);
else if (type == typeof(ushort))
result = (ushort)result ^ (ushort)(item);
else if (type == typeof(int))
result = (int)result ^ (int)(item);
else if (type == typeof(uint))
result = (uint)result ^ (uint)(item);
else if (type == typeof(long))
result = (long)result ^ (long)(item);
else if (type == typeof(ulong))
result = (ulong)result ^ (ulong)(item);
else
return Runtime.Call("op_ExclusiveOr",args);
}
return Convert.ChangeType(result,type);
}
/// <summary>
/// (<= object1 object2 object*) Less than or equal
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object LessThanEqual(Cons args, Environment environment)
{
Double last = Convert.ToDouble(args.First());
foreach (object item in (Cons)args.Rest())
{
Double current = Convert.ToDouble(item);
if (!(last <= current))
return false;
last = current;
}
return true;
}
/// <summary>
/// (while test expression*)
/// </summary>
public static Object While(Cons args, LSharp.Environment environment)
{
string v = "";//"//(while " + Printer.ConsToString(args) + ")" + NewLine;
v += Generate(args.First(),environment);
v += @"
while (LSharp.Conversions.ObjectToBoolean(retval))
{
";
foreach (object item in (Cons)args.Rest())
{
v += Generate(item, environment);
}
v += Generate(args.First(),environment);
v += "}" + NewLine;
return v;
}
/// <summary>
/// Creates a fresh cons, the car of which is object-1 and the cdr of which is object-2.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Cons(Cons args, Environment environment)
{
if (args.Length() == 1)
return args.First();
if (args.Length() == 2)
return new Cons(args.First(),Cons((Cons)args.Rest(), environment));
throw new LSharpException("Too many arguments given to cons");
}
/// <summary>
/// Calls a .NET method.
/// The first argument is the object to which the method is attached.
/// Passes the rest of the arguments to the appropriate constructor
/// </summary>
/// <param name="method"></param>
/// <param name="arguments"></param>
/// <returns></returns>
public static object Call(String method, Cons arguments)
{
BindingFlags bindingFlags = BindingFlags.IgnoreCase
| BindingFlags.Public
| BindingFlags.NonPublic;
// Is it a method on a static type or an object instance ?
Type type;
if (arguments.First().GetType() == typeof(LSharp.Symbol))
{
bindingFlags = bindingFlags | BindingFlags.Static | BindingFlags.FlattenHierarchy;
// Find the type object from its name
type = TypeCache.Instance().FindType(arguments.First().ToString());
}
else
{
bindingFlags = bindingFlags | BindingFlags.Instance;
type = arguments.First().GetType();
}
Type[] types = new Type[arguments.Length() -1];
object[] parameters = new object[arguments.Length() -1];
int loop = 0;
if (arguments.Rest() != null)
foreach (object argument in (Cons)arguments.Rest())
{
types[loop] = argument.GetType();
parameters[loop] = argument;
loop++;
}
// Start by looking for a method call
MethodInfo m = type.GetMethod(method.ToString(),
bindingFlags | BindingFlags.InvokeMethod
,null,types,null);
if (m != null)
return m.Invoke(arguments.First(),parameters);
// Now loook for a property get
PropertyInfo p = type.GetProperty(method.ToString(),bindingFlags | BindingFlags.GetProperty,
null,null, types,null);
if (p != null)
return p.GetGetMethod().Invoke(arguments.First(),parameters);
// Now look for a field get
FieldInfo f = type.GetField(method.ToString(),bindingFlags | BindingFlags.GetField);
if (f != null)
return f.GetValue(arguments.First());
// FIXME: or an event ?
EventInfo e = type.GetEvent(method.ToString(), bindingFlags); // | BindingFlags.Event)
if (e != null) // attempt to call the click event
return e.GetRaiseMethod().Invoke(arguments.First(), parameters);
throw new LSharpException(string.Format("Call: No such method, property, field, or event '{0}' on '{1}'", method.ToString(),type));
}
/// <summary>
/// (call method object argument*)
/// Calls a .NET method on a given object with given arguments.
/// This is useful if the method name clashes with a variable which is already
/// bound in the current L Sharp lexical environment.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Call(Cons args, Environment environment)
{
return Runtime.Call(args.Car().ToString(),
(Cons)Runtime.EvalList(args.Rest(),environment));
}
/// <summary>
/// (while test expression*)
/// The while special form corresponds to the while construct found
/// in most algebraic programming languages. First test is evauated,
/// if true then expression* is evaluated. The process continues until
/// the evaluation of test is false.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object While(Cons args, Environment environment)
{
object test;
while ((Conversions.ObjectToBoolean(test = Runtime.Eval(args.First(),environment))))
{
foreach (object item in (Cons)args.Rest())
{
Runtime.Eval(item, environment);
}
}
return test;
}
/// <summary>
/// (trace filename expression*)
/// Traces an evaluation of expression* (as if in an implicit do),
/// documenting all call and return steps; writes the output as an
/// XML file in filename.
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Trace(Cons args, Environment environment)
{
string filename = (String)Runtime.Eval(args.First(),environment);
try
{
Runtime.Profiler = new XmlTracer(filename);
object result = null;;
foreach (object item in (Cons)args.Rest())
{
result = Runtime.Eval(item, environment);
}
return result;
}
catch (Exception e)
{
throw;
}
finally
{
Runtime.Profiler.Close();
Runtime.Profiler = new DefaultProfiler();
}
}
/// <summary>
/// Calls a .NET method.
/// The first argument is the object to which the method is attached.
/// Passes the rest of the arguments to the appropriate constructor
/// </summary>
/// <param name="method"></param>
/// <param name="arguments"></param>
/// <returns></returns>
public static object Call(String method, Cons arguments)
{
BindingFlags bindingFlags = BindingFlags.IgnoreCase
| BindingFlags.Public
| BindingFlags.NonPublic;
string methname = method;
string typename = string.Empty;
Type type = null;
int i = methname.LastIndexOf(".");
if (i >= 0)
{
methname = methname.Substring(i + 1);
typename = method.Substring(0, i);
type = TypeCache.FindType(typename);
}
// Is it a method on a static type or an object instance ?
if (type == null)
{
if (arguments.First() is Symbol)
{
bindingFlags = bindingFlags | BindingFlags.Static | BindingFlags.FlattenHierarchy;
// Find the type object from its name
type = TypeCache.FindType(arguments.First().ToString());
}
else
{
bindingFlags = bindingFlags | BindingFlags.Instance;
type = arguments.First().GetType();
}
}
else
{
bindingFlags = bindingFlags | BindingFlags.Instance;
}
if (type == null)
{
throw new LSharpException(string.Format("Call: No such type '{0}'. Did you forget a 'using'?", arguments.First()));
}
Type[] types = new Type[arguments.Length() - 1];
object[] parameters = new object[arguments.Length() - 1];
int loop = 0;
if (arguments.Rest() != null)
{
foreach (object argument in (Cons)arguments.Rest())
{
types[loop] = argument.GetType();
parameters[loop] = argument;
loop++;
}
}
// Start by looking for a method call
MethodInfo m = type.GetMethod(methname,
bindingFlags | BindingFlags.InvokeMethod
, null, types, null);
if (m != null)
{
return(m.Invoke(arguments.First(), parameters));
}
// Now loook for a property get
PropertyInfo p = type.GetProperty(methname, bindingFlags | BindingFlags.GetProperty,
null, null, types, null);
if (p != null)
{
return(p.GetGetMethod().Invoke(arguments.First(), parameters));
}
// Now look for a field get
FieldInfo f = type.GetField(methname, bindingFlags | BindingFlags.GetField);
if (f != null)
{
return(f.GetValue(arguments.First()));
}
// or an event ?
throw new LSharpException(string.Format("Call: No such method, property or field '{1}.{0}({2})'",
method.ToString(), type, TypeString(types, parameters)));
}
public static string GenerateCons(Cons args, LSharp.Environment environment)
{
// ananlysi cons
if (args == null)
{
return @"//retval = null; // dont null mite need retval
";
}
else
{
Symbol sym = args.Car() as Symbol;
object e = Runtime.Eval(sym, environment);
if (e is Function)
{
Function f = e as Function;
string v = "{" + NewLine;
Cons rest = args.Rest() as Cons;
v += GenerateFuncCall(f.Method.DeclaringType.ToString(), f.Method.Name, rest, environment);
return v + "}" + NewLine;
}
else if (e is SpecialForm)
{
SpecialForm f = e as SpecialForm;
Cons rest = args.Rest() as Cons;
string r = Printer.ConsToString(rest);
string lFName = f.Method.Name.ToLower();
if (lFName == "while")
return While(rest, environment) as string;
if (lFName == "for")
return For(rest, environment) as string;
if (lFName == "and")
return And(rest, environment) as string;
if (lFName == "call")
return Call(rest, environment) as string;
if (lFName == "cond")
return Cond(rest, environment) as string;
if (lFName == "do")
return Do(rest, environment) as string;
if (lFName == "foreach")
return ForEach(rest, environment) as string;
if (lFName == "if")
return If(rest, environment) as string;
if (lFName == "let")
return Let(rest, environment) as string;
if (lFName == "or")
return Or(rest, environment) as string;
if (lFName == "quote")
return Quote(rest, environment) as string;
if (lFName == "setq")
return Setq(rest, environment) as string;
if (lFName == "the")
return The(rest, environment) as string;
if (lFName == "to")
return To(rest, environment) as string;
if (lFName == "try")
return Try(rest, environment) as string;
if (lFName == "when")
return When(rest, environment) as string;
if (lFName == "with")
return With(rest, environment) as string;
return Runtime.EvalString("(" + f.Method.Name + " " + r + ")", environment) as string;
}
else if (e is Macro)
{
Macro m = e as Macro;
Cons rest = args.Rest() as Cons;
Cons em = m.Expand(rest) as Cons;
return Generate(em, environment);
}
else if (e is Closure)
{
extracode += Closure(new Cons(sym), environment) as string;
string v = "{" + NewLine;
Cons rest = args.Rest() as Cons;
v += GenerateFuncCall(null, environment.GetValue(sym) as string, rest, environment);
return v + "}" + NewLine;
}
else if (currsymbols.ContainsKey(sym))
{
string v = "{" + NewLine;
Cons rest = args.Rest() as Cons;
v += GenerateFuncCall(null, environment.GetValue(sym) as string, rest, environment);
return v + "}" + NewLine;
}
else
{
// not good, lets not support this for now: .NET method call
try
{
// try: LSharp.Runtime.Appy(<args>);
Cons rest = args.Rest() as Cons;
string ret = GenerateList(rest, environment, "temporarytableforspecialfunctioncall");
ret += "\nLSharp.Runtime.Apply(retval, LSharp.Cons.FromList(temporarytableforspecialfunctioncall), environment);";
//return ret; //"// call not supported";// Call(args, environment).ToString();
return Call(args, environment) as string;
}
catch
{
string margs = GetArgs();
string v = GenerateList(args.Rest() as Cons, environment, margs);
return string.Format("retval = LSharp.Cons.FromList({0});{1}",
margs, NewLine);
}
}
}
}
public static Object Mod(Cons args, Environment environment)
{
Type type = args.First().GetType();
Double result = Convert.ToDouble(args.First());
foreach (object item in (Cons)args.Rest())
{
if (item is Double)
type = item.GetType();
result %= Convert.ToDouble(item);
}
return Convert.ChangeType(result, type);
}
public static Object New(Cons args, Environment environment)
{
Type type = TypeCache.FindType(args.First().ToString());
return(Runtime.MakeInstance(type, args.Rest()));
}
/// <summary>
/// (new class) Creates a new object, an instance of type class
/// </summary>
/// <param name="args"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object New(Cons args, Environment environment)
{
Type type = TypeCache.Instance().FindType(args.First().ToString());
return Runtime.MakeInstance(type,args.Rest());
}
public static Object Call(Cons args, Environment environment)
{
return(Runtime.Call(args.Car().ToString(),
(Cons)Runtime.EvalList(args.Rest(), environment)));
}
