/// <summary> /// (gui-inspect OBJECT) /// shows a Form with data on the item OBJECT /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static object GuiInspect(Cons args, Environment environment) { // TODO : Fix //string sname = (string) Functions.SymbolName(new Cons(args.First()), environment); InspectorForm i = new InspectorForm(args.Car(), environment); i.ShowDialog(); return args.First(); }
/// <summary> /// Returns true if all arguments are true, false otherwise. /// Performs short circuit evaluation on its arguments. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object And(Cons args, Environment environment) { foreach (Object item in args) { if (Conversions.ObjectToBoolean(Runtime.Eval(item,environment)) == false) return false; } return true; }
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; }
/// <summary> /// (add object*) /// Returns the sum of all the specified objects. /// Each object must be a numerical type such as System.In32 or System.Double. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Add(Cons args, Environment environment) { Type type = args.First().GetType(); Double result = 0; foreach (Object item in args) { if (item is Double) type = item.GetType(); result += Convert.ToDouble(item); } 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); }
public Object Expand(Cons arguments) { // Create a new lexical environment Environment localEnvironment = new Environment(environment); Primitives.ProcessArguments(argumentNames, arguments, localEnvironment); object result = null; foreach (object o in body) { result = Runtime.Eval(o,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 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 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)); }
/// <summary> /// Creates a list given a DataTable /// </summary> /// <param name="dataTable"></param> /// <returns></returns> public static Cons FromDataTable(DataTable dataTable) { object list = null; foreach (DataRow row in dataTable.Rows) { object subList = null; foreach (DataColumn column in dataTable.Columns) { subList = new Cons(row[column], subList); } list = new Cons(((Cons)subList).Reverse(), list); } return((Cons)list); }
/// <summary> /// Maps eval to a list of expressions /// </summary> /// <param name="list"></param> /// <param name="environment"></param> /// <returns></returns> public static Cons EvalList(object list, Environment environment) { if (list == null) return null; object result = null; foreach (object item in (Cons)list ) { result = new Cons(Eval(item,environment) ,result); } return ((Cons)result).Reverse(); }
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); }
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 Add(Cons args, Environment environment) { object car = args.First(); Type type = car == null ? typeof(double) : car.GetType(); Double result = 0; foreach (Object item in args) { if (item is Double) { type = typeof(double); } result += Convert.ToDouble(item); } return(Convert.ChangeType(result, type)); }
public static Object Multiply(Cons args, Environment environment) { Type type = args.First().GetType(); Double result = 1; foreach (Object item in args) { if (item is Double) { type = item.GetType(); } result *= Convert.ToDouble(item); } return(Convert.ChangeType(result, type)); }
public override bool Equals(object obj) { if (obj is Cons) { Cons that = (Cons)obj; bool carsEqual = Primitives.Eql(this.Car(), that.Car()); bool cdrsEqual = Primitives.Eql(this.Cdr(), that.Cdr()); return(carsEqual && cdrsEqual); } else { return(false); } }
/// <summary> /// Maps eval to a list of expressions /// </summary> /// <param name="list"></param> /// <param name="environment"></param> /// <returns></returns> public static Cons EvalList(object list, Environment environment) { if (list == null) { return(null); } object result = null; foreach (object item in (Cons)list) { result = new Cons(Eval(item, environment), result); } return(((Cons)result).Reverse()); }
public bool MoveNext() { object o = list.Cdr(); if (o==null) return false; if (o is Cons) { list = (Cons)o; } else { list = new Cons(o); } return true; }
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 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 Reference(Cons args, Environment environment) { object result = null; foreach (object module in args) { if (module is string) { result = AssemblyCache.LoadAssembly((string)module); } else { throw new LSharpException(String.Format("Reference: {0} is not a string", module)); } } return(result); }
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 Car(Cons args, Environment environment) { object o = args.First(); if (o is Cons) { return(((Cons)o).First()); } if (o is IEnumerable) { IEnumerator e = ((IEnumerable)o).GetEnumerator(); e.MoveNext(); return(e.Current); } throw new LSharpException(string.Format("Car: {0} is not IEnumerable", o)); }
public Object Expand(Cons arguments) { // Create a new lexical environment Environment localEnvironment = new Environment(environment); Primitives.ProcessArguments(argumentNames, arguments, localEnvironment); object result = null; if (body != null) { foreach (object o in body) { result = Runtime.Eval(o, localEnvironment); } } return(result); }
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 Using(Cons args, Environment environment) { string result = null; foreach (object name in args) { if (name is String) { TypeCache.Using((string)name); result = (string)name; } else { throw new LSharpException(String.Format("Using: {0} is not a string", name)); } } return(result); }
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> /// Invokes the closure with arguments bound to the values specified in the /// argument list /// </summary> /// <param name="arguments"></param> /// <returns></returns> public Object Invoke(Cons arguments) { // Create a new lexical environment Environment localEnvironment = new Environment(environment); Primitives.ProcessArguments(argumentNames, arguments, localEnvironment); // Evaluate the body within this lexixal environment object result = null; if (body != null) { foreach (object o in body) { result = Runtime.Eval(o, localEnvironment); } } return(result); }
/// <summary> /// Invokes the closure with arguments bound to the values specified in the /// argument list /// </summary> /// <param name="arguments"></param> /// <returns></returns> public Object Invoke(Cons arguments) { // Create a new lexical environment Environment localEnvironment = new Environment(environment); Primitives.ProcessArguments(argumentNames, arguments, localEnvironment); // Evaluate the body within this lexical environment object result = null; if (body != null) { foreach (object o in body) { result = Runtime.Eval(o, localEnvironment); } } return result; }
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 bool MoveNext() { object o = list.Cdr(); if (o == null) { return(false); } if (o is Cons) { list = (Cons)o; } else { list = new Cons(o); } return(true); }
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)); } }
// 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 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 Load(Cons args, Environment environment) { object filename = args.First(); if (filename is string) { TextReader textReader = new StreamReader((string)filename); string buffer = textReader.ReadToEnd(); textReader.Close(); // We want to evaluate the whole file, so there is an implicit do // which we now make explicit string expression = string.Format("(do {0})", buffer); object input = Reader.Read(new StringReader(expression), ReadTable.DefaultReadTable()); object output = Runtime.Eval(input, environment); return(output); } throw new LSharpException(String.Format("Using: {0} is not a string", filename)); }
public static Object Nconc(Cons args, Environment environment) { // With no argument, returns null if (args == null) { return(null); } // With one argument, returns that argument if (args.Length() < 2) { return(args.First()); } for (int i = 0; i < args.Length() - 1; i++) { Cons cons = (Cons)args.Nth(i); cons = (Cons)cons.Last(); cons.Rplacd(args.Nth(i + 1)); } return(args.First()); }
public static Object Pr(Cons args, Environment environment) { if (args == null) { return(null); } else { object last = null; foreach (object o in args) { last = o; if (o is System.String) { Console.Write(o); } else { Console.Write(Printer.WriteToString(o)); } } return(last); } }
/// <summary> /// (load filename) Loads and evaluates all statements in the given /// filename which must be a text file. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Load(Cons args, Environment environment) { object filename = args.First(); if (filename is string) { TextReader textReader; // 9/29/11: Enabled "short" filenames (adds .ls if needed) if (System.IO.File.Exists((string)filename)) textReader = new StreamReader((string)filename); else if (File.Exists(filename + ".ls")) // short file specified? textReader = new StreamReader((string)filename + ".ls"); else throw new LSharpException("Cannot find file " + filename); string buffer = textReader.ReadToEnd(); textReader.Close(); // We want to evaluate the whole file, so there is an implicit do // which we now make explicit string expression = string.Format("(do {0}\n)",buffer); object input = Reader.Read(new StringReader(expression),ReadTable.DefaultReadTable()); object output = Runtime.Eval(input, environment); return output; } throw new LSharpException(String.Format("Load: {0} is not a string", filename)); }
/// <summary> /// (list object*) /// Creates a new cons, an ordered list with each object as a member. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object List(Cons args, Environment environment) { return args; }
/// <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> /// (length expression) /// Returns the length of expression. If expression is null, length returns 0, /// otherwise the length is calculated by calling the length method on the object, /// ensuring that length works for strings, lists and most collection-like objects. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Length(Cons args, Environment environment) { object o = args.Car(); if (o == null) return 0; else return Runtime.Call("length", args); }
/// <summary> /// (nconc list*) /// Returns a list whose elements are the elements of each list in /// order. Destructively modifies all but the last list, such that /// the cdr of the last cons in each list is the next list. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Nconc(Cons args, Environment environment) { // With no argument, returns null if (args == null) return null; // With one argument, returns that argument if (args.Length() < 2) return args.First(); for (int i = 0; i < args.Length() -1; i ++) { Cons cons = (Cons)args.Nth(i); cons = (Cons)cons.Last(); cons.Rplacd(args.Nth(i+1)); } return args.First(); }
/// <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> /// (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(); }
/// <summary> /// Generates a new symbol /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Gensym(Cons args, Environment environment) { return new Symbol("#:G" + Guid.NewGuid()); }
/// <summary> /// Evaluates an LSharp expression contained in a string within a given /// environment /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object EvalString(Cons args, Environment environment) { return Runtime.EvalString (args.First().ToString(), environment); }
/// <summary> /// (exit [exit-code]) /// Terminates the current process and returns the specified exit-code to the /// calling process. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Exit(Cons args, Environment environment) { if (args == null) System.Environment.Exit(0); else System.Environment.Exit((int)args.First()); return null; }
/// <summary> /// Evaluates an LSharp expression in a given environment /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Eval(Cons args, Environment environment) { if (args.Length() == 1) return Runtime.Eval(args.First(), environment); else throw new LSharpException("Incorrect arguments given to eval"); }
/// <summary> /// (eql expression*) Returns true if all expressions are equal, that is /// their implementations of equal return true. As a special case, null /// is eql to null. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Eql(Cons args, Environment environment) { return Primitives.Eql(args); }
public Macro(Cons argumentNames, Cons body, Environment environment) { this.body = body; this.argumentNames = argumentNames; this.environment = environment; }
/// <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> /// (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()); }
public static Object MacroExpand(Cons args, Environment environment) { Macro macro = (Macro)args.First(); Cons arguments = (Cons)args.Rest(); return macro.Expand(arguments); }
/// <summary> /// (inspect object) Returns a description of the specified object, using reflection. /// Useful for debugging. /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Inspect(Cons args, Environment environment) { object o = args.First(); string s = Inspector.Inspect(o); Console.WriteLine(s); return null; }
/// <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> /// (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; }
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 string WriteToString(Object x) { if (x == null) { return("null"); } if (x == Reader.EOFVALUE) { return("EOF"); } Type type = x.GetType(); if (x is string) { return(string.Format("\"{0}\"", (string)x)); } if (x is bool) { return(x.ToString().ToLower()); } if (x is char) { return(string.Format("#\\{0}", x)); } if (x is Symbol) { return(string.Format("{0}", x)); } if (x is Cons) { bool wasquote = true; Cons cons = (Cons)x; StringBuilder stringBuilder = new StringBuilder(); Symbol car = cons.Car() as Symbol; if (car == Symbol.QUOTE) { stringBuilder.Append("'"); } else if (car == Symbol.BACKQUOTE) { stringBuilder.Append("`"); } else if (car == Symbol.SPLICE) { stringBuilder.Append(",@"); } else if (car == Symbol.UNQUOTE) { stringBuilder.Append(","); } else { wasquote = false; stringBuilder.Append("("); stringBuilder.Append(WriteToString(cons.Car())); stringBuilder.Append(" "); } Object o; o = cons.Cdr(); while (o != null) { if (o is Cons) { cons = (Cons)o; stringBuilder.Append(WriteToString(cons.Car())); o = cons.Cdr(); if (o != null) { stringBuilder.Append(" "); } } else { stringBuilder.Append(". "); stringBuilder.Append(WriteToString(o)); o = null; } } string op = stringBuilder.ToString().Trim(); if (wasquote) { return(op); } else { return(op + ")"); } } return(x.ToString().Trim()); }
/// <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()); }
/// <summary> /// Returns an object representing the curent lexical environment /// </summary> /// <param name="args"></param> /// <param name="environment"></param> /// <returns></returns> public static Object Environment(Cons args, Environment environment) { return environment; }