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 void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
EmitUnboxed(rhc, objx, ilg);
HostExpr.EmitBoxReturn(objx, ilg, typeof(bool));
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
objx.EmitVar(ilg, _var);
if (_isDynamic)
{
ilg.Emit(OpCodes.Call, Compiler.Method_Var_setDynamic0);
}
if (_meta != null)
{
if (_initProvided || true) //IncludesExplicitMetadata((MapExpr)_meta))
{
ilg.Emit(OpCodes.Dup);
_meta.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(IPersistentMap));
ilg.Emit(OpCodes.Call, Compiler.Method_Var_setMeta);
}
}
if (_initProvided)
{
ilg.Emit(OpCodes.Dup);
if (_init is FnExpr)
((FnExpr)_init).EmitForDefn(objx, ilg);
else
_init.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Call,Compiler.Method_Var_bindRoot);
}
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
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 override void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
ilg.EmitBoolean(_val);
ilg.Emit(OpCodes.Box,typeof(bool));
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
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));
}
public void EmitAssign(RHC rhc, ObjExpr objx, CljILGen ilg, Expr val)
{
objx.EmitVar(ilg, _var);
val.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Call, Compiler.Method_Var_set);
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
for (int i = 0; i < _exprs.count() - 1; i++)
{
Expr e = (Expr)_exprs.nth(i);
e.Emit(RHC.Statement, objx, ilg);
}
LastExpr.Emit(rhc, objx, ilg);
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
ilg.Emit(OpCodes.Call,Compiler.Method_Compiler_CurrentNamespace.GetGetMethod());
ilg.Emit(OpCodes.Ldstr, _c);
ilg.Emit(OpCodes.Call, Compiler.Method_RT_classForName);
ilg.Emit(OpCodes.Call, Compiler.Method_Namespace_importClass1);
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
_expr.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(IObj));
_meta.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(IPersistentMap));
ilg.EmitCall(Compiler.Method_IObj_withMeta);
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
{
for (int i = 0; i < _exprs.count() - 1; i++)
{
Expr e = (Expr)_exprs.nth(i);
e.Emit(RHC.Statement, objx, ilg);
}
MaybePrimitiveExpr mbe = (MaybePrimitiveExpr)LastExpr;
mbe.EmitUnboxed(rhc, objx, ilg);
}
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;
}
internal static void EmitBoxReturn(ObjExpr objx, CljILGen ilg, Type returnType)
{
if (returnType == typeof(void))
{
ilg.Emit(OpCodes.Ldnull);
}
else if (returnType.IsPrimitive || returnType.IsValueType)
{
ilg.Emit(OpCodes.Box, returnType);
}
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
EmitUnboxed(rhc, objx, ilg);
if (rhc != RHC.Statement)
{
HostExpr.EmitBoxReturn(objx, ilg, _retType);
}
if (rhc == RHC.Statement)
{
ilg.Emit(OpCodes.Pop);
}
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
_expr.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(IObj));
_meta.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(IPersistentMap));
ilg.EmitCall(Compiler.Method_IObj_withMeta);
if (rhc == RHC.Statement)
{
ilg.Emit(OpCodes.Pop);
}
}
public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
{
GenContext.EmitDebugInfo(ilg, _spanMap);
if (_tinfo.IsLiteral)
{
// literal fields need to be inlined directly in here... We use GetRawConstant
// which will work even in partial trust if the constant is protected.
object value = _tinfo.GetRawConstantValue();
switch (Type.GetTypeCode(_tinfo.FieldType))
{
case TypeCode.Boolean:
if ((bool)value)
{
ilg.Emit(OpCodes.Ldc_I4_1);
}
else
{
ilg.Emit(OpCodes.Ldc_I4_0);
}
break;
case TypeCode.Byte: ilg.EmitInt((int)(byte)value); break;
case TypeCode.Char: ilg.EmitInt((int)(char)value); break;
case TypeCode.Double: ilg.EmitDouble((double)value); break;
case TypeCode.Int16: ilg.EmitInt((int)(short)value); break;
case TypeCode.Int32: ilg.EmitInt((int)value); break;
case TypeCode.Int64: ilg.EmitLong((long)value); break;
case TypeCode.SByte: ilg.EmitInt((int)(sbyte)value); break;
case TypeCode.Single: ilg.EmitSingle((float)value); break;
case TypeCode.String: ilg.EmitString((string)value); break;
case TypeCode.UInt16: ilg.EmitInt((int)(ushort)value); break;
case TypeCode.UInt32: ilg.Emit(OpCodes.Ldc_I4, (uint)value); break;
case TypeCode.UInt64: ilg.Emit(OpCodes.Ldc_I8, (ulong)value); break;
}
}
else
{
ilg.MaybeEmitVolatileOp(_tinfo);
ilg.EmitFieldGet(_tinfo);
}
}
protected static void EmitBody(ObjExpr objx, CljILGen ilg, Type retType, Expr body)
{
MaybePrimitiveExpr be = (MaybePrimitiveExpr)body;
if (Util.IsPrimitive(retType) && be.CanEmitPrimitive)
{
Type bt = Compiler.MaybePrimitiveType(be);
if (bt == retType)
{
be.EmitUnboxed(RHC.Return, objx, ilg);
}
else if (retType == typeof(long) && bt == typeof(int))
{
be.EmitUnboxed(RHC.Return, objx, ilg);
ilg.Emit(OpCodes.Conv_I8);
}
else if (retType == typeof(double) && bt == typeof(float))
{
be.EmitUnboxed(RHC.Return, objx, ilg);
ilg.Emit(OpCodes.Conv_R8);
}
else if (retType == typeof(int) && bt == typeof(long))
{
be.EmitUnboxed(RHC.Return, objx, ilg);
ilg.Emit(OpCodes.Call, Compiler.Method_RT_intCast_long);
}
else if (retType == typeof(float) && bt == typeof(double))
{
be.EmitUnboxed(RHC.Return, objx, ilg);
ilg.Emit(OpCodes.Conv_R4);
}
else
{
throw new ArgumentException(String.Format("Mismatched primitive return, expected: {0}, had: {1}", retType, be.ClrType));
}
}
else
{
body.Emit(RHC.Return, objx, ilg);
if (body.HasNormalExit())
{
if (retType == typeof(void))
{
ilg.Emit(OpCodes.Pop);
}
else
{
EmitUnboxArg(ilg, typeof(object), retType);
}
}
}
}
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context)
{
Expression basicFn = _fexpr.GenCode(RHC.Expression, objx, context);
basicFn = Expression.Convert(basicFn, typeof(IFn));
if (_isProtocol)
{
return(GenProto(rhc, objx, context, basicFn));
}
return(GenNonProto(rhc, objx, context, basicFn));
}
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 override void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
if (_excExpr == null)
{
ilg.Emit(OpCodes.Rethrow);
}
else
{
_excExpr.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(Exception));
ilg.Emit(OpCodes.Throw);
}
}
public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
{
Type t = _n.GetType();
if (t == typeof(int))
ilg.EmitLong((long)(int)_n);
else if (t == typeof(double))
ilg.EmitDouble((double)_n);
else if (t == typeof(long))
ilg.EmitLong((long)_n);
else
throw new ArgumentException("Unsupported Number type: " + _n.GetType().Name);
}
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);
}
void DoEmit(RHC rhc, ObjExpr objx, CljILGen ilg, bool emitUnboxed)
{
Label nullLabel = ilg.DefineLabel();
Label falseLabel = ilg.DefineLabel();
Label endLabel = ilg.DefineLabel();
Label trueLabel = ilg.DefineLabel();
GenContext.EmitDebugInfo(ilg, _sourceSpan);
if (_testExpr is StaticMethodExpr sme && sme.CanEmitIntrinsicPredicate())
{
sme.EmitIntrinsicPredicate(RHC.Expression, objx, ilg, falseLabel);
}
internal static void EmitArgsAsArray(IPersistentVector args, ObjExpr objx, CljILGen ilg)
{
ilg.EmitInt(args.count());
ilg.Emit(OpCodes.Newarr, typeof(Object));
for (int i = 0; i < args.count(); i++)
{
ilg.Emit(OpCodes.Dup);
ilg.EmitInt(i);
((Expr)args.nth(i)).Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Stelem_Ref);
}
}
public Expression GenCode(RHC rhc, ObjExpr objx, 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.GenCode(RHC.Statement, objx, context));
}
exprs.Add(LastExpr.GenCode(rhc, objx, context));
return(Expression.Block(exprs));
}
private static void EmitExpr(ObjExpr objx, CljILGen ilg, Expr expr, bool emitUnboxed)
{
MaybePrimitiveExpr mbe = expr as MaybePrimitiveExpr;
if (emitUnboxed && mbe != null)
{
mbe.EmitUnboxed(RHC.Expression, objx, ilg);
}
else
{
expr.Emit(RHC.Expression, objx, ilg);
}
}
public override void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
if (_excExpr == null)
{
ilg.Emit(OpCodes.Rethrow);
}
else
{
_excExpr.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(Exception));
ilg.Emit(OpCodes.Throw);
}
}
public override void EmitAssign(RHC rhc, ObjExpr objx, CljILGen ilg, Expr val)
{
GenContext.EmitDebugInfo(ilg, _spanMap);
val.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Dup);
HostExpr.EmitUnboxArg(objx, ilg, FieldType);
ilg.EmitPropertySet(_tinfo);
if (rhc == RHC.Statement)
{
ilg.Emit(OpCodes.Pop);
}
}
public override Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context)
{
if (_method != null)
{
Expression call = GenDlrForMethod(objx, context);
call = Compiler.MaybeAddDebugInfo(call, _spanMap, context.IsDebuggable);
return(call);
}
else
{
throw new InvalidOperationException("Unboxed emit of unknown member.");
}
}
// TODO: remove duplicate code between GenProtoLight and GenProtoFull
private Expression GenProtoLight(RHC rhc, ObjExpr objx, GenContext context, Expression fn)
{
Var v = ((VarExpr)_fexpr).Var;
Expr e = (Expr)_args.nth(0);
ParameterExpression targetParam = Expression.Parameter(typeof(Object), "target");
ParameterExpression targetTypeParam = Expression.Parameter(typeof(Type), "targetType");
ParameterExpression vpfnParam = Expression.Parameter(typeof(AFunction), "vpfn");
//ParameterExpression thisParam = objx.ThisParam;
Expression targetParamAssign = Expression.Assign(targetParam, Compiler.MaybeBox(e.GenCode(RHC.Expression, objx, context)));
Expression targetTypeParamAssign =
Expression.Assign(
targetTypeParam,
Expression.Call(null, Compiler.Method_Util_classOf, targetParam));
Expression vpfnParamAssign =
Expression.Assign(
vpfnParam,
Expression.Convert(Expression.Call(objx.GenVar(context, v), Compiler.Method_Var_getRawRoot), typeof(AFunction)));
if (_protocolOn == null)
{
return(Expression.Block(
new ParameterExpression[] { targetParam, targetTypeParam, vpfnParam },
targetParamAssign,
targetTypeParamAssign,
vpfnParamAssign,
GenerateArgsAndCall(rhc, objx, context, vpfnParam, targetParam)));
}
else
{
Expression[] args = new Expression[_args.count() - 1];
for (int i = 1; i < _args.count(); i++)
{
Expression bare = ((Expr)_args.nth(i)).GenCode(RHC.Expression, objx, context);
args[i - 1] = Compiler.MaybeBox(bare);
}
return(Expression.Block(
new ParameterExpression[] { targetParam, targetTypeParam, vpfnParam },
targetParamAssign,
targetTypeParamAssign,
Expression.Condition(
Expression.Not(Expression.TypeIs(targetParam, _protocolOn)),
Expression.Block(
vpfnParamAssign,
GenerateArgsAndCall(rhc, objx, context, vpfnParam, targetParam)),
Compiler.MaybeBox(Expression.Call(Expression.Convert(targetParam, _protocolOn), _onMethod, args)))));
}
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
objx.EmitVar(ilg, _var);
if ( _shadowsCoreMapping )
{
LocalBuilder locNs = ilg.DeclareLocal(typeof(Namespace));
GenContext.SetLocalName(locNs, "ns");
ilg.Emit(OpCodes.Dup);
ilg.EmitFieldGet(VarNsFI);
ilg.Emit(OpCodes.Stloc,locNs);
LocalBuilder locSym = ilg.DeclareLocal(typeof(Symbol));
GenContext.SetLocalName(locSym, "sym");
ilg.Emit(OpCodes.Dup);
ilg.EmitFieldGet(VarSymFI);
ilg.Emit(OpCodes.Stloc, locSym);
ilg.Emit(OpCodes.Ldloc, locNs);
ilg.Emit(OpCodes.Ldloc, locSym);
ilg.Emit(OpCodes.Call, NamespaceReferMI);
}
if (_isDynamic)
{
ilg.Emit(OpCodes.Call, Compiler.Method_Var_setDynamic0);
}
if (_meta != null)
{
if (_initProvided || true) //IncludesExplicitMetadata((MapExpr)_meta))
{
ilg.Emit(OpCodes.Dup);
_meta.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Castclass, typeof(IPersistentMap));
ilg.Emit(OpCodes.Call, Compiler.Method_Var_setMeta);
}
}
if (_initProvided)
{
ilg.Emit(OpCodes.Dup);
if (_init is FnExpr)
((FnExpr)_init).EmitForDefn(objx, ilg);
else
_init.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Call,Compiler.Method_Var_bindRoot);
}
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
void GenerateMethod(ObjExpr objx, GenContext context)
{
if (Prim != null)
{
GeneratePrimMethod(objx, context);
}
TypeBuilder tb = objx.TypeBuilder;
MethodBuilder mb = tb.DefineMethod(MethodName, MethodAttributes.ReuseSlot | MethodAttributes.Public | MethodAttributes.Virtual, ReturnType, ArgTypes);
//Console.Write("InMd: {0} {1}(", ReturnType.Name, MethodName);
//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);
if (ReturnType != StaticReturnType)
{
gen.Emit(OpCodes.Castclass, ReturnType);
}
gen.Emit(OpCodes.Ret);
if (IsExplicit)
{
tb.DefineMethodOverride(mb, _explicitMethodInfo);
}
}
// TODO: PRIORITY: IMPLEMENT protocolOn
private Expression GenProto(RHC rhc, ObjExpr objx, GenContext context, Expression fn)
{
switch (objx.FnMode)
{
case FnMode.Light:
return(GenProtoLight(rhc, objx, context, fn));
case FnMode.Full:
return(GenProtoFull(rhc, objx, context, fn));
default:
throw Util.UnreachableCode();
}
}
void DoEmit(RHC rhc, ObjExpr objx, CljILGen ilg, bool emitUnboxed)
{
List<LocalBuilder> locals = new List<LocalBuilder>();
for (int i = 0; i < _bindingInits.count(); i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
Type primType = Compiler.MaybePrimitiveType(bi.Init);
if (primType != null)
{
LocalBuilder local = ilg.DeclareLocal(primType);
locals.Add(local);
GenContext.SetLocalName(local, bi.Binding.Name);
bi.Binding.LocalVar = local;
((MaybePrimitiveExpr)bi.Init).EmitUnboxed(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Stloc, local);
}
else
{
LocalBuilder local = ilg.DeclareLocal(typeof(Object));
locals.Add(local);
GenContext.SetLocalName(local, bi.Binding.Name);
bi.Binding.LocalVar = local;
bi.Init.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Stloc, local);
}
}
Label loopLabel = ilg.DefineLabel();
ilg.MarkLabel(loopLabel);
try
{
if (_isLoop)
Var.pushThreadBindings(PersistentHashMap.create(Compiler.LoopLabelVar, loopLabel));
if (emitUnboxed)
((MaybePrimitiveExpr)_body).EmitUnboxed(rhc, objx, ilg);
else
_body.Emit(rhc, objx, ilg);
}
finally
{
if (_isLoop)
Var.popThreadBindings();
}
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
if (_coll is IPersistentList)
ilg.EmitFieldGet(ListEmptyFI);
else if (_coll is IPersistentVector)
ilg.EmitFieldGet(VectorEmptyFI);
else if (_coll is IPersistentMap)
ilg.EmitFieldGet(HashMapEmptyFI);
else if (_coll is IPersistentSet)
ilg.EmitFieldGet(HashSetEmptyFI);
else
throw new InvalidOperationException("Unknown collection type.");
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
public static void EmitByRefArg(HostArg ha, ObjExpr objx, CljILGen ilg)
{
if (ha.LocalBinding.IsArg)
{
ilg.Emit(OpCodes.Ldarga, ha.LocalBinding.Index);
}
else if (ha.LocalBinding.IsThis)
{
ilg.Emit(OpCodes.Ldarga, 0);
}
else
{
ilg.Emit(OpCodes.Ldloca, ha.LocalBinding.LocalVar);
}
}
public override void Emit(ObjExpr fn, TypeBuilder tb)
{
if (Prim != null)
{
DoEmitPrim(fn, tb);
}
else if (fn.IsStatic)
{
DoEmitStatic(fn, tb);
}
else
{
DoEmit(fn, tb);
}
}
internal void EmitIntrinsicPredicate(RHC rhc, ObjExpr objx, CljILGen ilg, Label falseLabel)
{
GenContext.EmitDebugInfo(ilg, _spanMap);
if (_method != null)
{
MethodExpr.EmitTypedArgs(objx, ilg, _method.GetParameters(), _args);
// JVM: clear locals
Intrinsics.EmitPred(_method, ilg, falseLabel);
}
else
{
throw new InvalidOperationException("Unboxed emit of unknown member");
}
}
//static readonly FieldInfo VectorEmptyFI = typeof(PersistentVector).GetField("EMPTY");
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
if (_coll is IPersistentList || _coll is LazySeq) // JVM does not include LazySeq test. I'm getting it in some places. LazySeq of 0 size got us here, we'll treat as an empty list
ilg.EmitFieldGet(ListEmptyFI);
else if (_coll is IPersistentVector)
ilg.EmitFieldGet(TupleEmptyFI);
else if (_coll is IPersistentMap)
ilg.EmitFieldGet(HashMapEmptyFI);
else if (_coll is IPersistentSet)
ilg.EmitFieldGet(HashSetEmptyFI);
else
throw new InvalidOperationException("Unknown collection type.");
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
{
_expr.Emit(RHC.Expression, objx, ilg);
// This corresponds to the most general case code in System.Linq.Expressions.Compiler.LambdaCompiler
Type opType = _expr.HasClrType && _expr.ClrType != null ? _expr.ClrType : typeof(object);
if (opType.IsValueType)
{
ilg.Emit(OpCodes.Box, opType);
}
ilg.Emit(OpCodes.Isinst, _t);
ilg.Emit(OpCodes.Ldnull);
ilg.Emit(OpCodes.Cgt_Un);
}
public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg)
{
_expr.Emit(RHC.Expression, objx, ilg);
// This corresponds to the most general case code in System.Linq.Expressions.Compiler.LambdaCompiler
Type opType = _expr.HasClrType && _expr.ClrType != null ? _expr.ClrType : typeof(object);
if (opType.IsValueType)
{
ilg.Emit(OpCodes.Box, opType);
}
ilg.Emit(OpCodes.Isinst, _t);
ilg.Emit(OpCodes.Ldnull);
ilg.Emit(OpCodes.Cgt_Un);
}
public Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, 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.GenCode(RHC.Statement, objx, context));
}
MaybePrimitiveExpr last = (MaybePrimitiveExpr)LastExpr;
exprs.Add(last.GenCodeUnboxed(rhc, objx, context));
return(Expression.Block(exprs));
}
void EmitThenForHashes(ObjExpr objx, CljILGen ilg, Expr test, Expr then, Label defaultLabel, bool emitUnboxed)
{
_expr.Emit(RHC.Expression, objx, ilg);
test.Emit(RHC.Expression, objx, ilg);
if (_testType == _hashIdentityKey)
{
ilg.Emit(OpCodes.Ceq);
ilg.Emit(OpCodes.Brfalse, defaultLabel);
}
else
{
ilg.Emit(OpCodes.Call, Compiler.Method_Util_equiv);
ilg.Emit(OpCodes.Brfalse, defaultLabel);
}
EmitExpr(objx, ilg, then, emitUnboxed);
}
void EmitProto(RHC rhc, ObjExpr objx, CljILGen ilg)
{
switch (objx.FnMode)
{
case FnMode.Light:
EmitProtoLight(rhc, objx, ilg);
break;
case FnMode.Full:
EmitProtoFull(rhc, objx, ilg);
break;
default:
throw Util.UnreachableCode();
}
}
public override Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context)
{
Expression target = _target.GenCode(RHC.Expression, objx, context);
if (_targetType != null && _tinfo != null)
{
Expression convTarget = Expression.Convert(target, _targetType);
Expression access = GenAccess(rhc, objx, convTarget);
access = Compiler.MaybeAddDebugInfo(access, _spanMap, context.IsDebuggable);
return(access);
}
else
{
throw new InvalidOperationException("Unboxed emit of unknown member.");
}
}
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 void EmitTargetExpression(ObjExpr objx, CljILGen ilg)
{
if (Compiler.CompileStubOrigClassVar.isBound && Compiler.CompileStubOrigClassVar.deref() != null && objx.TypeBlder != null)
{
ilg.Emit(OpCodes.Ldtoken, objx.TypeBlder);
}
else if (_type != null)
{
ilg.Emit(OpCodes.Ldtoken, _type);
}
else
{
throw new ArgumentException("Cannot generate type for NewExpr. Serious!");
}
ilg.Emit(OpCodes.Call, Compiler.Method_Type_GetTypeFromHandle);
}
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 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.");
}
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
GenContext.EmitDebugInfo(ilg, _spanMap);
if (_ctor != null)
EmitForMethod(rhc, objx, ilg);
else if (_isNoArgValueTypeCtor)
EmitForNoArgValueTypeCtor(rhc, objx, ilg);
else
{
EmitComplexCall(rhc, objx, ilg);
if (_type.IsValueType)
HostExpr.EmitBoxReturn(objx, ilg, _type);
}
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
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 void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
GenContext.EmitDebugInfo(ilg, _spanMap);
Type retType;
if (_method != null)
{
EmitForMethod(objx, ilg);
retType = _method.ReturnType;
}
else
{
EmitComplexCall(objx, ilg);
retType = typeof(object);
}
HostExpr.EmitBoxReturn(objx, ilg, retType);
if (rhc == RHC.Statement)
ilg.Emit(OpCodes.Pop);
}
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;
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
int n = _bindingInits.count();
// Define our locals
for (int i = 0; i < n; i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
LocalBuilder local = ilg.DeclareLocal(typeof(IFn));
bi.Binding.LocalVar = local;
ilg.Emit(OpCodes.Ldnull);
ilg.Emit(OpCodes.Stloc, local);
}
// Then initialize
IPersistentSet lbset = PersistentHashSet.EMPTY;
for (int i = 0; i < n; i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
lbset = (IPersistentSet)lbset.cons(bi.Binding);
bi.Init.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Stloc,bi.Binding.LocalVar);
}
for (int i = 0; i < n; i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
ObjExpr fe = (ObjExpr)bi.Init;
ilg.Emit(OpCodes.Ldloc, bi.Binding.LocalVar);
fe.EmitLetFnInits(ilg, bi.Binding.LocalVar, objx, lbset);
}
_body.Emit(rhc, objx, ilg);
}
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
{
if (_catchExprs.count() == 0 && _finallyExpr == null)
{
// degenerate case
_tryExpr.Emit(rhc, objx, ilg);
return;
}
LocalBuilder retLocal = ilg.DeclareLocal(typeof(Object));
ilg.BeginExceptionBlock();
_tryExpr.Emit(rhc, objx, ilg);
if (rhc != RHC.Statement)
ilg.Emit(OpCodes.Stloc, retLocal);
for (int i = 0; i < _catchExprs.count(); i++)
{
CatchClause clause = (CatchClause)_catchExprs.nth(i);
ilg.BeginCatchBlock(clause.Type);
// Exception should be on the stack. Put in clause local
clause.Lb.LocalVar = ilg.DeclareLocal(clause.Type);
ilg.Emit(OpCodes.Stloc, clause.Lb.LocalVar);
clause.Handler.Emit(rhc, objx, ilg);
if (clause.Handler.HasNormalExit() && rhc != RHC.Statement)
ilg.Emit(OpCodes.Stloc, retLocal);
}
if (_finallyExpr != null)
{
ilg.BeginFinallyBlock();
_finallyExpr.Emit(RHC.Statement, objx, ilg);
}
ilg.EndExceptionBlock();
if (rhc != RHC.Statement)
ilg.Emit(OpCodes.Ldloc, retLocal);
}
public Expression GenCode(RHC rhc, ObjExpr objx, 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.
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);
Expression valExpr = ((Expr)_args.nth(i)).GenCode(RHC.Expression, objx, 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)));
finalAssigns.Add(Expression.Assign(b.ParamExpression, tempVar));
}
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);
}