public override void Emit(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); HostExpr.EmitBoxReturn(objx, ilg, FieldType); } else { // We could convert this to a dynamic call-site _target.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Ldstr, _memberName); ilg.Emit(OpCodes.Call, Compiler.Method_Reflector_GetInstanceFieldOrProperty); } if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public override void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { Type targetType = _targetType; //Type stubType = Compiler.CompileStubOrigClassVar.isBound ? (Type)Compiler.CompileStubOrigClassVar.deref() : null; //if (_targetType == stubType) // targetType = objx.BaseType; GenContext.EmitDebugInfo(ilg, _spanMap); if (targetType != null && _tinfo != null) { _target.Emit(RHC.Expression, objx, ilg); MethodExpr.EmitPrepForCall(ilg, typeof(object), FieldDeclaringType); EmitGet(ilg); HostExpr.EmitBoxReturn(objx, ilg, FieldType); } else { // TODO: convert to dynamic? _target.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Ldstr, _fieldName); ilg.Emit(OpCodes.Call, Compiler.Method_Reflector_GetInstanceFieldOrProperty); } if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { // See MethodExpr.EmitComplexCall to see why this is so complicated // Build the parameter list List <ParameterExpression> paramExprs = new List <ParameterExpression>(); List <Type> paramTypes = new List <Type>(); Type paramType = _target.HasClrType && _target.ClrType != null && _target.ClrType.IsPrimitive ? _target.ClrType : typeof(object); ParameterExpression param = Expression.Parameter(paramType); paramExprs.Add(param); paramTypes.Add(paramType); // Build dynamic call and lambda Type returnType = HasClrType ? ClrType : typeof(object); GetMemberBinder binder = new ClojureGetZeroArityMemberBinder(ClojureContext.Default, _memberName, false); DynamicExpression dyn = Expression.Dynamic(binder, returnType, paramExprs); LambdaExpression lambda; Type delType; MethodBuilder mbLambda; MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_" + _memberName + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out lambda, out delType, out mbLambda); // Emit target + args (no args, actually) _target.Emit(RHC.Expression, objx, ilg); MethodExpr.EmitDynamicCallPostlude(lambda, delType, mbLambda, ilg); }
internal void EmitAssignLocal(CljILGen ilg, LocalBinding lb, Expr val) { if (!IsMutable(lb)) throw new ArgumentException("Cannot assign to non-mutable: ", lb.Name); FieldBuilder fb = null; bool hasField = ClosedOverFieldsMap.TryGetValue(lb, out fb); ilg.Emit(OpCodes.Ldarg_0); // this Type primt = lb.PrimitiveType; if (primt != null) { MaybePrimitiveExpr mbe = val as MaybePrimitiveExpr; if (!(mbe != null && mbe.CanEmitPrimitive)) throw new ArgumentException("Must assign primitive to primitive mutable", lb.Name); mbe.EmitUnboxed(RHC.Expression, this, ilg); } else { val.Emit(RHC.Expression, this, ilg); } if (hasField) { ilg.MaybeEmitVolatileOp(IsVolatile(lb)); ilg.Emit(OpCodes.Stfld, fb); } else ilg.Emit(OpCodes.Stloc, lb.LocalVar); }
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 void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { if (_variadic) { ParameterInfo[] pinfos = _method.GetParameters(); for (int i = 0; i < pinfos.Length - 1; i++) { Expr e = (Expr)_args.nth(i); if (Compiler.MaybePrimitiveType(e) == pinfos[i].ParameterType) { ((MaybePrimitiveExpr)e).EmitUnboxed(RHC.Expression, objx, ilg); } else { e.Emit(RHC.Expression, objx, ilg); HostExpr.EmitUnboxArg(objx, ilg, pinfos[i].ParameterType); } } IPersistentVector restArgs = RT.subvec(_args, pinfos.Length - 1, _args.count()); MethodExpr.EmitArgsAsArray(restArgs, objx, ilg); ilg.EmitCall(Compiler.Method_ArraySeq_create); } else { MethodExpr.EmitTypedArgs(objx, ilg, _method.GetParameters(), _args); } ilg.EmitCall(_method); }
void EmitArgsAndCall(int firstArgToEmit, RHC rhc, ObjExpr objx, CljILGen ilg) { for (int i = firstArgToEmit; i < Math.Min(Compiler.MaxPositionalArity, _args.count()); i++) { Expr e = (Expr)_args.nth(i); e.Emit(RHC.Expression, objx, ilg); } if (_args.count() > Compiler.MaxPositionalArity) { IPersistentVector restArgs = PersistentVector.EMPTY; for (int i = Compiler.MaxPositionalArity; i < _args.count(); i++) { restArgs = restArgs.cons(_args.nth(i)); } MethodExpr.EmitArgsAsArray(restArgs, objx, ilg); } //if ( rhc == RHC.Return ) //{ // ObjMethod2 method = (ObjMethod2)Compiler.MethodVar.deref(); // method.EmitClearLocals(context); //} MethodInfo mi = Compiler.Methods_IFn_invoke[Math.Min(Compiler.MaxPositionalArity + 1, _args.count())]; ilg.Emit(OpCodes.Callvirt, mi); }
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 EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { _expr.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Isinst, _t); ilg.Emit(OpCodes.Ldnull); ilg.Emit(OpCodes.Cgt_Un); }
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) { 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) { 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 expr) { expr.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 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 (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 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); } }
private static void EmitExpr(ObjExpr objx, CljILGen ilg, Expr expr, bool emitUnboxed) { if (emitUnboxed && expr is MaybePrimitiveExpr mbe) { mbe.EmitUnboxed(RHC.Expression, objx, ilg); } else { expr.Emit(RHC.Expression, objx, ilg); } }
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 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); } }
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 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 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); if (_targetType != null && _tinfo != null) { _target.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Castclass, _targetType); val.Emit(RHC.Expression, objx, ilg); LocalBuilder tmp = ilg.DeclareLocal(typeof(object)); GenContext.SetLocalName(tmp, "valTemp"); ilg.Emit(OpCodes.Dup); ilg.Emit(OpCodes.Stloc, tmp); if (FieldType.IsValueType) { HostExpr.EmitUnboxArg(objx, ilg, FieldType); } else { ilg.Emit(OpCodes.Castclass, FieldType); } EmitSet(ilg); ilg.Emit(OpCodes.Ldloc, tmp); } else { _target.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Ldstr, _memberName); val.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Call, Compiler.Method_Reflector_SetInstanceFieldOrProperty); } if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
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); }
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); }
private void EmitThenForInts(ObjExpr objx, CljILGen ilg, Type exprType, Expr test, Expr then, Label defaultLabel, bool emitUnboxed) { if (exprType == null) { _expr.Emit(RHC.Expression, objx, ilg); test.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Call, Compiler.Method_Util_equiv); ilg.Emit(OpCodes.Brfalse, defaultLabel); EmitExpr(objx, ilg, then, emitUnboxed); } else if (exprType == typeof(long)) { ((NumberExpr)test).EmitUnboxed(RHC.Expression, objx, ilg); _expr.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Ceq); ilg.Emit(OpCodes.Brfalse, defaultLabel); EmitExpr(objx, ilg, then, emitUnboxed); } else if (exprType == typeof(int) || exprType == typeof(short) || exprType == typeof(byte) || exprType == typeof(ulong) || exprType == typeof(uint) || exprType == typeof(ushort) || exprType == typeof(sbyte)) { if (IsShiftMasked) { ((NumberExpr)test).EmitUnboxed(RHC.Expression, objx, ilg); _expr.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_I8); ilg.Emit(OpCodes.Ceq); ilg.Emit(OpCodes.Brfalse, defaultLabel); EmitExpr(objx, ilg, then, emitUnboxed); } // else direct match EmitExpr(objx, ilg, then, emitUnboxed); } else { ilg.Emit(OpCodes.Br, defaultLabel); } }
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 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 static void EmitTypedArg(ObjExpr objx, CljILGen ilg, Type paramType, Expr arg) { Type primt = Compiler.MaybePrimitiveType(arg); MaybePrimitiveExpr mpe = arg as MaybePrimitiveExpr; if (primt == paramType) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); } else if (primt == typeof(int) && paramType == typeof(long)) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_I8); } else if (primt == typeof(long) && paramType == typeof(int)) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); if (RT.booleanCast(RT.UncheckedMathVar.deref())) { ilg.Emit(OpCodes.Call, Compiler.Method_RT_uncheckedIntCast_long); } else { ilg.Emit(OpCodes.Call, Compiler.Method_RT_intCast_long); } } else if (primt == typeof(float) && paramType == typeof(double)) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_R8); } else if (primt == typeof(double) && paramType == typeof(float)) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_R4); } else { arg.Emit(RHC.Expression, objx, ilg); HostExpr.EmitUnboxArg(objx, ilg, paramType); } }
public virtual void Emit(ObjExpr fn, TypeBuilder tb) { MethodBuilder mb = tb.DefineMethod(GetMethodName(), MethodAttributes.Public, GetReturnType(), GetArgTypes()); 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(); } }
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 static void EmitTypedArg(ObjExpr objx, CljILGen ilg, Type paramType, Expr arg) { Type primt = Compiler.MaybePrimitiveType(arg); MaybePrimitiveExpr mpe = arg as MaybePrimitiveExpr; if (primt == paramType) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); } else if (primt == typeof(int) && paramType == typeof(long)) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_I8); } else if (primt == typeof(long) && paramType == typeof(int)) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); if (RT.booleanCast(RT.UncheckedMathVar.deref())) ilg.Emit(OpCodes.Call,Compiler.Method_RT_uncheckedIntCast_long); else ilg.Emit(OpCodes.Call,Compiler.Method_RT_intCast_long); } else if (primt == typeof(float) && paramType == typeof(double)) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_R8); } else if (primt == typeof(double) && paramType == typeof(float)) { mpe.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_R4); } else { arg.Emit(RHC.Expression, objx, ilg); HostExpr.EmitUnboxArg(objx, ilg, paramType); } }
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { Label?loopLabel = (Label)Compiler.LoopLabelVar.deref(); if (loopLabel == null) { throw new InvalidOperationException("Recur not in proper context."); } { for (int i = 0; i < _loopLocals.count(); i++) { LocalBinding lb = (LocalBinding)_loopLocals.nth(i); Expr arg = (Expr)_args.nth(i); Type primt = lb.PrimitiveType; if (primt != null) { MaybePrimitiveExpr mpeArg = arg as MaybePrimitiveExpr; Type pt = Compiler.MaybePrimitiveType(arg); if (pt == primt) { mpeArg.EmitUnboxed(RHC.Expression, objx, ilg); } else if (primt == typeof(long) && pt == typeof(int)) { mpeArg.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_I8); } else if (primt == typeof(double) && pt == typeof(float)) { mpeArg.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_R8); } else if (primt == typeof(int) && pt == typeof(long)) { mpeArg.EmitUnboxed(RHC.Expression, objx, ilg); ilg.EmitCall(Compiler.Method_RT_intCast_long); } else if (primt == typeof(float) && pt == typeof(double)) { mpeArg.EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Conv_R4); } else { throw new ArgumentException(String.Format( "{0}:{1} recur arg for primitive local: {2} is not matching primitive, had: {3}, needed {4}", _source, _spanMap != null ? (int)_spanMap.valAt(RT.StartLineKey, 0) : 0, lb.Name, (arg.HasClrType ? arg.ClrType.Name : "Object"), primt.Name)); } } else { arg.Emit(RHC.Expression, objx, ilg); } } } for (int i = _loopLocals.count() - 1; i >= 0; i--) { LocalBinding lb = (LocalBinding)_loopLocals.nth(i); //Type primt = lb.PrimitiveType; if (lb.IsArg) { //ilg.Emit(OpCodes.Starg, lb.Index - (objx.IsStatic ? 0 : 1)); ilg.EmitStoreArg(lb.Index); } else { ilg.Emit(OpCodes.Stloc, lb.LocalVar); } } ilg.Emit(OpCodes.Br, loopLabel.Value); }
protected override void EmitTargetExpression(ObjExpr objx, CljILGen ilg) { _target.Emit(RHC.Expression, objx, ilg); }
internal void EmitAssignLocal(CljILGen ilg, LocalBinding lb, Expr val) { if (!IsMutable(lb)) throw new ArgumentException("Cannot assign to non-mutable: ", lb.Name); FieldBuilder fb = null; bool hasField = _closedOverFieldsMap.TryGetValue(lb, out fb); ilg.Emit(OpCodes.Ldarg_0); // this Type primt = lb.PrimitiveType; if (primt != null) { MaybePrimitiveExpr mbe = val as MaybePrimitiveExpr; if (!(mbe != null && mbe.CanEmitPrimitive)) throw new ArgumentException("Must assign primitive to primitive mutable", lb.Name); mbe.EmitUnboxed(RHC.Expression, this, ilg); } else { val.Emit(RHC.Expression, this, ilg); } if (hasField) { ilg.MaybeEmitVolatileOp(IsVolatile(lb)); ilg.Emit(OpCodes.Stfld, fb); } else ilg.Emit(OpCodes.Stloc, lb.LocalVar); }
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); }
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); } } }