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>();
}
