//(import (ironscheme clr))
//(define malloc (pinvoke-call msvcrt malloc void* (uint32)))
public override Expression Generate(object args, CodeBlock cb)
{
Cons c = args as Cons;
string lib = Unquote(c.car);
c = c.cdr as Cons;
string proc = Unquote(c.car);
c = c.cdr as Cons;
Type returntype = GetFFIType(Unquote(c.car));
c = c.cdr as Cons;
List <Type> paramtypes = new List <Type>();
while (c != null)
{
paramtypes.Add(GetFFIType(Unquote(c.car)));
c = c.cdr as Cons;
}
CodeBlock call = GenerateInvoke(proc,
a => PInvokeCall(lib, proc, returntype, paramtypes, a),
returntype,
paramtypes,
cb);
return(Ast.Call(Closure_Make, Ast.CodeBlockExpression(call, false), Ast.Constant(paramtypes.Count)));
}
public override Expression Generate(object args, CodeBlock c)
{
var refs = ClrGenerator.SaveReferences();
object arg = Builtins.First(args);
object typespec = (Builtins.Second(args));
Cons body = Builtins.Cdr(Builtins.Cdr(args)) as Cons;
var returntype = ClrGenerator.ExtractTypeInfo(Builtins.List(quote, Builtins.Second(typespec)));
CodeBlock cb = Ast.CodeBlock(SpanHint, GetLambdaName(c), returntype);
NameHint = SymbolId.Empty;
cb.Filename = LocationHint;
cb.Parent = c;
bool isrest = AssignParameters(cb, arg, Builtins.Car(typespec));
List <Statement> stmts = new List <Statement>();
FillBody(cb, stmts, body, true);
Type dt = GetDelegateType(cb);
Type ct = GetClosureType(cb);
Expression ex = Ast.New(ct.GetConstructor(new Type[] { dt }), Ast.CodeBlockExpression(cb, true, dt));
ClrGenerator.ResetReferences(refs);
return(ex);
}
protected static Expression MakeClosure(CodeBlock cb, bool varargs, bool typed)
{
if (varargs)
{
return(Ast.SimpleCallHelper(Closure_MakeVarArgsX, Ast.CodeBlockExpression(cb, false, typed),
Ast.Constant(cb.ParameterCount)));
}
else
{
return(Ast.SimpleCallHelper(Closure_Make, Ast.CodeBlockExpression(cb, false, typed), Ast.Constant(cb.ParameterCount)));
}
}
public override Expression Generate(object args, CodeBlock c)
{
var ns = ClrGenerator.SaveReferences();
Cons name = (args as Cons).car as Cons;
bool isprogram = name == null;
string[] fullname = Array.ConvertAll <object, string>(Builtins.ListToVector(name), SymbolToString);
string n = string.Join(".", fullname);
NameHint = SymbolTable.StringToId(n);
CodeBlock cb = Ast.CodeBlock(SpanHint, GetLambdaName(c));
cb.IsGlobal = true;
List <SymbolId> vars = new List <SymbolId>();
List <Variable> locals = new List <Variable>();
List <Expression> assignments = new List <Expression>();
List <object> defs = new List <object>();
List <object> bodies = new List <object>();
List <object> sources = new List <object>();
args = (args as Cons).cdr;
Cons a = (args as Cons).car as Cons;
while (a != null)
{
Cons d = a.car as Cons;
SymbolId v = (SymbolId)d.car;
SymbolId l = (SymbolId)((Cons)d.cdr).car;
vars.Add(l);
locals.Add(Create(v, cb, typeof(object)));
defs.Add(((Cons)((Cons)d.cdr).cdr).car);
a = a.cdr as Cons;
}
#if DONE
// pass 0 - record defs
for (int i = 0; i < vars.Count; i++)
{
if (IsMakeRecord(defs[i]))
{
//Debugger.Break();
Type type = CreateRecordType(defs[i] as Cons);
if (type != null)
{
ClrGenerator.AddCompileTimeType(type);
}
}
}
#endif
List <Statement> stmts = new List <Statement>();
// pass 1
for (int i = 0; i < vars.Count; i++)
{
sources.Add(null);
bool annotated, typed;
if (IsLambda(defs[i], out annotated, out typed))
{
Cons cl = defs[i] as Cons;
sources[i] = Copy(cl);
int depth = GetDepth(sources[i]);
if (depth > 10)
{
sources[i] = null;
}
if (annotated)
{
cl = cl.cdr as Cons;
}
if (cl.cdr != null)
{
if (((Cons)cl.cdr).cdr == null)
{
Cons bh = (Cons)((Cons)cl.cdr).car;
if (typed)
{
bh = bh.cdr as Cons;
}
Cons b = bh.cdr as Cons;
bh.cdr = new Cons(Builtins.FALSE);
bodies.Add(b);
}
else
{
List <Cons> cbs = new List <Cons>();
Cons cc = cl.cdr as Cons;
while (cc != null)
{
Cons bh = (Cons)cc.car;
if (typed)
{
bh = bh.cdr as Cons;
}
Cons b = bh.cdr as Cons;
bh.cdr = new Cons(Builtins.FALSE);
cbs.Add(b);
cc = cc.cdr as Cons;
}
bodies.Add(cbs);
}
}
else
{
bodies.Add(null);
}
}
else
{
bodies.Add(null);
}
VarHint = locals[i].Name;
VarHint2 = vars[i];
NameHint = SymbolTable.StringToId(n + "::" + Builtins.UnGenSymInternal(vars[i]));
Expression e = GetAst(defs[i], cb);
VarHint = VarHint2 = SymbolId.Empty;
if (e is UnaryExpression && e.NodeType == AstNodeType.Convert && e.Type != typeof(object))
{
locals[i].Type = e.Type;
}
else if (e.Type.IsValueType)
{
e = Ast.ConvertHelper(e, typeof(object));
}
assignments.Add(e);
if (e is MethodCallExpression)
{
MethodCallExpression mce = e as MethodCallExpression;
if (mce.Method == Closure_Make)
{
var cbe = mce.Arguments[0] as CodeBlockExpression;
cbe.Block.Source = sources[i];
libraryglobals.Add(locals[i].Name, cbe);
libraryglobals.Add(vars[i], cbe);
}
else if (mce.Method == Closure_MakeVarArgsX)
{
libraryglobalsX.Add(locals[i].Name, mce.Arguments[0] as CodeBlockExpression);
libraryglobalsX.Add(vars[i], mce.Arguments[0] as CodeBlockExpression);
}
else if (mce.Method == Closure_MakeCase)
{
NewArrayExpression tcs = mce.Arguments[0] as NewArrayExpression;
List <CodeBlockDescriptor> cdbs = new List <CodeBlockDescriptor>();
foreach (CodeBlockExpression tc in tcs.Expressions)
{
//where do we clean this up??
cdbs.Add(descriptorshack[tc]);
}
libraryglobalsN.Add(locals[i].Name, cdbs.ToArray());
libraryglobalsN.Add(vars[i], cdbs.ToArray());
}
else if (mce.Method == Closure_MakeTypedCase)
{
NewArrayExpression tcs = mce.Arguments[0] as NewArrayExpression;
List <CodeBlockDescriptor> cdbs = new List <CodeBlockDescriptor>();
foreach (Expression tc in tcs.Expressions)
{
//where do we clean this up??
cdbs.Add(descriptorshack2[tc]);
}
libraryglobalsN.Add(locals[i].Name, cdbs.ToArray());
libraryglobalsN.Add(vars[i], cdbs.ToArray());
}
}
else if (e is NewExpression)
{
NewExpression ne = e as NewExpression;
if (typeof(ITypedCallable).IsAssignableFrom(e.Type))
{
libraryglobals.Add(locals[i].Name, ne.Arguments[0] as CodeBlockExpression);
libraryglobals.Add(vars[i], ne.Arguments[0] as CodeBlockExpression);
}
}
}
// pass 2, expand lambda bodies
for (int i = 0; i < vars.Count; i++)
{
Expression e = assignments[i];
NameHint = SymbolTable.StringToId(n + "::" + Builtins.UnGenSymInternal(vars[i]));
if (bodies[i] != null)
{
CodeBlockDescriptor[] cbds;
CodeBlockExpression cbe;
if (libraryglobals.TryGetValue(locals[i].Name, out cbe))
{
Cons b = bodies[i] as Cons;
CodeBlock cbody = cbe.Block;
cbody.Body = null;
FillBody(cbody, new List <Statement>(), b, true);
}
else if (libraryglobalsX.TryGetValue(locals[i].Name, out cbe))
{
Cons b = bodies[i] as Cons;
CodeBlock cbody = cbe.Block;
cbody.Body = null;
FillBody(cbody, new List <Statement>(), b, true);
}
else if (libraryglobalsN.TryGetValue(locals[i].Name, out cbds))
{
List <Cons> b = bodies[i] as List <Cons>;
for (int j = 0; j < b.Count; j++)
{
CodeBlock cbody = cbds[j].codeblock.Block;
cbody.Body = null;
FillBody(cbody, new List <Statement>(), b[j], true);
}
}
}
stmts.Add(Ast.Write(locals[i], e));
// needed indeed
if (!isprogram)
{
stmts.Add(Ast.Statement(Ast.SimpleCallHelper(SetSymbolValue, Ast.Constant(vars[i]), Ast.Read(locals[i]))));
}
}
Cons body = Builtins.Cdr(args) as Cons;
FillBody(cb, stmts, body, true);
cb.ExplicitCodeContextExpression = Ast.CodeContext();
#if OPTIMIZATIONS
Expression ex = InlineCall(c, Ast.CodeBlockExpression(cb, false));
#else
Expression ex = Ast.SimpleCallHelper(MakeClosure(cb, false), GetCallable(0));
#endif
NameHint = SymbolId.Invalid;
ClrGenerator.ResetReferences(ns);
return(ex);
}
public override Expression Generate(object args, CodeBlock c)
{
Cons lambdas = args as Cons;
int arlen = lambdas == null ? 0 : lambdas.Length;
if (arlen == 1)
{
if (lambdagen == null)
{
lambdagen = Context.Scope.LookupName(SymbolTable.StringToId("lambda")) as LambdaGenerator;
}
return(lambdagen.Generate(lambdas.car, c));
}
else
{
List <CodeBlockDescriptor> cbs = new List <CodeBlockDescriptor>();
Cons annotations = this.annotations;
this.annotations = null;
string lambdaname = GetLambdaName(c);
NameHint = SymbolId.Empty;
var sh = SpanHint;
var lh = LocationHint;
Annotation ann = null;
while (lambdas != null)
{
object actual = lambdas.car;
if (annotations != null)
{
ann = annotations.car as Annotation;
if (ann != null)
{
var h = (Cons)ann.source;
if (h.cdr is string)
{
sh = ExtractLocation(((Cons)ann.source).cdr as string);
}
else if (h.cdr is SourceSpan)
{
sh = (SourceSpan)h.cdr;
}
}
}
var refs = ClrGenerator.SaveReferences();
CodeBlock cb = Ast.CodeBlock(sh, lambdaname);
cb.Filename = lh;
cb.Parent = c;
object arg = Builtins.First(actual);
Cons body = Builtins.Cdr(actual) as Cons;
bool isrest = AssignParameters(cb, arg);
cb.IsRest = isrest;
List <Statement> stmts = new List <Statement>();
FillBody(cb, stmts, body, true);
CodeBlockDescriptor cbd = new CodeBlockDescriptor();
cbd.arity = isrest ? -cb.ParameterCount : cb.ParameterCount;
cbd.codeblock = Ast.CodeBlockExpression(cb, false);
cbd.varargs = isrest;
descriptorshack.Add(cbd.codeblock, cbd);
cbs.Add(cbd);
if (annotations != null)
{
annotations = annotations.cdr as Cons;
}
lambdas = lambdas.cdr as Cons;
ClrGenerator.ResetReferences(refs);
}
return(MakeCaseClosure(lambdaname, cbs));
}
}
public override Expression Generate(object args, CodeBlock c)
{
var refs = ClrGenerator.SaveReferences();
NameHint = SymbolTable.StringToId("");
CodeBlock cb = Ast.CodeBlock(SpanHint, GetLambdaName(c));
cb.Parent = c;
List <Variable> vars = new List <Variable>();
List <Variable> temps = new List <Variable>();
List <object> defs = new List <object>();
Cons a = (args as Cons).car as Cons;
while (a != null)
{
Cons d = a.car as Cons;
Variable t = cb.CreateVariable((SymbolId)Builtins.GenSym(d.car), Variable.VariableKind.Temporary, typeof(object));
temps.Add(t);
Variable r = Create((SymbolId)d.car, cb, typeof(object));
r.SetUnInitialized();
vars.Add(r);
defs.Add(((Cons)d.cdr).car);
a = a.cdr as Cons;
}
List <Statement> stmts = new List <Statement>();
var notstrict = !ScriptDomainManager.Options.StrictMode;
for (int i = 0; i < vars.Count; i++)
{
NameHint = Builtins.UnGenSymInternal(vars[i].Name);
//VarHint = vars[i].Name;
Expression e = GetAst(defs[i], cb);
if (e is MethodCallExpression)
{
MethodCallExpression mce = (MethodCallExpression)e;
if (mce.Method == Closure_Make || mce.Method == Closure_MakeCase || mce.Method == Closure_MakeVarArgsX)
{
if (notstrict)
{
vars[i].SetInitialized();
temps[i].Type = vars[i].Type = typeof(Callable);
}
}
}
else if (e is NewExpression)
{
var ne = (NewExpression)e;
if (typeof(ITypedCallable).IsAssignableFrom(ne.Type))
{
if (notstrict)
{
vars[i].SetInitialized();
temps[i].Type = vars[i].Type = ne.Type;
}
}
}
if (e is UnaryExpression && e.NodeType == AstNodeType.Convert && e.Type != typeof(object))
{
if (notstrict)
{
temps[i].Type = vars[i].Type = e.Type;
}
}
else if (e.Type.IsValueType)
{
e = Ast.ConvertHelper(e, typeof(object));
}
stmts.Add(Ast.Write(temps[i], e));
}
for (int i = 0; i < vars.Count; i++)
{
stmts.Add(Ast.Write(vars[i], temps[i]));
}
NameHint = SymbolId.Invalid;
Cons body = Builtins.Cdr(args) as Cons;
FillBody(cb, stmts, body, true);
#if OPTIMIZATIONS
Expression ex = InlineCall(c, Ast.CodeBlockExpression(cb, false));
#else
Expression ex = Ast.SimpleCallHelper(MakeClosure(cb, false), GetCallable(0));
#endif
ClrGenerator.ResetReferences(refs);
return(ex);
}
protected internal static Expression GetAst(object args, CodeBlock cb, bool istailposition)
{
if (args is Annotation)
{
args = ((Annotation)args).stripped;
}
Cons c = args as Cons;
if (c != null)
{
if (c.car is SymbolId)
{
SymbolId f = (SymbolId)c.car;
Variable var = cb.Lookup(f);
if (var != null && !assigns.ContainsKey(f))
{
var = null;
}
object m;
#if OPTIMIZATIONS
#if !BLAH
CodeBlockExpression cbe;
//// needs to do the same for overloads...
if (SimpleGenerator.libraryglobals.TryGetValue(f, out cbe))
{
Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);
if (cbe.Block.ParameterCount < 9 && cbe.Block.ParameterCount == ppp.Length)
{
//inline here? we could for simple bodies, but we need to copy the entire structure
if (!(cbe.Block.HasEnvironment || cbe.Block.IsClosure))
{
if (cbe.Block.Body is ReturnStatement)
{
ReturnStatement rs = (ReturnStatement)cbe.Block.Body;
if (!ScriptDomainManager.Options.DebugMode &&
!ScriptDomainManager.Options.LightweightDebugging &&
!cb.IsGlobal && IsSimpleExpression(rs.Expression))
{
return(InlineCall(cb, Ast.CodeBlockExpression(RewriteBody(cbe.Block), false, cbe.IsStronglyTyped), ppp));
}
}
}
if (cbe.Block != cb.Parent && cbe.Block != cb) // do TCE later
{
return(CallNormal(cbe, ppp));
}
}
}
// varargs
if (SimpleGenerator.libraryglobalsX.TryGetValue(f, out cbe))
{
Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);
if (cbe.Block.ParameterCount < 9 && cbe.Block.ParameterCount - 1 <= ppp.Length)
{
//inline here?
return(CallVarArgs(cbe, ppp));
}
}
// overloads
CodeBlockDescriptor[] cbd;
if (SimpleGenerator.libraryglobalsN.TryGetValue(f, out cbd))
{
Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);
foreach (CodeBlockDescriptor d in cbd)
{
if (d.codeblock.Block.ParameterCount < 9)
{
if (ppp.Length == d.arity || (d.varargs && ppp.Length > d.arity))
{
if (d.varargs)
{
//inline here?
return(CallVarArgs(d.codeblock, ppp));
}
else
{
//inline here?
//if (d.codeblock.Block != cb.Parent && d.codeblock.Block != cb) // do TCE later, not yet
{
return(CallNormal(d.codeblock, ppp));
}
}
}
}
}
}
#endif
//if (!ScriptDomainManager.Options.DebugMode)
{
if (f == SymbolTable.StringToId("call-with-values"))
{
Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);
if (ppp.Length == 2 && ppp[1] is MethodCallExpression)
{
MethodCallExpression consumer = ppp[1] as MethodCallExpression;
if (ppp[0] is MethodCallExpression)
{
MethodCallExpression producer = ppp[0] as MethodCallExpression;
if (consumer.Method == Closure_Make && producer.Method == Closure_Make)
{
CodeBlockExpression ccbe = consumer.Arguments[0] as CodeBlockExpression;
CodeBlockExpression pcbe = producer.Arguments[0] as CodeBlockExpression;
pcbe.Block.Bind();
ccbe.Block.Bind();
if (ccbe.Block.ParameterCount == 0)
{
return(InlineCall(cb, ccbe));
}
else if (ccbe.Block.ParameterCount == 1)
{
return(InlineCall(cb, ccbe, Ast.SimpleCallHelper(typeof(Helpers).GetMethod("UnwrapValue"), InlineCall(cb, pcbe))));
}
else
{
Variable values = cb.CreateTemporaryVariable((SymbolId)Builtins.GenSym("values"), typeof(object[]));
Expression valuesarr = Ast.Read(values);
Expression[] pppp = new Expression[ccbe.Block.ParameterCount];
for (int i = 0; i < pppp.Length; i++)
{
pppp[i] = Ast.ArrayIndex(valuesarr, Ast.Constant(i));
}
return(Ast.Comma(
Ast.Void(
Ast.Write(
values,
Ast.ComplexCallHelper(
Ast.SimpleCallHelper(typeof(Helpers).GetMethod("WrapValue"), InlineCall(cb, pcbe)),
typeof(MultipleValues).GetMethod("ToArray", new Type[] { typeof(int) }),
Ast.Constant(pppp.Length)))),
InlineCall(cb, ccbe, pppp)));
}
}
}
if (consumer.Method == Closure_Make)
{
CodeBlockExpression ccbe = consumer.Arguments[0] as CodeBlockExpression;
ccbe.Block.Bind();
Expression producer = ppp[0];
Expression exx = Ast.ConvertHelper(producer, typeof(Callable));
MethodInfo callx = GetCallable(0);
if (ccbe.Block.ParameterCount == 0)
{
return(InlineCall(cb, ccbe));
}
else if (ccbe.Block.ParameterCount == 1)
{
return(InlineCall(cb, ccbe, Ast.SimpleCallHelper(typeof(Helpers).GetMethod("UnwrapValue"), Ast.Call(exx, callx))));
}
else
{
Variable values = cb.CreateTemporaryVariable((SymbolId)Builtins.GenSym("values"), typeof(object[]));
Expression valuesarr = Ast.Read(values);
Expression[] pppp = new Expression[ccbe.Block.ParameterCount];
for (int i = 0; i < pppp.Length; i++)
{
pppp[i] = Ast.ArrayIndex(valuesarr, Ast.Constant(i));
}
return(Ast.Comma(
Ast.Void(
Ast.Write(
values,
Ast.ComplexCallHelper(
Ast.SimpleCallHelper(typeof(Helpers).GetMethod("WrapValue"),
Ast.Call(exx, callx)),
typeof(MultipleValues).GetMethod("ToArray", new Type[] { typeof(int) }),
Ast.Constant(pppp.Length)))),
InlineCall(cb, ccbe, pppp)));
}
}
}
else
{
;
}
}
}
#endif
// this can be enabled once builtins are auto CPS'd.
// ok I tried, but there are issues still, not sure what
#if OPTIMIZATIONS
// check for inline emitter
InlineEmitter ie;
if (TryGetInlineEmitter(f, out ie))
{
Expression result = ie(GetAstList(c.cdr as Cons, cb));
// if null is returned, the method cannot be inlined
if (result != null)
{
if (spanhint.IsValid)
{
result.SetLoc(spanhint);
}
return(result);
}
}
#endif
if (Context.Scope.TryLookupName(f, out m))
{
if (var == null)
{
IGenerator gh = m as IGenerator;
if (gh != null)
{
return(gh.Generate(c.cdr, cb));
}
BuiltinMethod bf = m as BuiltinMethod;
if (bf != null)
{
MethodBinder mb = bf.Binder;
Expression[] pars = Array.ConvertAll(GetAstList(c.cdr as Cons, cb), e => Unwrap(e));
if (bf.AllowConstantFold && !ScriptDomainManager.Options.DebugMode)
{
bool constant = Array.TrueForAll(pars, e => e is ConstantExpression && e.Type != typeof(BigInteger));
if (constant)
{
object[] cargs = Array.ConvertAll(pars, e => GetRuntimeConstant((ConstantExpression)e));
CallTarget0 disp = delegate
{
return(bf.Call(cargs));
};
CallTarget1 handler = delegate(object e)
{
throw new CompileTimeEvaluationException();
};
try
{
object result = Runtime.R6RS.Exceptions.WithExceptionHandler(
Closure.Create(handler),
Closure.Create(disp));
var rrrr = GetCons(result, cb);
if (spanhint.IsValid)
{
rrrr.SetLoc(spanhint);
}
return(rrrr);
}
catch (CompileTimeEvaluationException)
{
}
}
}
Type[] types = GetExpressionTypes(pars);
MethodCandidate mc = mb.MakeBindingTarget(CallType.None, types);
if (mc != null)
{
if (mc.Target.NeedsContext)
{
pars = ArrayUtils.Insert <Expression>(Ast.CodeContext(), pars);
}
MethodBase meth = mc.Target.Method;
var rrrr = Ast.ComplexCallHelper(meth as MethodInfo, pars);
if (spanhint.IsValid)
{
rrrr.SetLoc(spanhint);
}
return(rrrr);
}
}
Closure clos = m as Closure;
if (clos != null && !SetGenerator.IsAssigned(f))
{
// no provision for varargs
MethodInfo[] mis = clos.Targets;
if (mis.Length > 0)
{
MethodBinder mb = MethodBinder.MakeBinder(binder, SymbolTable.IdToString(f), mis, BinderType.Normal);
Expression[] pars = Array.ConvertAll(GetAstList(c.cdr as Cons, cb), e => Unwrap(e));
if (clos.AllowConstantFold && !ScriptDomainManager.Options.DebugMode)
{
bool constant = Array.TrueForAll(pars, e => e is ConstantExpression && e.Type != typeof(BigInteger));
if (constant)
{
object[] cargs = Array.ConvertAll(pars, e => GetRuntimeConstant((ConstantExpression)e));
CallTarget0 disp = delegate
{
var rrrr = clos.Call(cargs);
return(rrrr);
};
CallTarget1 handler = delegate(object e)
{
throw new CompileTimeEvaluationException();
};
try
{
object result = Runtime.R6RS.Exceptions.WithExceptionHandler(
Closure.Create(handler),
Closure.Create(disp));
var rrrr = GetCons(result, cb);
if (spanhint.IsValid)
{
rrrr.SetLoc(spanhint);
}
return(rrrr);
}
catch (CompileTimeEvaluationException)
{
}
}
}
// exclude transient members if needed
if (!AllowTransientBinding)
{
mis = Array.FindAll(mis, x => !IsTransient(x.Module));
}
if (mis.Length > 0)
{
Type[] types = GetExpressionTypes(pars);
MethodCandidate mc = mb.MakeBindingTarget(CallType.None, types);
if (mc != null)
{
if (mc.Target.NeedsContext)
{
pars = ArrayUtils.Insert <Expression>(Ast.CodeContext(), pars);
}
MethodBase meth = mc.Target.Method;
var rrrr = Ast.ComplexCallHelper(meth as MethodInfo, pars);
if (spanhint.IsValid)
{
rrrr.SetLoc(spanhint);
}
return(rrrr);
}
}
}
// check for overload thing
}
}
}
}
Expression ex = Unwrap(GetAst(c.car, cb));
// a 'let'
if (ex is MethodCallExpression)
{
var ppp = GetAstList(c.cdr as Cons, cb);
MethodCallExpression mcexpr = (MethodCallExpression)ex;
if (mcexpr.Method == Closure_Make)
{
CodeBlockExpression cbe = mcexpr.Arguments[0] as CodeBlockExpression;
if (ppp.Length < 9 && cbe.Block.ParameterCount == ppp.Length)
{
return(InlineCall(cb, cbe, istailposition, ppp));
}
}
// cater for varargs more efficiently, this does not seem to hit, probably needed somewhere else
if (mcexpr.Method == Closure_MakeVarArgsX)
{
CodeBlockExpression cbe = mcexpr.Arguments[0] as CodeBlockExpression;
if (ppp.Length < 9 && cbe.Block.ParameterCount <= ppp.Length)
{
return(CallVarArgs(cbe, ppp));
}
}
}
if (ex is NewExpression && typeof(ITypedCallable).IsAssignableFrom(ex.Type))
{
NewExpression mcexpr = ex as NewExpression;
CodeBlockExpression cbe = mcexpr.Arguments[0] as CodeBlockExpression;
if (cbe == null && mcexpr.Arguments[0].Type == typeof(CodeContext) && mcexpr.Arguments[0] is ConstantExpression) // implies null
{
cbe = mcexpr.Arguments[1] as CodeBlockExpression;
}
if (cbe != null)
{
var ppp = GetAstListNoCast(c.cdr as Cons, cb);
if (ppp.Length < 9 && cbe.Block.ParameterCount == ppp.Length)
{
return(InlineCall(cb, cbe, istailposition, ppp));
}
}
}
if (ex is ConstantExpression)
{
Builtins.SyntaxError(SymbolTable.StringToObject("generator"), "expecting a procedure", c.car, c);
}
Expression r = null;
if (ex.Type.Name.Contains("TypedClosure"))
{
Expression[] pp = GetAstListNoCast(c.cdr as Cons, cb);
var m = ex.Type.GetMethod("Invoke");
r = Ast.SimpleCallHelper(ex, m, pp);
}
else
{
Expression[] pp = GetAstList(c.cdr as Cons, cb);
if (ex.Type != typeof(Callable))
{
ex = Ast.ConvertHelper(ex, typeof(Callable));
}
MethodInfo call = GetCallable(pp.Length);
r = pp.Length > 8 ?
Ast.Call(ex, call, Ast.NewArray(typeof(object[]), pp)) :
Ast.Call(ex, call, pp);
}
if (spanhint.IsValid)
{
r.SetLoc(spanhint);
}
return(r);
}
object[] v = args as object[];
if (v != null)
{
return(GetConsVector(v, cb));
}
else if (args is byte[])
{
Expression[] ba = Array.ConvertAll(args as byte[], b => Ast.Constant(b));
return(Ast.NewArray(typeof(byte[]), ba));
}
else
{
if (args is SymbolId)
{
SymbolId sym = (SymbolId)args;
if (sym == SymbolTable.StringToId("uninitialized"))
{
return(Ast.ReadField(null, typeof(Uninitialized), "Instance"));
}
else
{
return(Read(sym, cb, typeof(object)));
}
}
if (args == Builtins.Unspecified)
{
return(Ast.ReadField(null, Unspecified));
}
if (args is Fraction)
{
Fraction f = (Fraction)args;
return(Ast.Constant(new FractionConstant(f)));
}
if (args is ComplexFraction)
{
ComplexFraction f = (ComplexFraction)args;
return(Ast.Constant(new ComplexFractionConstant(f)));
}
if (args != null && args.GetType().Name == "stx")
{
args = new SerializedConstant(args);
}
return(Ast.Constant(args));
}
}
public override Expression Generate(object args, CodeBlock c)
{
Cons lambdas = args as Cons;
int arlen = lambdas == null ? 0 : lambdas.Length;
if (arlen == 1)
{
if (lambdagen == null)
{
lambdagen = Context.Scope.LookupName(SymbolTable.StringToId("typed-lambda")) as TypedLambdaGenerator;
}
return(lambdagen.Generate(lambdas.car, c));
}
else
{
List <CodeBlockDescriptor> cbs = new List <CodeBlockDescriptor>();
string lambdaname = GetLambdaName(c);
NameHint = SymbolId.Empty;
var sh = SpanHint;
var lh = LocationHint;
while (lambdas != null)
{
var refs = ClrGenerator.SaveReferences();
object actual = lambdas.car;
object arg = Builtins.First(actual);
object typespec = (Builtins.Second(actual));
Cons body = Builtins.Cdr(Builtins.Cdr(actual)) as Cons;
var returntype = ClrGenerator.ExtractTypeInfo(Builtins.List(quote, Builtins.Second(typespec)));
CodeBlock cb = Ast.CodeBlock(SpanHint, lambdaname, returntype);
NameHint = SymbolId.Empty;
cb.Filename = lh;
cb.Parent = c;
bool isrest = AssignParameters(cb, arg, Builtins.Car(typespec));
List <Statement> stmts = new List <Statement>();
FillBody(cb, stmts, body, true);
Type dt = GetDelegateType(cb);
Type ct = GetClosureType(cb);
var cbe = Ast.CodeBlockExpression(cb, true, dt);
Expression ex = Ast.New(ct.GetConstructor(new Type[] { dt }), cbe);
CodeBlockDescriptor cbd = new CodeBlockDescriptor();
cbd.arity = isrest ? -cb.ParameterCount : cb.ParameterCount;
cbd.callable = ex;
cbd.codeblock = cbe;
cbd.varargs = isrest;
descriptorshack2.Add(cbd.callable, cbd);
cbs.Add(cbd);
lambdas = lambdas.cdr as Cons;
ClrGenerator.ResetReferences(refs);
}
return(MakeTypedCaseClosure(lambdaname, cbs));
}
}
