static Variable MakeVar(CodeBlock cb, SymbolId name, Type type)
{
//using globals instead of locals does improve performance a lot, compiling is easier too
//unfortunately they dont play well
//should really investigate better closure structure
return(cb.CreateVariable(name, cb.IsGlobal ? Variable.VariableKind.Global : Variable.VariableKind.Local
, type ?? typeof(object)));
}
static Expression Read(SymbolId name, CodeBlock cb, Type type)
{
SymbolId sname = name;
Variable v = cb.Lookup(sname);
if (v == null)
{
if (assigns.ContainsKey(sname))
{
return(Ast.Read(sname));
}
else
{
CodeBlock tl = GetTopLevel(cb);
v = tl.CreateVariable(sname, Variable.VariableKind.Global, typeof(object), Ast.Read(sname));
return(Ast.Read(v));
}
}
return(Ast.ReadDefined(v));
}
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);
}
static Variable MakeVar(CodeBlock cb, SymbolId name, Type type)
{
//using globals instead of locals does improve performance a lot, compiling is easier too
//unfortunately they dont play well
//should really investigate better closure structure
return cb.CreateVariable(name, cb.IsGlobal ? Variable.VariableKind.Global : Variable.VariableKind.Local
, type ?? typeof(object));
}
