public override LispObject Eval(Cons body, LispEnvironment env) { var varForms = body.Car.As<Cons>(); var varSymbols = varForms.Select(x => x.As<Cons>().Car.As<Symbol>()).ToList(); var varInitForms = varForms.Select(x => x.As<Cons>().Cdr.As<Cons>().Car).ToList(); var varStepForms = varForms.Select(x => x.As<Cons>().Cdr.As<Cons>().Cdr.As<Cons>().Car).ToList(); var cadr = body.Cdr.As<Cons>().Car.As<Cons>(); var testForm = cadr.Car; var resultForms = cadr.Cdr.As<Cons>(); var doBody = body.Cdr.As<Cons>().Cdr.As<Cons>(); var doEnv = new LispEnvironment(env); SetInitValues(doEnv, varSymbols, varInitForms); while (doEnv.Eval(testForm).IsNil) { new Progn().Eval(doBody, doEnv); SetStepValues(doEnv, varSymbols, varStepForms); } return new Progn().Eval(resultForms, doEnv); }
public CommandLineOptions() { ScriptName = null; UserArguments = null; Debug = true; Repl = true; }
public override LispObject Eval(Cons body, LispEnvironment env) { var lambdaList = body.Car.As<Cons>(); var progn = Progn.Wrap(body.Cdr.As<Cons>(), env); return new Lambda(lambdaList, progn, env); }
private IEnumerable<KeyValuePair<double, double>> ConvertToPair(Cons cons) { var pairs = (from Cons pair in cons select new KeyValuePair<double, double>((double) pair.car, (double) pair.cdr)); return pairs.ToList(); }
public override LispObject Eval(Cons body, LispEnvironment env) { var symbol = Car.Of(body).As<Symbol>(); var value = env.Eval(Car.Of(Cdr.Of(body))); env.SetValue(symbol, value); return value; }
public override LispObject Apply(Cons arguments, LispEnvironment env) { if (arguments.Car.IsAtom) { return T.True; } return LispNull.Nil; }
public void SingleConsTest() { var symbol = new Symbol("abc"); var cons = new Cons(symbol, LispNull.Nil); var enumerator = new ListEnumerator(cons); Assert.IsTrue(enumerator.MoveNext()); Assert.AreSame(symbol, enumerator.Current); Assert.IsFalse(enumerator.MoveNext()); }
public override LispObject Apply(Cons argumentValues, LispEnvironment env) { var fun = argumentValues.Car.As<Function>(); var args = argumentValues.Cdr.As<Cons>(); var spread = Spread(args); return fun.Apply(spread, env); }
public static Cons Spread(Cons args) { if (args.Cdr.IsNil) { return args.Car.As<Cons>(); } return new Cons(args.Car, Spread(args.Cdr.As<Cons>())); }
public Arity(Cons lambdaList) { int count = 0; while (lambdaList != null) { lambdaList = (Cons) lambdaList.Cdr; count += 1; } this.minimumArgumentCount = count; this.maximumArgumentCount = count; }
public override Node eval(Node t, Environment e) { if (t.getCdr().getCar().isSymbol()) e.define(t.getCdr().getCar(), t.getCdr().getCdr().getCar()); else { Cons functionBody = new Cons(t.getCdr().getCar().getCdr(), t.getCdr().getCdr()); e.define((Node)t.getCdr().GetCar().GetCar(), new Cons(new Ident("lambda"), functionBody).eval(e)); } return Void.getInstance(); }
public override LispObject Apply(Cons argumentsValues, LispEnvironment env) { LispNumber sum = new LispInteger(0); foreach (var addend in argumentsValues) { var num = addend.As<LispNumber>(); sum = sum.Add(num); } return sum; }
public override LispObject Eval(Cons defmacroBody, LispEnvironment env) { var symbol = defmacroBody.Car.As<Symbol>(); var lambdaList = Car.Of(Cdr.Of(defmacroBody)); var macroBody = Cdr.Of(Cdr.Of(defmacroBody)).As<Cons>(); var progn = Progn.Wrap(macroBody, env); var macro = new Macro(symbol.Name, lambdaList, progn, env); env.AddBinding(symbol, macro); return macro; }
public override LispObject Eval(Cons body, LispEnvironment env) { var testForm = Car.Of(body); var thenForm = Car.Of(Cdr.Of(body)); var elseForm = Car.Of(Cdr.Of(Cdr.Of(body))); if (env.Eval(testForm).IsTrue) { return env.Eval(thenForm); } return env.Eval(elseForm); }
public void MillionCons() { const int SIZE = 1000000; Cons cons = new Cons(0); int i; for (i= 1 ; i < SIZE; i++) { cons = new Cons(i,cons); } Assert.AreEqual(SIZE,cons.Length()); }
public static Object Compile(Cons args, Environment environment) { currsymbols.Clear(); extracode = string.Empty; Environment localEnvironment = new Environment(environment); string name = MakeUnique("gen"); while (File.Exists(name + ".dll")) { name = MakeUnique("gen"); } string gc = Closure(args, localEnvironment) as string; if (gc.Length == 0) { return(null); } string code = string.Format(@" [assembly:LSharp.LSharpExtension] [LSharp.Function] public sealed class {0} {{ ", name); code += gc; code += extracode; code += @" }"; copts.GenerateExecutable = false; copts.OutputAssembly = name + ".dll"; CompilerResults cr = comp.CompileAssemblyFromSource(copts, code); if (cr.NativeCompilerReturnValue == 0) { Assembly genass = cr.CompiledAssembly; return(Runtime.Import(genass.Location, environment)); } else { foreach (CompilerError err in cr.Errors) { Console.Error.WriteLine("Compiler error: {0}", err); } return(null); } }
/// <summary> /// 写出到控制台 /// </summary> /// <param name="type">类型</param> /// <param name="message">消息</param> private void WriteConsole(LogType type, string message) { try { message = Cons.FormatLine(message); //处理日志信息(换行) Cons.SetColor(GetColor(type), ConsoleColor.Black); Console.WriteLine(LOG_FORMAT, DateTime.Now.ToString(TIME_FORMAT), type.ToString(), message); Cons.ResetColor(); //取消单独线程输出日志文件(单独线程输出日志必然会有延迟) //if (IsWriteFile) Queue.Enqueue(new LogModel() { Type = type, Message = message, CreateTime = DateTime.Now }); } catch { } }
private void AddImageToBoard(string userUrl) { Сhrome.OpenUrlNewTab(userUrl); IWebElement Element_photo = Сhrome.FindWebElement(By.XPath("//div[@class = 'e2e-Work']/div/div[1]/div[1]/div/div/div[2]/a")); if (Element_photo == null) { Cons.WriteLine($"AddImageToBoard. v2 {userUrl}"); Сhrome.CloseAndReturnTab(); return; } string url_photo = Element_photo.GetAttribute("href"); Сhrome.OpenUrl(url_photo); Thread.Sleep(1000); if (!Сhrome.ClickButtonXPath("//div[. = 'Сохранить']")) { Cons.WriteLine($"Error open board."); Сhrome.CloseAndReturnTab(); return; } Thread.Sleep(500); if (Сhrome.FindWebElement(By.XPath("//*[contains(text(), 'Новая доска настроени')]")) == null) { if (!Сhrome.ClickButtonXPath("//div[. = 'Сохранить']")) { Cons.WriteLine($"Error check open board."); Сhrome.CloseAndReturnTab(); return; } } Thread.Sleep(200); if (!Сhrome.ClickButtonXPath($"//li[. ='{GetRandomNameBoard()}']")) { Cons.WriteLine($"Error select board."); } Thread.Sleep(600); if (!Сhrome.ClickButtonXPath("//button[. ='Сохранить']")) { Cons.WriteLine($"Error save image to board."); } Thread.Sleep(3000); Сhrome.CloseAndReturnTab(); }
public static Object Do(Cons args, Environment environment) { //string v = "//(do " + Printer.ConsToString(args) + ")" + NewLine; string v = string.Empty; if (args != null) { foreach (object item in args) { string sv = Generate(item, environment) + NewLine; v += sv; } } return(v); }
public void ConsWrite(string s) { const int MaxConsSz = 500; Cons.AppendText(DateTime.Now.ToString("H:m:s ") + s + "\n"); if (Cons.Lines.Length > MaxConsSz) { int numOfLines = Cons.Lines.Length - MaxConsSz; var lines = this.Cons.Lines; var newLines = lines.Skip(numOfLines); this.Cons.Lines = newLines.ToArray(); } Cons.SelectionStart = Cons.Text.Length; Cons.ScrollToCaret(); }
public void SeqIteratorResetAtFirstWorks() { Cons c = new Cons(1, new Cons(2, null)); SeqEnumerator s = new SeqEnumerator(c); s.MoveNext(); s.Reset(); Expect(s.MoveNext()); Expect(s.Current, EqualTo(1)); Expect(s.MoveNext()); Expect(s.Current, EqualTo(2)); Expect(s.Current, EqualTo(2)); Expect(s.MoveNext(), False); }
public void ConsLength() { const int SIZE = 10; Cons cons = new Cons(0); int i; for (i= 1 ; i < SIZE; i++) { cons = new Cons(i,cons); Console.WriteLine(i); } Assert.AreEqual(SIZE, cons.Length()); }
static Cons Evlis(object formlist) { Cons evaluated = null; while (true) { Cons formpair = formlist as Cons; if (formpair != null) { evaluated = new Cons (Eval (formpair.Car), evaluated); formlist = formpair.Cdr; } else if (formpair == null) return (Cons) CL.Reverse (evaluated); else throw new NotImplementedException (); } }
public static Object Let(Cons args, Environment environment) { string v = //"//(let " + Printer.ConsToString(args) + ")" + NewLine + "{" + NewLine; Environment localEnvironment = new 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); }
public void SeqIteratorResetAtFirstWorks() { Cons c = new Cons(1, new Cons(2, null)); SeqEnumerator s = new SeqEnumerator(c); s.MoveNext(); s.Reset(); Expect(s.MoveNext()); Expect(s.Current).To.Equal(1); Expect(s.MoveNext()); Expect(s.Current).To.Equal(2); Expect(s.Current).To.Equal(2); Expect(s.MoveNext()).To.Be.False(); }
/// <summary> Collapses a native path (expressed as a Cons list) into a fully qualified name </summary> private static string CollapseIntoNativeName(Cons path) { string name = ""; while (path != null) { if (name.Length > 0) { name += "."; } name += path.first.AsSymbol.name; path = path.rest.AsCons; } return(name); }
public Val Call(Context ctx, Val a) { if (fnUnary != null) { return(fnUnary(ctx, a)); } else if (fnVarArg != null) { return(fnVarArg(ctx, Cons.MakeList(a))); } else { throw new LanguageError("Primitive function call of incorrect unary arity"); } }
public override bool BooleanOnEvent(string eventName, string[] paramNames, Type[] paramTypes, params object[] parameters) { if (Interpreter == null) { return(true); } eventName = eventName.ToLower(); Cons eval; if (!Interpreter.IsSubscriberOf(eventName)) { return(true); } if (EventArgsInDictionary) { Dictionary <String, object> eventArgs = new Dictionary <string, object>(); for (int i = 0; i < paramNames.Length; i++) { eventArgs.Add(paramNames[i], CoerceArg(parameters[i], paramTypes[i])); } eval = new Cons(eventName, new Cons(eventArgs, null)); } else { //todo return(true); Cons invokeMe = null; for (int i = paramNames.Length - 1; i >= 0; i--) { invokeMe = new Cons(CoerceArg(parameters[i], paramTypes[i]), invokeMe); } eval = new Cons(Interpreter.GetSymbol(eventName.ToLower()), invokeMe); } // right now most events are void but there is one that is boolean which means we may as well eturn true for all try { object o = Interpreter.Eval(eval); } catch (Exception e) { DLRConsole.DebugWriteLine(eval + " Caused"); DLRConsole.DebugWriteLine(e); } return(true); }
static void ExtractMethodInfo(Cons mcc, out string member, ref Type[] argtypes, ref Type[] gentypes) { member = SymbolTable.IdToString((SymbolId)mcc.car); mcc = mcc.cdr as Cons; if (mcc == null) { argtypes = gentypes = new Type[0]; return; } if (mcc.car is object[]) { var gargs = new List <Type>(); foreach (var ga in mcc.car as object[]) { var tt = ReadType(ga); if (tt == null) { ClrSyntaxError("clr-call", "type not found", ga); } gargs.Add(tt); } gentypes = gargs.ToArray(); mcc = mcc.cdr as Cons; } if (mcc != null) { var targs = new List <Type>(); foreach (var arg in mcc) { var tt = ReadType(arg); if (tt == null) { ClrSyntaxError("clr-call", "type not found", arg); } targs.Add(tt); } argtypes = targs.ToArray(); } }
public static void Test() { var i = 2; var result = ""; while (result != "-1") { result = WordsLibrary.GetRandomWordByLength(i); Cons.Writeln("Рандомное слово с длиной " + i + " : " + result); i++; } Check("корсак"); Check("хуяк"); Check("педолог"); }
public static void ParseLambdaList(Cons llist, Environment env, Function f) { var list = ListToArray(llist); foreach (var i in list) { if (!(i is Symbol s)) { throw new SyntaxError("Illegal parameter list"); } if (!s.Name.StartsWith("&")) { f.AddParam(s); } } }
public override LispObject Apply(Cons arguments, LispEnvironment env) { var argList = new List<LispObject>(arguments); if (argList.Count < 2) { throw new EvaluateException("Too few arguments to " + this.Name); } if (argList.Count > 2) { throw new EvaluateException("Too many arguments to " + this.Name); } return argList[0].As<LispNumber>().DivideBy(argList[1].As<LispNumber>()); }
public static object Find(object proc, object list) { ICallable p = RequiresNotNull <ICallable>(proc); Cons c = Requires <Runtime.Cons>(list); while (c != null) { if (IsTrue(p.Call(c.car))) { return(c.car); } c = c.cdr as Cons; } return(FALSE); }
public object ObjectToLisp(object prim) { OSD data = OSD.FromObject(prim); if (data.Type != OSDType.Unknown) { return(SerializeLisp(data)); } Type t = prim.GetType(); foreach (FieldInfo PI in t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)) { object value = ToLispValue(PI.FieldType, PI.GetValue(prim)); object kv = new Cons(PI.Name, new Cons(value, null)); } return(prim); }
private static YearNode EvalYear(Cons cons) { if ((cons.car as string).ToLower() == "year") { YearNode year = new YearNode(BigInteger.Parse((cons.cdr as Cons).car as string)); Cons monthCollection = (cons.cdr as Cons).cdr as Cons; foreach (Cons month in monthCollection) { year.Months.Add(EvalMonth(month)); } return(year); } else { throw new Exception($"无效的标记:{cons.car}"); } }
private static MonthNode EvalMonth(Cons cons) { if ((cons.car as string).ToLower() == "month") { MonthNode month = new MonthNode((cons.cdr as Cons).car as string); Cons daysCollection = (cons.cdr as Cons).cdr as Cons; foreach (Cons day in daysCollection) { month.Days.Add(EvalDay(day)); } return(month); } else { throw new Exception($"无效的标记:{cons.car}"); } }
public static void Init() { gml.Add(Symbol.FindOrCreate("DEFPARAMETER"), (IType form) => { var(t1, tbody) = Util.RequireAtLeast(form, 1, "DEFPARAMETER"); if (!(t1[0] is Symbol name)) { throw new SyntaxError("DEFPARAMETER: Invalid name"); } Cons ret = new Cons(Symbol.FindOrCreate("PROGN"), new Cons( new Cons(Symbol.FindOrCreate("SPECIAL"), new Cons(name, Lisp.nil)), Lisp.nil)); if (tbody is Cons c) { (ret.cdr as Cons).cdr = new Cons(new Cons(Symbol.FindOrCreate("SETQ"), new Cons(name, new Cons(c.car, Lisp.nil))), Lisp.nil); } return(ret); });
static Expression Apply(CodeBlock cb, Cons c, SourceSpan SpanHint) { var result = GetAst(c.cdr, cb); if (!result.Span.IsValid) { var ve = result as VoidExpression; if (ve != null && ve.Statement is WriteStatement) { ve.Statement.SetLoc(SpanHint); } else { result.SetLoc(SpanHint); } } return result; }
static Expression Apply(CodeBlock cb, Cons c, SourceSpan SpanHint) { var result = GetAst(c.cdr, cb); if (!result.Span.IsValid) { var ve = result as VoidExpression; if (ve != null && ve.Statement is WriteStatement) { ve.Statement.SetLoc(SpanHint); } else { result.SetLoc(SpanHint); } } return(result); }
private static Element createNextElement(Document doc, Element prevElem, string elemFamType, bool rotateOnSingleConDirection = false) { Cons prevElemCons = mp.GetConnectors(prevElem); FamilySymbol familySymbol = fi.GetElements <FamilySymbol, BuiltInParameter> (doc, BuiltInParameter.SYMBOL_FAMILY_AND_TYPE_NAMES_PARAM, elemFamType).FirstOrDefault(); if (familySymbol == null) { throw new Exception(elemFamType + " not found!"); } //The strange symbol activation thingie... //See: http://thebuildingcoder.typepad.com/blog/2014/08/activate-your-family-symbol-before-using-it.html if (!familySymbol.IsActive) { familySymbol.Activate(); doc.Regenerate(); } Element elem = doc.Create.NewFamilyInstance(prevElemCons.Secondary.Origin, familySymbol, StructuralType.NonStructural); doc.Regenerate(); Cons elemCons = mp.GetConnectors(elem); if (rotateOnSingleConDirection) { RotateElementInPosition(prevElemCons.Secondary.Origin, elemCons.Primary, prevElemCons.Secondary, elem); } else { RotateElementInPosition(prevElemCons.Secondary.Origin, elemCons.Primary, prevElemCons.Secondary, prevElemCons.Primary, elem); } ElementTransformUtils.MoveElement(doc, elem.Id, prevElemCons.Secondary.Origin - elemCons.Primary.Origin); return(elem); }
public override Expression Generate(object args, CodeBlock c) { Cons a = (Cons)args; object an = a.car; if (an is Annotation) { var anno = (Annotation)an; if (anno.source is Cons) { Cons src = anno.source as Cons; string filename = src.car as string; object location = src.cdr; Cons expr = anno.expression as Cons; annotations = expr == null ? null : expr.cdr as Cons; // bootstrap check if (location is string) { SpanHint = ExtractLocation(location as string); } else if (location is SourceSpan) { SpanHint = (SourceSpan)location; } if (c.Filename == null) { c.Filename = filename; } LocationHint = filename; return(base.Generate(a.cdr, c)); } } LocationHint = null; SpanHint = SourceSpan.None; return(base.Generate(a.cdr, c)); }
/// <summary> /// If the results form follows the pattern (append (list a b) (list c d) ...) /// it will be converted to a simple (list a b c d ...) /// </summary> private Val TryOptimizeAppend(Cons value) { Val original = new Val(value); if (!IsSymbolWithName(value.first, "append")) { return(original); } List <Val> results = new List <Val>(); Val rest = value.rest; while (rest.IsNotNil) { Cons cons = rest.AsConsOrNull; if (cons == null) { return(original); // not a proper list } Cons maybeList = cons.first.AsConsOrNull; if (maybeList == null) { return(original); // not all elements are lists themselves } if (!IsSymbolWithName(maybeList.first, "list")) { return(original); // not all elements are of the form (list ...) } Val ops = maybeList.rest; while (ops.IsCons) { results.Add(ops.AsCons.first); ops = ops.AsCons.rest; } rest = cons.rest; } // we've reassembled the bodies, return them in the form (list ...) return(new Val(new Cons(_global.Intern("list"), Cons.MakeList(results)))); }
public static Object While(Cons args, 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); }
public static Object With(Cons args, Environment environment) { string v = //"//(with " + Printer.ConsToString(args) + ")" + NewLine + "{" + NewLine; Cons bindings = (Cons)args.First(); Environment localEnvironment = new Environment(environment); while ((bindings != null) && (bindings.Length() > 1)) { v += GenerateAssignLocal((Symbol)bindings.First(), Generate(bindings.Second(), environment), localEnvironment); bindings = (Cons)bindings.Cddr(); } foreach (object item in (Cons)args.Cdr()) { v += Generate(item, localEnvironment); } return(v + "}"); }
public void FromListTest() { List <string> actual1 = new List <string>() { "a", "b", "c", "d", "e", "f", "g" }; List <string> actual2 = new List <string>() { "a", "b", "c", "d", "e", "f", "G" }; List <string> actual3 = new List <string>() { "A", "b", "c", "d", "e", "f", "G" }; Assert.AreEqual <Cons>(_expected, Cons.FromList(actual1)); Assert.AreNotEqual <Cons>(_expected, Cons.FromList(actual2)); Assert.AreNotEqual <Cons>(_expected, Cons.FromList(actual3)); }
internal override void Start(int limit) { for (int j = 0; j < 100; j++) { if (!OpenRandomFollowerPage()) { Cons.WriteLine($"Open random page error."); return; } for (int i = 3; i < 3000; i++) { string xpathNextUser = UserXpath + "/li[" + i + "]"; if (imageAddBoard_counter >= limit) { return; } if (IsBlock()) { return; } if (!Сhrome.Scroll(xpathNextUser)) { break; } if (CheckUser(xpathNextUser, out string userUrl, out _, out _, out _)) { AddImageToBoard(userUrl); db.AddUser(userUrl, 0, 0, 0); imageAddBoard_counter++; Cons.WriteLine($"{Name}. Count = {imageAddBoard_counter}"); } Thread.Sleep(100); } Cons.WriteLine("End following list"); } }
protected static bool AssignParameters(CodeBlock cb, object arg, object types) { bool isrest = false; Cons cargs = arg as Cons; Cons ctypes = types as Cons; if (cargs != null) { while (cargs != null) { SymbolId an = (SymbolId)Builtins.First(cargs); object type = Builtins.First(ctypes); Type clrtype = ClrGenerator.ExtractTypeInfo(Builtins.List(quote, type)); CreateParameter(an, cb, clrtype); Cons r = cargs.cdr as Cons; Cons rt = ctypes.cdr as Cons; if (r == null && cargs.cdr != null) { SymbolId ta = (SymbolId)cargs.cdr; CreateParameter(ta, cb, typeof(object)); isrest = true; break; } else { cargs = r; ctypes = rt; } } } else if (arg != null) // empty { SymbolId an = (SymbolId)arg; isrest = true; CreateParameter(an, cb, typeof(object)); } return(isrest); }
/// <summary> /// Starting with an open paren, recursively parse everything up to the matching closing paren, /// and then return it as a sequence of conses. /// </summary> private Val ParseList(InputStream stream, bool backquote) { List <Val> results = new List <Val>(); stream.Read(); // consume opening paren ConsumeWhitespace(stream); char ch; while ((ch = stream.Peek()) != ')' && ch != (char)0) { Val val = Parse(stream, backquote); results.Add(val); } stream.Read(); // consume the closing paren ConsumeWhitespace(stream); return(Cons.MakeList(results)); }
static Expression GetConsVector(object[] v, CodeBlock cb) { List <Expression> e = new List <Expression>(); foreach (object var in v) { Cons c = var as Cons; e.Add(GetCons(var, cb)); } for (int i = 0; i < e.Count; i++) { if (e[i].Type.IsValueType) { e[i] = Ast.ConvertHelper(e[i], typeof(object)); } } return(Ast.NewArray(typeof(object[]), e.ToArray())); }
public static object ListToVector(Parser p, string type, Cons list) { if (p.skipnumbers) { return null; } type = type.Substring(1, type.Length - 2); switch (type) { case "u8": case "vu8": return Builtins.ListToByteVector(list); case "fl": return Builtins.ListToFlonumVector(list); case "fx": return Builtins.ListToFixnumVector(list); default: throw new SyntaxErrorException("Not a known vector type: " + type); } }
public override LispObject Apply(Cons arguments, LispEnvironment env) { if (arguments.IsNil) { throw new EvaluationException("Too few arguments to " + Name); } if (arguments.Cdr.IsNil) { return arguments.Car.As<LispNumber>().Negate(); } var difference = arguments.Car.As<LispNumber>(); foreach (var subtrahend in arguments.Cdr.As<Cons>()) { difference = difference.Add(subtrahend.As<LispNumber>().Negate()); } return difference; }
public static object Filter(object proc, object list) { ICallable p = RequiresNotNull<ICallable>(proc); Cons e = Requires<Runtime.Cons>(list); Cons h = null, head = null; while (e != null) { if (IsTrue(p.Call(e.car))) { if (h == null) { h = head = new Cons(e.car); } else { h = (Cons)(h.cdr = new Cons(e.car)); } } e = e.cdr as Cons; } return head; }
public override LispObject Apply(Cons arguments, LispEnvironment env) { if (arguments.IsNil) { throw new EvaluationException("Too few arguments to " + Name); } var previous = arguments.Car.As<LispNumber>(); foreach (var arg in arguments.Cdr.As<Cons>()) { var num = arg.As<LispNumber>(); if (!test(previous, num)) { return LispNull.Nil; } previous = num; } return T.True; }
internal MonaLet(Token letkind, Cons<Tuple<Token, MonaExpr>> lets, MonaExpr formula, Dictionary<string, MonaParam> let_vars) : base(letkind, MonaExprType.BOOL, new MonaExpr[]{formula}) { this.lets = lets; this.let_vars = let_vars; }
static bool IsSimpleCons(Cons c) { if (c == null) { return true; } return !(c.car is Cons) && (c.cdr == null || IsSimpleCons(c.cdr as Cons)); }
public abstract LispObject Apply(Cons arguments, LispEnvironment env);
internal MonaVarDecls(MonaDeclKind kind, Cons<Token> univs, Cons<MonaVarWhere> vars) : base(kind) { this.univs = univs; this.vars = vars; }
public void Rule3(float dt, World world){ switch (s3) { case -1: count_down1 = 3f; goto case 5; case 5: if(((count_down1) > (0f))) { count_down1 = ((count_down1) - (dt)); s3 = 5; return; }else { goto case 0; } case 0: counter13 = -1; if((((Enumerable.Range(0,((1) + (((1) - (0))))).ToList<System.Int32>()).Count) == (0))) { s3 = -1; return; }else { ___a32 = (Enumerable.Range(0,((1) + (((1) - (0))))).ToList<System.Int32>())[0]; goto case 1; } case 1: counter13 = ((counter13) + (1)); if((((((Enumerable.Range(0,((1) + (((1) - (0))))).ToList<System.Int32>()).Count) == (counter13))) || (((counter13) > ((Enumerable.Range(0,((1) + (((1) - (0))))).ToList<System.Int32>()).Count))))) { s3 = -1; return; }else { ___a32 = (Enumerable.Range(0,((1) + (((1) - (0))))).ToList<System.Int32>())[counter13]; goto case 2; } case 2: Asteroids = new Cons<Asteroid>(new Asteroid(new UnityEngine.Vector3(UnityEngine.Random.Range(-10f,10f),1f,UnityEngine.Random.Range(15f,20f))), (Asteroids)).ToList<Asteroid>(); s3 = 1; return; default: return;}}
public Macro(string name, LispObject lambdaList, Cons macroBody, LispEnvironment macroEnv) { this.name = name; this.expander = new Lambda(lambdaList, macroBody, macroEnv); this.macroEnv = macroEnv; }
public Cons Expand(Cons form, LispEnvironment env) { var argumentValues = form.Cdr.As<Cons>(); return this.expander.Apply(argumentValues, this.macroEnv).As<Cons>(); }