public override Expression GenDlr(GenContext context)
{
if (_method != null)
return Compiler.MaybeBox(GenDlrForMethod(context));
else
return GenDlrViaReflection(context);
}
public override Expression GenDlr(GenContext context)
{
Expression exc = _excExpr.GenDlr(context);
Expression exc2 = Expression.Convert(exc, typeof(Exception));
return Expression.Throw(exc2);
}
private Expression GenDlrForMethod(GenContext context)
{
Expression target = _target.GenDlr(context);
Expression[] args = GenTypedArgs(context, _method.GetParameters(), _args);
return AstUtils.SimpleCallHelper(target,_method, args); ;
}
internal static Type Create(GenContext context, Type baseClass)
{
//ModuleBuilder mb = context.ModuleBldr;
string name = baseClass.Name + "_impl";
//TypeBuilder baseTB = context.ModuleBldr.DefineType(name, TypeAttributes.Class | TypeAttributes.Public, baseClass);
TypeBuilder baseTB = context.AssemblyGen.DefinePublicType(name, baseClass, true);
ObjExpr.MarkAsSerializable(baseTB);
baseTB.DefineDefaultConstructor(MethodAttributes.Public);
FieldBuilder metaField = baseTB.DefineField("_meta", typeof(IPersistentMap), FieldAttributes.Public);
MethodBuilder metaMB = baseTB.DefineMethod("meta", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot, typeof(IPersistentMap), Type.EmptyTypes);
ILGen gen = new ILGen(metaMB.GetILGenerator());
gen.EmitLoadArg(0);
gen.EmitFieldGet(metaField);
gen.Emit(OpCodes.Ret);
MethodBuilder withMB = baseTB.DefineMethod("withMeta", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.ReuseSlot, typeof(IObj), new Type[] { typeof(IPersistentMap)});
gen = new ILGen(withMB.GetILGenerator());
gen.EmitLoadArg(0);
gen.EmitCall(Compiler.Method_Object_MemberwiseClone);
gen.Emit(OpCodes.Castclass, baseTB);
gen.Emit(OpCodes.Dup);
gen.EmitLoadArg(1);
gen.EmitFieldSet(metaField);
gen.Emit(OpCodes.Ret);
for (int i = 0; i < 20; i++ )
DefineDelegateFieldAndOverride(baseTB, i);
return baseTB.CreateType();
}
public static Type GenerateInterface(string iName, ISeq extends, ISeq methods)
{
GenContext context = new GenContext(iName, CompilerMode.File);
// GenContext context = (GenContext)Compiler.COMPILER_CONTEXT.deref();
// if (context == null)
// {
//#if DEBUG
// context = new GenContext(iName, CompilerMode.File);
//#else
// throw new InvalidOperationException("No compiler context on the stack.");
//#endif
// }
Type[] interfaceTypes = GenClass.CreateTypeArray(extends == null ? null : extends.seq());
TypeBuilder proxyTB = context.ModuleBldr.DefineType(
iName,
TypeAttributes.Interface | TypeAttributes.Public | TypeAttributes.Abstract,
null,
interfaceTypes);
DefineMethods(proxyTB, methods);
Type t = proxyTB.CreateType();
context.AssyBldr.Save(iName + ".dll");
return t;
}
internal static Expression[] GenTypedArgs(GenContext context, ParameterInfo[] parms, IPersistentVector args)
{
Expression[] exprs = new Expression[parms.Length];
for (int i = 0; i < parms.Length; i++)
exprs[i] = GenTypedArg(context,parms[i].ParameterType, (Expr)args.nth(i));
return exprs;
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
List<Expression> exprs = new List<Expression>();
ParameterExpression parm = Expression.Parameter(typeof(Var), "v");
Expression varExpr = objx.GenVar(context,_var);
exprs.Add(Expression.Assign(parm, varExpr));
// The Java code does the following in the opposite order (as modified in commit #430dd4f, Jan 19, 2010)
// However, the call to bindRoot sets :macro to False. I'm not sure how it works now in the JVM version.
if (_initProvided )
// Java doesn't Box here, but we have to deal with unboxed bool values
exprs.Add(Expression.Call(parm, Compiler.Method_Var_bindRoot, Compiler.MaybeBox(_init.GenCode(RHC.Expression,objx,context))));
if (_meta != null)
{
if (_initProvided || IncludesExplicitMetadata((MapExpr)_meta))
{
// Java casts to IPersistentMap on the _meta, but Expression.Call can handle that for us.
exprs.Add(Expression.Call(parm, Compiler.Method_Var_setMeta, _meta.GenCode(RHC.Expression,objx,context)));
}
}
exprs.Add(parm);
return Expression.Block(new ParameterExpression[] { parm }, exprs);
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
int n = _bindingInits.count();
List<ParameterExpression> parms = new List<ParameterExpression>(n);
List<Expression> forms = new List<Expression>(n);
/// First, set up the environment.
for (int i = 0; i < n; i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
ParameterExpression parmExpr = Expression.Parameter(typeof(IFn), bi.Binding.Name);
bi.Binding.ParamExpression = parmExpr;
parms.Add(parmExpr);
}
// Then initialize
for (int i = 0; i < n; i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
ParameterExpression parmExpr = (ParameterExpression)bi.Binding.ParamExpression;
forms.Add(Expression.Assign(parmExpr, bi.Init.GenCode(RHC.Expression,objx,context)));
}
// The work
forms.Add(_body.GenCode(rhc,objx,context));
return Expression.Block(parms,forms);
}
public override Expression GenDlr(GenContext context)
{
Expression getTypeExpr = Expression.Call(null, Compiler.Method_RT_classForName, Expression.Constant(_c));
//Expression getNsExpr = Expression.Call(null, Compiler.Method_Compiler_CurrentNamespace);
Expression getNsExpr = Expression.Property(null, Compiler.Method_Compiler_CurrentNamespace);
return Expression.Call(getNsExpr, Compiler.Method_Namespace_importClass1, getTypeExpr);
}
public override Expression GenDlrUnboxed(GenContext context)
{
if (_method != null)
return GenDlrForMethod(context);
else
throw new InvalidOperationException("Unboxed emit of unknown member.");
}
public override Expression GenDlr(GenContext context)
{
Expression basicBody = _tryExpr.GenDlr(context);
// Wrap the basic body, a Comma, in a return to a label
LabelTarget target = Expression.Label(basicBody.Type, "ret_label");
//Expression tryBody = Expression.Return(target, basicBody);
Expression tryBody = basicBody;
CatchBlock[] catches = new CatchBlock[_catchExprs.count()];
for ( int i=0; i<_catchExprs.count(); i++ )
{
CatchClause clause = (CatchClause) _catchExprs.nth(i);
ParameterExpression parmExpr = Expression.Parameter(clause.Type, clause.Lb.Name);
clause.Lb.ParamExpression = parmExpr;
catches[i] = Expression.Catch(parmExpr,clause.Handler.GenDlr(context));
}
TryExpression tryStmt = _finallyExpr == null
? Expression.TryCatch(tryBody, catches)
: Expression.TryCatchFinally(tryBody, _finallyExpr.GenDlr(context), catches);
Expression defaultValue = Expression.Default(basicBody.Type);
Expression whole = Expression.Block(tryStmt, Expression.Label(target, defaultValue));
return whole;
}
public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Expression exc = _excExpr.GenCode(RHC.Expression, objx, context);
Expression exc2 = Expression.Convert(exc, typeof(Exception));
return Expression.Throw(exc2,typeof(object));
}
internal static Expression GenTypedArg(GenContext context, Type type, Expr arg)
{
if (Compiler.MaybePrimitiveType(arg) == type)
return ((MaybePrimitiveExpr)arg).GenDlrUnboxed(context);
else
// Java has emitUnboxArg -- should we do something similar?
return arg.GenDlr(context);
}
internal static Expression GenTypedArg(GenContext context, Type type, Expr arg)
{
if (Compiler.MaybePrimitiveType(arg) == type)
return ((MaybePrimitiveExpr)arg).GenDlrUnboxed(context);
else
{
Expression argExpr = arg.GenDlr(context);
return GenMaybeUnboxedArg(type, argExpr);
}
}
public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Expression call;
if (_method != null)
call = GenDlrForMethod(objx, context);
else
call = GenerateComplexCall(objx, context);
call = Compiler.MaybeAddDebugInfo(call, _spanMap, context.IsDebuggable);
return call;
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Expression objExpr = _expr.GenCode(RHC.Expression, objx, context);
Expression iobjExpr = Expression.Convert(objExpr, typeof(IObj));
Expression metaExpr = _meta.GenCode(RHC.Expression, objx, context);
metaExpr = Expression.Convert(metaExpr, typeof(IPersistentMap));
Expression ret = Expression.Call(iobjExpr, Compiler.Method_IObj_withMeta, metaExpr);
return ret;
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Expression objExpr = _expr.GenCode(RHC.Expression, objx, context);
Expression iobjExpr = Expression.Convert(objExpr, typeof(IObj));
Expression metaExpr = _meta.GenCode(RHC.Expression, objx, context);
// Do we need a conversion here? probably not.
Expression ret = Expression.Call(iobjExpr, Compiler.Method_IObj_withMeta, metaExpr);
return ret;
}
public Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context)
{
Type t = _n.GetType();
if (t == typeof(int))
return Expression.Constant((long)(int)_n, typeof(long));
else if (t == typeof(double))
return Expression.Constant((double)_n, typeof(double));
else if ( t == typeof(long) )
return Expression.Constant((long)_n,typeof(long));
throw new ArgumentException("Unsupported Number type: " + _n.GetType().Name);
}
internal static Type Create(GenContext context, Type baseClass)
{
ModuleBuilder mb = context.ModuleBldr;
string name = baseClass.Name + "_impl";
TypeBuilder baseTB = context.ModuleBldr.DefineType(name, TypeAttributes.Class | TypeAttributes.Public, baseClass);
baseTB.DefineDefaultConstructor(MethodAttributes.Public);
for (int i = 0; i < 20; i++ )
DefineDelegateFieldAndOverride(baseTB, i);
return baseTB.CreateType();
}
static public void EmitDynamicCallPostlude(LambdaExpression lambda, Type delType, MethodBuilder mbLambda, CljILGen ilg)
{
GenContext context = Compiler.CompilerContextVar.deref() as GenContext;
if (context == null)
{
// light compile
MethodInfo mi = delType.GetMethod("Invoke");
ilg.Emit(OpCodes.Callvirt, mi);
}
else
{
ilg.Emit(OpCodes.Call, mbLambda);
}
}
public override Expression GenDlr(GenContext context)
{
Expression fn = _fexpr.GenDlr(context);
fn = Expression.Convert(fn, typeof(IFn));
int argCount = _args.count();
Expression[] args = new Expression[argCount];
for (int i = 0; i < argCount; i++ )
args[i] = Compiler.MaybeBox(((Expr)_args.nth(i)).GenDlr(context));
Expression call = GenerateInvocation(InvocationReturnType, fn, args);
return call;
}
private void EmitStaticConstructorBody(CljILGen ilg)
{
GenContext.EmitDebugInfo(ilg, SpanMap);
if (Constants.count() > 0)
{
EmitConstantFieldInits(ilg);
}
if (KeywordCallsites.count() > 0)
{
EmitKeywordCallsiteInits(ilg);
}
ilg.Emit(OpCodes.Ret);
}
GenProxy(string className)
{
if (Compiler.IsCompiling)
{
//string path = (string)Compiler.COMPILE_PATH.deref();
//if (path == null)
// throw new Exception("*compile-path* not set");
////string dir = (string)Compiler.SOURCE_PATH.deref();
//_context = new GenContext(className, ".dll", path, CompilerMode.File);
_context = (GenContext)Compiler.CompilerContextVar.deref();
}
else
_context = GenContext.CreateWithInternalAssembly("proxy" + (++_saveId).ToString(), false);
}
internal LambdaExpression GenerateImmediateLambda(RHC rhc, ObjExpr objx, GenContext context)
{
List <ParameterExpression> parmExprs = new List <ParameterExpression>(_argLocals.count());
if (_thisBinding != null)
{
_thisBinding.ParamExpression = objx.ThisParam;
}
try
{
LabelTarget loopLabel = Expression.Label("top");
Var.pushThreadBindings(RT.map(Compiler.LoopLabelVar, loopLabel, Compiler.MethodVar, this));
for (int i = 0; i < _argLocals.count(); i++)
{
LocalBinding b = (LocalBinding)_argLocals.nth(i);
ParameterExpression pexpr = Expression.Parameter(typeof(object), b.Name);
b.ParamExpression = pexpr;
parmExprs.Add(pexpr);
}
List <Expression> bodyExprs = new List <Expression>();
//bodyExprs.AddRange(typedParmInitExprs);
bodyExprs.Add(Expression.Label(loopLabel));
bodyExprs.Add(Compiler.MaybeBox(_body.GenCode(rhc, objx, context)));
Expression block;
//if (typedParmExprs.Count > 0)
// block = Expression.Block(typedParmExprs, bodyExprs);
//else
block = Expression.Block(bodyExprs);
return(Expression.Lambda(
FuncTypeHelpers.GetFFuncType(parmExprs.Count),
block,
Objx.ThisName,
parmExprs));
}
finally
{
Var.popThreadBindings();
}
}
internal static Expression GenTypedArg(ObjExpr objx, GenContext context, Type paramType, Expr arg)
{
Type primt = Compiler.MaybePrimitiveType(arg);
if (primt == paramType)
{
Expression expr = ((MaybePrimitiveExpr)arg).GenCodeUnboxed(RHC.Expression, objx, context);
return(expr);
}
else if (primt == typeof(int) && paramType == typeof(long))
{
Expression expr = ((MaybePrimitiveExpr)arg).GenCodeUnboxed(RHC.Expression, objx, context);
expr = Expression.Convert(expr, typeof(long));
return(expr);
}
else if (primt == typeof(long) && paramType == typeof(int))
{
Expression expr = ((MaybePrimitiveExpr)arg).GenCodeUnboxed(RHC.Expression, objx, context);
if (RT.booleanCast(RT.UncheckedMathVar.deref()))
{
expr = Expression.Call(Compiler.Method_RT_uncheckedIntCast_long, expr);
}
else
{
expr = Expression.Call(Compiler.Method_RT_intCast_long, expr);
}
return(expr);
}
else if (primt == typeof(float) && paramType == typeof(double))
{
Expression expr = ((MaybePrimitiveExpr)arg).GenCodeUnboxed(RHC.Expression, objx, context);
expr = Expression.Convert(expr, typeof(double));
return(expr);
}
else if (primt == typeof(double) && paramType == typeof(float))
{
Expression expr = ((MaybePrimitiveExpr)arg).GenCodeUnboxed(RHC.Expression, objx, context);
expr = Expression.Convert(expr, typeof(float));
return(expr);
}
else
{
Expression argExpr = arg.GenCode(RHC.Expression, objx, context);
return(GenUnboxArg(argExpr, paramType));
}
}
private Expression GenTargetExpression(ObjExpr objx, GenContext context)
{
if (Compiler.CompileStubOrigClassVar.isBound && Compiler.CompileStubOrigClassVar.deref() != null && objx.TypeBuilder != null)
{
return(Expression.Constant(objx.TypeBuilder, typeof(Type)));
}
if (_type != null)
{
return(Expression.Constant(_type, typeof(Type)));
}
throw new ArgumentException("Cannot generate type for NewExpr. Serious!");
//string name = Compiler.DestubClassName(_type.FullName);
//return Expression.Call(null, Compiler.Method_RT_classForName, Expression.Constant(name));
}
public override Expression GenDlr(GenContext context)
{
List<Expression> exprs = new List<Expression>(_exprs.count());
for (int i = 0; i < _exprs.count() - 1; i++)
{
Expr e = (Expr)_exprs.nth(i);
exprs.Add(e.GenDlr(context));
}
// In Java version, this is split off because the Context in the calls above is forced to be C.STATEMENT.
// TODO: Wrap this into the loop above. No real need to do this way.
Expr last = (Expr)_exprs.nth(_exprs.count() - 1);
exprs.Add(last.GenDlr(context));
return Expression.Block(exprs);
}
internal Expression GenLocal(GenContext context, LocalBinding lb)
{
if (context.Mode == CompilerMode.File && _closes.containsKey(lb))
{
Expression expr = Expression.Field(_thisParam, lb.Name);
Type primtType = lb.PrimitiveType;
if (primtType != null)
{
expr = Compiler.MaybeBox(Expression.Convert(expr, primtType));
}
return(expr);
}
else
{
return(lb.ParamExpression);
}
}
static public void EmitDynamicCallPreamble(DynamicExpression dyn, IPersistentMap spanMap, string methodName, Type returnType, List <ParameterExpression> paramExprs, Type[] paramTypes, CljILGen ilg, out LambdaExpression lambda, out Type delType, out MethodBuilder mbLambda)
{
Expression call = dyn;
GenContext context = Compiler.CompilerContextVar.deref() as GenContext;
if (context != null && context.DynInitHelper != null)
{
call = context.DynInitHelper.ReduceDyn(dyn);
}
if (returnType == typeof(void))
{
call = Expression.Block(call, Expression.Default(typeof(object)));
returnType = typeof(object);
}
else if (returnType != call.Type)
{
call = Expression.Convert(call, returnType);
}
call = GenContext.AddDebugInfo(call, spanMap);
delType = Microsoft.Scripting.Generation.Snippets.Shared.DefineDelegate("__interop__", returnType, paramTypes);
lambda = Expression.Lambda(delType, call, paramExprs);
mbLambda = null;
if (context == null)
{
// light compile
Delegate d = lambda.Compile();
int key = RT.nextID();
CacheDelegate(key, d);
ilg.EmitInt(key);
ilg.Emit(OpCodes.Call, Method_MethodExpr_GetDelegate);
ilg.Emit(OpCodes.Castclass, delType);
}
else
{
mbLambda = context.TB.DefineMethod(methodName, MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, returnType, paramTypes);
lambda.CompileToMethod(mbLambda);
}
}
GenProxy(string className)
{
if (Compiler.IsCompiling)
{
//string path = (string)Compiler.COMPILE_PATH.deref();
//if (path == null)
// throw new Exception("*compile-path* not set");
////string dir = (string)Compiler.SOURCE_PATH.deref();
//_context = new GenContext(className, ".dll", path, CompilerMode.File);
_context = (GenContext)Compiler.COMPILER_CONTEXT.deref();
}
else
//_context = new GenContext("proxy" + (++_saveId).ToString(), CompilerMode.Immediate);
_context = new GenContext("proxy" + (++_saveId).ToString(), false);
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Type collType;
if (_coll is IPersistentList)
collType = typeof(PersistentList);
else if (_coll is IPersistentVector)
collType = typeof(PersistentVector);
else if (_coll is IPersistentMap)
collType = typeof(PersistentArrayMap);
else if (_coll is IPersistentSet)
collType = typeof(PersistentHashSet);
else
throw new InvalidOperationException("Unknown collection type.");
return Expression.Field(null, collType, "EMPTY");
}
public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
{
Type targetType = _targetType;
GenContext.EmitDebugInfo(ilg, _spanMap);
if (targetType != null && _tinfo != null)
{
_target.Emit(RHC.Expression, objx, ilg);
MethodExpr.EmitPrepForCall(ilg, typeof(object), FieldDeclaringType);
EmitGet(ilg);
}
else
{
throw new InvalidOperationException("Unboxed emit of unknown member.");
}
}
private ConstructorBuilder EmitConstructorForNonDefType(TypeBuilder fnTB, Type baseType)
{
ConstructorBuilder cb = fnTB.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, CtorTypes());
CljILGen gen = new CljILGen(cb.GetILGenerator());
GenContext.EmitDebugInfo(gen, SpanMap);
//Call base constructor
ConstructorInfo baseCtorInfo = baseType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, Type.EmptyTypes, null);
if (baseCtorInfo == null)
{
throw new InvalidOperationException("Unable to find default constructor for " + baseType.FullName);
}
gen.EmitLoadArg(0);
gen.Emit(OpCodes.Call, baseCtorInfo);
// Store Meta
if (SupportsMeta)
{
gen.EmitLoadArg(0);
gen.EmitLoadArg(1);
gen.Emit(OpCodes.Castclass, typeof(IPersistentMap));
gen.EmitFieldSet(MetaField);
}
// store closed-overs in their fields
int a = 0;
int offset = !SupportsMeta ? 1 : 2;
for (ISeq s = RT.keys(Closes); s != null; s = s.next(), a++)
{
//LocalBinding lb = (LocalBinding)s.first();
FieldBuilder fb = ClosedOverFields[a];
bool isVolatile = IsVolatile(ClosedOverFieldsToBindingsMap[fb]);
gen.EmitLoadArg(0); // gen.Emit(OpCodes.Ldarg_0);
gen.EmitLoadArg(a + offset); // gen.Emit(OpCodes.Ldarg, a + 1);
gen.MaybeEmitVolatileOp(isVolatile);
gen.Emit(OpCodes.Stfld, fb);
}
gen.Emit(OpCodes.Ret);
return(cb);
}
void GenerateMethod(MethodInfo staticMethodInfo, GenContext context)
{
string methodName = IsVariadic ? "doInvoke" : "invoke";
TypeBuilder tb = context.FnExpr.TypeBuilder;
// TODO: Cache all the CreateObjectTypeArray values
MethodBuilder mb = tb.DefineMethod(methodName, MethodAttributes.ReuseSlot | MethodAttributes.Public | MethodAttributes.Virtual, typeof(object), Compiler.CreateObjectTypeArray(NumParams));
ILGenerator gen = mb.GetILGenerator();
gen.Emit(OpCodes.Ldarg_0);
for (int i = 1; i <= _argLocals.count(); i++)
{
gen.Emit(OpCodes.Ldarg, i);
}
gen.Emit(OpCodes.Call, staticMethodInfo);
gen.Emit(OpCodes.Ret);
}
public override Expression GenDlr(GenContext context)
{
List <Expression> exprs = new List <Expression>(_exprs.count());
for (int i = 0; i < _exprs.count() - 1; i++)
{
Expr e = (Expr)_exprs.nth(i);
exprs.Add(e.GenDlr(context));
}
// In Java version, this is split off because the Context in the calls above is forced to be C.STATEMENT.
// TODO: Wrap this into the loop above. No real need to do this way.
Expr last = (Expr)_exprs.nth(_exprs.count() - 1);
exprs.Add(last.GenDlr(context));
return(Expression.Block(exprs));
}
public static GenContext CreateWithInternalAssembly(string assyName, bool createDynInitHelper)
{
GenContext ctx = CreateGenContext(assyName, assyName, ".dll", null, createDynInitHelper);
AddInternalAssembly(ctx.AssemblyBuilder);
#if CLR2
// Massive kludge for .net 3.5 -- the RuntimeAssemblyBuilder yielded by reflection is not the same as AssemblyBuilder.
Type t = CreateDummyType(ctx.ModuleBuilder);
MethodInfo m = t.GetMethod("test");
if (m != null && m.DeclaringType.Assembly != ctx.AssemblyBuilder)
{
AddInternalAssembly(m.DeclaringType.Assembly);
}
#endif
return(ctx);
}
public override Expression GenDlrUnboxed(GenContext context)
{
Expression target = _target.GenDlr(context);
if (_targetType != null && (_fieldInfo != null || _propertyInfo != null))
{
Expression convTarget = Expression.Convert(target, _targetType);
Expression access = _fieldInfo != null
? Expression.Field(convTarget, _fieldInfo)
: Expression.Property(convTarget, _propertyInfo);
return(access);
}
else
{
throw new InvalidOperationException("Unboxed emit of unknown member.");
}
}
public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
{
GenContext.EmitDebugInfo(ilg, _spanMap);
if (_method != null)
{
EmitForMethod(objx, ilg);
}
else
{
throw new InvalidOperationException("Unboxed emit of unknown member.");
}
if (rhc == RHC.Statement)
{
ilg.Emit(OpCodes.Pop);
}
}
public override Expression GenDlr(GenContext context)
{
LabelTarget loopLabel = (LabelTarget)Compiler.LOOP_LABEL.deref();
if (loopLabel == null)
{
throw new InvalidOperationException("Recur not in proper context.");
}
int argCount = _args.count();
List <ParameterExpression> tempVars = new List <ParameterExpression>(argCount);
List <Expression> tempAssigns = new List <Expression>(argCount);
List <Expression> finalAssigns = new List <Expression>(argCount);
// Evaluate all the init forms into local variables.
// TODO: Check the typing here.
for (int i = 0; i < _loopLocals.count(); i++)
{
LocalBinding b = (LocalBinding)_loopLocals.nth(i);
Expr arg = (Expr)_args.nth(i);
ParameterExpression tempVar = Expression.Parameter(b.ParamExpression.Type, "__local__" + i); //asdf-tag
Expression valExpr = ((Expr)_args.nth(i)).GenDlr(context);
tempVars.Add(tempVar);
if (tempVar.Type == typeof(Object))
{
tempAssigns.Add(Expression.Assign(tempVar, Compiler.MaybeBox(valExpr)));
}
else
{
tempAssigns.Add(Expression.Assign(tempVar, Expression.Convert(valExpr, tempVar.Type))); //asdf-tag
}
finalAssigns.Add(Expression.Assign(b.ParamExpression, tempVar)); //asdf-tag
}
List <Expression> exprs = tempAssigns;
exprs.AddRange(finalAssigns);
exprs.Add(Expression.Goto(loopLabel));
// need to do this to get a return value in the type inferencing -- else can't use this in a then or else clause.
exprs.Add(Expression.Constant(null));
return(Expression.Block(tempVars, exprs));
}
public override void EmitAssign(RHC rhc, ObjExpr objx, CljILGen ilg, Expr val)
{
if (_tinfo.IsInitOnly)
{
throw new InvalidOperationException(String.Format("Attempt to set readonly static field {0} in class {1}", _tinfo.Name, _tinfo.DeclaringType));
}
GenContext.EmitDebugInfo(ilg, _spanMap);
val.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Dup);
HostExpr.EmitUnboxArg(objx, ilg, FieldType);
ilg.MaybeEmitVolatileOp(_tinfo);
ilg.EmitFieldSet(_tinfo);
if (rhc == RHC.Statement)
{
ilg.Emit(OpCodes.Pop);
}
}
public override Expression GenDlr(GenContext context)
{
throw new NotImplementedException();
//List<ParameterExpression> parms = new List<ParameterExpression>();
//List<Expression> forms = new List<Expression>();
//for (int i = 0; i < _bindingInits.count(); i++)
//{
// BindingInit bi = (BindingInit)_bindingInits.nth(i);
// Type primType = Compiler.MaybePrimitiveType(bi.Init);
// ParameterExpression parmExpr = Expression.Parameter(primType ?? typeof(object), bi.Binding.Name);
// bi.Binding.ParamExpression = parmExpr;
// parms.Add(parmExpr);
// //forms.Add(Expression.Assign(parmExpr, Compiler.MaybeBox(bi.Init.GenDlr(context))));
// Expression initExpr = primType != null ? ((MaybePrimitiveExpr)bi.Init).GenDlrUnboxed(context) : Compiler.MaybeBox(bi.Init.GenDlr(context));
// forms.Add(Expression.Assign(parmExpr, initExpr));
//}
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
GenContext.EmitDebugInfo(ilg, _spanMap);
if (_isProtocol)
{
EmitProto(rhc, objx, ilg);
}
else
{
_fexpr.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(IFn));
EmitArgsAndCall(0, rhc, objx, ilg);
}
if (rhc == RHC.Statement)
{
ilg.Emit(OpCodes.Pop);
}
}
public override Expression GenDlr(GenContext context)
{
Expression target = _target.GenDlr(context);
if (_targetType != null && (_fieldInfo != null || _propertyInfo != null))
{
Expression convTarget = Expression.Convert(target, _targetType);
Expression access = _fieldInfo != null
? Expression.Field(convTarget, _fieldInfo)
: Expression.Property(convTarget, _propertyInfo);
return(Compiler.MaybeBox(access));
}
else
{
return(Compiler.MaybeBox(Expression.PropertyOrField(target, _fieldName)));
}
//Or maybe this should call Reflector.invokeNoArgInstanceMember
}
public Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context)
{
Type t = _n.GetType();
if (t == typeof(int))
{
return(Expression.Constant((long)(int)_n, typeof(long)));
}
else if (t == typeof(double))
{
return(Expression.Constant((double)_n, typeof(double)));
}
else if (t == typeof(long))
{
return(Expression.Constant((long)_n, typeof(long)));
}
throw new ArgumentException("Unsupported Number type: " + _n.GetType().Name);
}
public override Expression GenDlr(GenContext context)
{
Expression fn = _fexpr.GenDlr(context);
fn = Expression.Convert(fn, typeof(IFn));
int argCount = _args.count();
Expression[] args = new Expression[argCount];
for (int i = 0; i < argCount; i++)
{
args[i] = Compiler.MaybeBox(((Expr)_args.nth(i)).GenDlr(context));
}
Expression call = GenerateInvocation(InvocationReturnType, fn, args);
return(call);
}
public override Expression GenDlr(GenContext context)
{
throw new NotImplementedException();
//List<ParameterExpression> parms = new List<ParameterExpression>();
//List<Expression> forms = new List<Expression>();
//for (int i = 0; i < _bindingInits.count(); i++)
//{
// BindingInit bi = (BindingInit)_bindingInits.nth(i);
// Type primType = Compiler.MaybePrimitiveType(bi.Init);
// ParameterExpression parmExpr = Expression.Parameter(primType ?? typeof(object), bi.Binding.Name);
// bi.Binding.ParamExpression = parmExpr;
// parms.Add(parmExpr);
// //forms.Add(Expression.Assign(parmExpr, Compiler.MaybeBox(bi.Init.GenDlr(context))));
// Expression initExpr = primType != null ? ((MaybePrimitiveExpr)bi.Init).GenDlrUnboxed(context) : Compiler.MaybeBox(bi.Init.GenDlr(context));
// forms.Add(Expression.Assign(parmExpr, initExpr));
//}
}
public override Expression GenDlr(GenContext context)
{
LabelTarget loopLabel = Expression.Label();
List <ParameterExpression> parms = new List <ParameterExpression>();
List <Expression> forms = new List <Expression>();
for (int i = 0; i < _bindingInits.count(); i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
Type primType = Compiler.MaybePrimitiveType(bi.Init);
ParameterExpression parmExpr = Expression.Parameter(primType ?? typeof(object), bi.Binding.Name);
bi.Binding.ParamExpression = parmExpr;
parms.Add(parmExpr);
//forms.Add(Expression.Assign(parmExpr, Compiler.MaybeBox(bi.Init.GenDlr(context))));
Expression initExpr = primType != null ? ((MaybePrimitiveExpr)bi.Init).GenDlrUnboxed(context) : Compiler.MaybeBox(bi.Init.GenDlr(context));
forms.Add(Expression.Assign(parmExpr, initExpr));
}
forms.Add(Expression.Label(loopLabel));
try
{
if (_isLoop)
{
Var.pushThreadBindings(PersistentHashMap.create(Compiler.LOOP_LABEL, loopLabel));
}
forms.Add(_body.GenDlr(context));
}
finally
{
if (_isLoop)
{
Var.popThreadBindings();
}
}
Expression block = Expression.Block(parms, forms);
return(block);
}
public override Expression GenDlr(GenContext context)
{
if (_ctor != null)
{
// The ctor is uniquely determined.
Expression[] args = Compiler.GenTypedArgArray(context, _ctor.GetParameters(), _args);
return(Expression.New(_ctor, args));
// JAVA: emitClearLocals
}
else
{
Expression typeExpr = Expression.Call(Compiler.Method_RT_classForName, Expression.Constant(_type.FullName));
Expression args = Compiler.GenArgArray(context, _args);
// Java: emitClearLocals
return(Expression.Call(Compiler.Method_Reflector_InvokeConstructor, typeExpr, args));
}
}
public override Expression GenDlr(GenContext context)
{
if ( _ctor != null )
{
// The ctor is uniquely determined.
Expression[] args = Compiler.GenTypedArgArray(context, _ctor.GetParameters(), _args);
return Expression.New(_ctor, args);
// JAVA: emitClearLocals
}
else
{
Expression typeExpr = Expression.Call(Compiler.Method_RT_classForName, Expression.Constant(_type.FullName));
Expression args = Compiler.GenArgArray(context, _args);
// Java: emitClearLocals
return Expression.Call(Compiler.Method_Reflector_InvokeConstructor,typeExpr,args);
}
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Expression call;
if (_ctor != null)
{
call = GenDlrForMethod(rhc, objx, context);
}
else if (_isNoArgValueTypeCtor)
{
call = Expression.Default(_type);
}
else
{
call = GenerateComplexCall(rhc, objx, context);
}
call = Compiler.MaybeAddDebugInfo(call, _spanMap, context.IsDebuggable);
return(call);
}
public override Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context)
{
Expression target = _target.GenCode(RHC.Expression, objx, context);
Type returnType = HasClrType ? ClrType : typeof(object);
// TODO: Get rid of Default
GetMemberBinder binder = new ClojureGetZeroArityMemberBinder(ClojureContext.Default, _memberName, false);
DynamicExpression dyn = Expression.Dynamic(binder, returnType, new Expression[] { target });
Expression call = dyn;
if (context.DynInitHelper != null)
{
call = context.DynInitHelper.ReduceDyn(dyn);
}
call = Compiler.MaybeAddDebugInfo(call, _spanMap, context.IsDebuggable);
return(call);
}
public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Expression call;
Type retType;
if (_method != null)
{
call = GenDlrForMethod(objx, context);
retType = _method.ReturnType;
}
else
{
call = GenerateComplexCall(objx, context);
retType = typeof(object);
}
call = HostExpr.GenBoxReturn(call, retType, objx, context);
call = Compiler.MaybeAddDebugInfo(call, _spanMap, context.IsDebuggable);
return(call);
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
//if (context.Mode == CompilerMode.Immediate)
if (objx.FnMode == FnMode.Light )
{
// This will emit a plain Keyword reference, rather than a callsite.
InvokeExpr ie = new InvokeExpr(_source, _spanMap, (Symbol)_tag, _kw, RT.vector(_target));
return ie.GenCode(rhc, objx, context);
}
else
{
ParameterExpression thunkParam = Expression.Parameter(typeof(ILookupThunk), "thunk");
Expression assignThunk = Expression.Assign(thunkParam, Expression.Field(null, objx.ThunkField(_siteIndex)));
ParameterExpression targetParam = Expression.Parameter(typeof(object), "target");
Expression assignTarget = Expression.Assign(targetParam,_target.GenCode(RHC.Expression, objx, context));
ParameterExpression valParam = Expression.Parameter(typeof(Object), "val");
Expression assignVal = Expression.Assign(valParam, Expression.Call(thunkParam, Compiler.Method_ILookupThunk_get,targetParam));
ParameterExpression siteParam = Expression.Parameter(typeof(KeywordLookupSite), "site");
Expression assignSite = Expression.Assign(siteParam, Expression.Field(null, objx.KeywordLookupSiteField(_siteIndex)));
Expression block =
Expression.Block(typeof(Object), new ParameterExpression[] { thunkParam, valParam, targetParam },
assignThunk,
assignTarget,
assignVal,
Expression.Condition(
Expression.NotEqual(valParam, thunkParam),
valParam,
Expression.Block(typeof(Object), new ParameterExpression[] { siteParam },
assignSite,
Expression.Call(siteParam, Compiler.Method_ILookupSite_fault, targetParam, objx.ThisParam)),
typeof(object)));
block = Compiler.MaybeAddDebugInfo(block, _spanMap);
return block;
}
}
public override Expression GenDlr(GenContext context)
{
List<Expression> exprs = new List<Expression>(_exprs.count());
// In Java version, this is split off because the Context in the calls above is forced to be C.STATEMENT.
//for (int i = 0; i < _exprs.count() - 1; i++)
//{
// Expr e = (Expr)_exprs.nth(i);
// exprs.Add(e.GenDlr(context));
//}
//Expr last = (Expr)_exprs.nth(_exprs.count() - 1);
//exprs.Add(last.GenDlr(context));
for (int i = 0; i < _exprs.count(); i++)
{
Expr e = (Expr)_exprs.nth(i);
exprs.Add(e.GenDlr(context));
}
return Expression.Block(exprs);
}
private void EmitStaticConstructorBody(CljILGen ilg)
{
GenContext.EmitDebugInfo(ilg, SpanMap);
if (Constants.count() > 0)
{
EmitConstantFieldInits(ilg);
}
if (KeywordCallsites.count() > 0)
{
EmitKeywordCallsiteInits(ilg);
}
if (IsDefType && RT.booleanCast(RT.get(Opts, Compiler.LoadNsKeyword)))
{
EmitLoadNsInitForDeftype(ilg);
}
ilg.Emit(OpCodes.Ret);
}
public virtual void Emit(ObjExpr fn, TypeBuilder tb)
{
MethodBuilder mb = tb.DefineMethod(MethodName, MethodAttributes.Public, ReturnType, ArgTypes);
CljILGen ilg = new CljILGen(mb.GetILGenerator());
Label loopLabel = ilg.DefineLabel();
GenContext.EmitDebugInfo(ilg, SpanMap);
try
{
Var.pushThreadBindings(RT.map(Compiler.LoopLabelVar, loopLabel, Compiler.MethodVar, this));
ilg.MarkLabel(loopLabel);
Body.Emit(RHC.Return, fn, ilg);
ilg.Emit(OpCodes.Ret);
}
finally
{
Var.popThreadBindings();
}
}
void GeneratePrimMethod(ObjExpr objx, GenContext context)
{
TypeBuilder tb = objx.TypeBuilder;
MethodBuilder mb = tb.DefineMethod("invokePrim", MethodAttributes.ReuseSlot | MethodAttributes.Public | MethodAttributes.Virtual, StaticReturnType, StaticMethodArgTypes);
//Console.Write("InMd: {0} {1}(", ReturnType.Name, "invokePrim");
//foreach (Type t in ArgTypes)
// Console.Write("{0}", t.Name);
//Console.WriteLine(")");
GenInterface.SetCustomAttributes(mb, _methodMeta);
if (_parms != null)
{
for (int i = 0; i < _parms.count(); i++)
{
IPersistentMap meta = GenInterface.ExtractAttributes(RT.meta(_parms.nth(i)));
if (meta != null && meta.count() > 0)
{
ParameterBuilder pb = mb.DefineParameter(i + 1, ParameterAttributes.None, ((Symbol)_parms.nth(i)).Name);
GenInterface.SetCustomAttributes(pb, meta);
}
}
}
ILGen gen = new ILGen(mb.GetILGenerator());
gen.EmitLoadArg(0);
for (int i = 1; i <= _argLocals.count(); i++)
{
gen.EmitLoadArg(i);
}
gen.EmitCall(_staticMethodBuilder);
gen.Emit(OpCodes.Ret);
if (IsExplicit)
{
tb.DefineMethodOverride(mb, _explicitMethodInfo);
}
}
public override Expression GenDlr(GenContext context)
{
List<Expression> exprs = new List<Expression>();
ParameterExpression parm = Expression.Parameter(typeof(Var), "v");
Expression varExpr = context.FnExpr.GenVar(context,_var);
exprs.Add(Expression.Assign(parm, varExpr));
if (_initProvided)
// Java doesn't Box here, but we have to deal with unboxed bool values
exprs.Add(Expression.Call(parm, Compiler.Method_Var_BindRoot, Compiler.MaybeBox(_init.GenDlr(context))));
if (_meta != null)
// Java casts to IPersistentMap on the _meta, but Expression.Call can handle that for us.
exprs.Add(Expression.Call(parm, Compiler.Method_Var_setMeta, _meta.GenDlr(context)));
exprs.Add(parm);
return Expression.Block(new ParameterExpression[] { parm }, exprs);
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Expression basicBody = _tryExpr.GenCode(rhc, objx, context);
if (basicBody.Type == typeof(void))
basicBody = Expression.Block(basicBody, Expression.Default(typeof(object)));
Expression tryBody = Expression.Convert(basicBody,typeof(object));
CatchBlock[] catches = new CatchBlock[_catchExprs.count()];
for ( int i=0; i<_catchExprs.count(); i++ )
{
CatchClause clause = (CatchClause) _catchExprs.nth(i);
ParameterExpression parmExpr = Expression.Parameter(clause.Type, clause.Lb.Name);
clause.Lb.ParamExpression = parmExpr;
catches[i] = Expression.Catch(parmExpr, Expression.Convert(clause.Handler.GenCode(rhc, objx, context), typeof(object)));
}
TryExpression tryStmt = _finallyExpr == null
? Expression.TryCatch(tryBody, catches)
: Expression.TryCatchFinally(tryBody, _finallyExpr.GenCode(RHC.Statement, objx, context), catches);
return tryStmt;
}
Type CompileBaseClass(GenContext context, Type super, Type[] interfaces, Object frm)
{
//TypeBuilder tb = context.ModuleBuilder.DefineType(Compiler.CompileStubPrefix + "." + InternalName + RT.nextID(), TypeAttributes.Public | TypeAttributes.Abstract, super, interfaces);
TypeBuilder tb = context.ModuleBuilder.DefineType(Compiler.DeftypeBaseClassNamePrefix + "." + InternalName + RT.nextID(), TypeAttributes.Public | TypeAttributes.Abstract, super, interfaces);
tb.DefineDefaultConstructor(MethodAttributes.Public);
EmitClosedOverFields(tb);
DefineBaseClassClosedOverConstructors(super, tb);
DefineBaseClassMethods(interfaces, tb);
Type t = tb.CreateType();
BaseClass = t;
BaseClassClosedOverCtor = GetConstructorWithArgCount(t, CtorTypes().Length);
if (AltCtorDrops > 0)
{
BaseClassAltCtor = GetConstructorWithArgCount(t, CtorTypes().Length - AltCtorDrops);
}
return(t);
}