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 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 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 ParserContext SetRhc(RHC rhc) { if (_rhc == rhc) return this; return new ParserContext(rhc, _isAssignContext); }
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 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 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 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; }
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 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 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 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 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 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); }
//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 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 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 GenAssign(RHC rhc, ObjExpr objx, GenContext context, Expr val) { return(Expression.Block( objx.GenAssignLocal(context, _b, val), objx.GenLocal(context, _b))); }
public override void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { _target.Emit(RHC.Expression, objx, ilg); ilg.EmitCall(Compiler.Method_Monitor_Exit); Compiler.NilExprInstance.Emit(rhc, objx, ilg); }
protected override Expression GenAccess(RHC rhc, ObjExpr objx, Expression target) { return(Expression.Property(target, _tinfo)); }
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { DoEmit(rhc, objx, ilg, false); }
void EmitProto(RHC rhc, ObjExpr objx, CljILGen ilg) { Label onLabel = ilg.DefineLabel(); Label callLabel = ilg.DefineLabel(); Label endLabel = ilg.DefineLabel(); Var v = ((VarExpr)_fexpr).Var; Expr e = (Expr)_args.nth(0); e.Emit(RHC.Expression, objx, ilg); // target ilg.Emit(OpCodes.Dup); // target, target LocalBuilder targetTemp = ilg.DeclareLocal(typeof(Object)); GenContext.SetLocalName(targetTemp, "target"); ilg.Emit(OpCodes.Stloc, targetTemp); // target ilg.Emit(OpCodes.Call, Compiler.Method_Util_classOf); // class ilg.EmitFieldGet(objx.CachedTypeField(_siteIndex)); // class, cached-class ilg.Emit(OpCodes.Beq, callLabel); // if (_protocolOn != null) { ilg.Emit(OpCodes.Ldloc, targetTemp); // target ilg.Emit(OpCodes.Isinst, _protocolOn); // null or target ilg.Emit(OpCodes.Ldnull); // (null or target), null ilg.Emit(OpCodes.Cgt_Un); // (0 or 1) ilg.Emit(OpCodes.Brtrue, onLabel); } ilg.Emit(OpCodes.Ldloc, targetTemp); // target ilg.Emit(OpCodes.Call, Compiler.Method_Util_classOf); // class LocalBuilder typeTemp = ilg.DeclareLocal(typeof(Type)); GenContext.SetLocalName(typeTemp, "type"); ilg.Emit(OpCodes.Stloc, typeTemp); // (typeType <= class) ilg.Emit(OpCodes.Ldloc, typeTemp); // this, class ilg.EmitFieldSet(objx.CachedTypeField(_siteIndex)); // ilg.MarkLabel(callLabel); objx.EmitVar(ilg, v); // var ilg.Emit(OpCodes.Call, Compiler.Method_Var_getRawRoot); // proto-fn ilg.Emit(OpCodes.Castclass, typeof(AFunction)); ilg.Emit(OpCodes.Ldloc, targetTemp); // proto-fn, target EmitArgsAndCall(1, rhc, objx, ilg); ilg.Emit(OpCodes.Br, endLabel); ilg.MarkLabel(onLabel); ilg.Emit(OpCodes.Ldloc, targetTemp); // target if (_protocolOn != null) { ilg.Emit(OpCodes.Castclass, _protocolOn); MethodExpr.EmitTypedArgs(objx, ilg, _onMethod.GetParameters(), RT.subvec(_args, 1, _args.count())); //if (rhc == RHC.Return) //{ // ObjMethod2 method = (ObjMethod)Compiler.MethodVar.deref(); // method.EmitClearLocals(context); //} ilg.Emit(OpCodes.Callvirt, _onMethod); HostExpr.EmitBoxReturn(objx, ilg, _onMethod.ReturnType); } ilg.MarkLabel(endLabel); }
public abstract Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context);
public Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context) { throw new InvalidOperationException("Can't emit"); }
public abstract void EmitAssign(RHC rhc, ObjExpr objx, CljILGen ilg, Expr val);
public override void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { _excExpr.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Castclass, typeof(Exception)); ilg.Emit(OpCodes.Throw); }
public void DoEmit(RHC rhc, ObjExpr objx, CljILGen ilg, bool emitUnboxed) { GenContext.EmitDebugInfo(ilg, _sourceSpan); Label defaultLabel = ilg.DefineLabel(); Label endLabel = ilg.DefineLabel(); SortedDictionary <int, Label> labels = new SortedDictionary <int, Label>(); foreach (int i in _tests.Keys) { labels[i] = ilg.DefineLabel(); } Type primExprType = Compiler.MaybePrimitiveType(_expr); if (_testType == _intKey) { EmitExprForInts(objx, ilg, primExprType, defaultLabel); } else { EmitExprForHashes(objx, ilg); } if (_switchType == _sparseKey) { Label[] la = labels.Values.ToArray <Label>(); ilg.Emit(OpCodes.Switch, la); ilg.Emit(OpCodes.Br, defaultLabel); } else { Label[] la = new Label[(_high - _low) + 1]; for (int i = _low; i <= _high; i++) { la[i - _low] = labels.ContainsKey(i) ? labels[i] : defaultLabel; } ilg.EmitInt(_low); ilg.Emit(OpCodes.Sub); ilg.Emit(OpCodes.Switch, la); ilg.Emit(OpCodes.Br, defaultLabel); } foreach (int i in labels.Keys) { ilg.MarkLabel(labels[i]); if (_testType == _intKey) { EmitThenForInts(objx, ilg, primExprType, _tests[i], _thens[i], defaultLabel, emitUnboxed); } else if ((bool)RT.contains(_skipCheck, i)) { EmitExpr(objx, ilg, _thens[i], emitUnboxed); } else { EmitThenForHashes(objx, ilg, _tests[i], _thens[i], defaultLabel, emitUnboxed); } if (_thens[i].HasNormalExit()) { ilg.Emit(OpCodes.Br, endLabel); } } ilg.MarkLabel(defaultLabel); EmitExpr(objx, ilg, _defaultExpr, emitUnboxed); ilg.MarkLabel(endLabel); if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { throw new InvalidOperationException("Can't emit"); }
public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { objx.EmitUnboxedLocal(ilg, _b); }
public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context) { // Java: fn.emitConstant(gen,id) //return Expression.Constant(_v); return(objx.GenConstant(context, _id, _v)); }
public ParserContext(RHC rhc, bool isAssignContext) { _rhc = rhc; _isAssignContext = isAssignContext; }
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); //if (rhc != RHC.Statement) // ilg.Emit(OpCodes.Ldnull); }
public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context) { return(Compiler.MaybeBox(GenCodeUnboxed(rhc, objx, context))); }
public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context) { return(objx.GenConstant(context, _id, _n)); }
// TODO: See if it is worth removing the code duplication with MethodExp.GenDlr. private Expression GenerateComplexCall(RHC rhc, ObjExpr objx, GenContext context) { Expression call; Expression target = GenTargetExpression(objx, context); List <Expression> exprs = new List <Expression>(_args.Count); List <ParameterExpression> sbParams = new List <ParameterExpression>(); List <Expression> sbInits = new List <Expression>(); List <Expression> sbTransfers = new List <Expression>(); MethodExpr.GenerateComplexArgList(objx, context, _args, out exprs, out sbParams, out sbInits, out sbTransfers); Expression[] argExprs = ClrExtensions.ArrayInsert <Expression>(target, exprs); Type returnType = this.ClrType; Type stubType = Compiler.CompileStubOrigClassVar.isBound ? (Type)Compiler.CompileStubOrigClassVar.deref() : null; if (returnType == stubType) { returnType = objx.BaseType; } // TODO: get rid of Default CreateInstanceBinder binder = new ClojureCreateInstanceBinder(ClojureContext.Default, _args.Count); DynamicExpression dyn = Expression.Dynamic(binder, typeof(object), argExprs); // I'd like to use returnType in place of typeof(object) in the previous, // But I can't override ReturnType in DefaultCreateInstanceBinder and this causes an error. // Look for the conversion below. //if (context.Mode == CompilerMode.File) if (context.DynInitHelper != null) { call = context.DynInitHelper.ReduceDyn(dyn); } else { call = dyn; } call = Expression.Convert(call, returnType); if (sbParams.Count > 0) { // We have ref/out params. Construct the complicated call; ParameterExpression callValParam = Expression.Parameter(returnType, "__callVal"); ParameterExpression[] allParams = ClrExtensions.ArrayInsert <ParameterExpression>(callValParam, sbParams); call = Expression.Block( returnType, allParams, Expression.Block(sbInits), Expression.Assign(callValParam, call), Expression.Block(sbTransfers), callValParam); } return(call); }
public void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { DoEmit(rhc, objx, ilg, true); }
public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { GenContext.EmitDebugInfo(ilg, _spanMap); ilg.EmitPropertyGet(_tinfo); }
protected abstract Expression GenAccess(RHC rhc, ObjExpr objx, Expression target);
public Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context) { return(GenCode(rhc, objx, context, true)); }
public Expression GenCodeUnboxed(RHC rhc, ObjExpr objx, GenContext context) { return(objx.GenUnboxedLocal(context, _b)); }
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { Label endLabel = ilg.DefineLabel(); Label faultLabel = ilg.DefineLabel(); GenContext.EmitDebugInfo(ilg, _spanMap); LocalBuilder thunkLoc = ilg.DeclareLocal(typeof(ILookupThunk)); LocalBuilder targetLoc = ilg.DeclareLocal(typeof(Object)); LocalBuilder resultLoc = ilg.DeclareLocal(typeof(Object)); GenContext.SetLocalName(thunkLoc, "thunk"); GenContext.SetLocalName(targetLoc, "target"); GenContext.SetLocalName(resultLoc, "result"); // TODO: Debug info // pseudo-code: // ILookupThunk thunk = objclass.ThunkField(i) // object target = ...code... // object val = thunk.get(target) // if ( val != thunk ) // return val // else // KeywordLookupSite site = objclass.SiteField(i) // thunk = site.fault(target) // objclass.ThunkField(i) = thunk // val = thunk.get(target) // return val ilg.EmitFieldGet(objx.ThunkField(_siteIndex)); // thunk ilg.Emit(OpCodes.Stloc, thunkLoc); // (thunkLoc <= thunk) _target.Emit(RHC.Expression, objx, ilg); // target ilg.Emit(OpCodes.Stloc, targetLoc); // (targetLoc <= target) ilg.Emit(OpCodes.Ldloc, thunkLoc); ilg.Emit(OpCodes.Ldloc, targetLoc); ilg.EmitCall(Compiler.Method_ILookupThunk_get); // result ilg.Emit(OpCodes.Stloc, resultLoc); // (resultLoc <= result) ilg.Emit(OpCodes.Ldloc, thunkLoc); ilg.Emit(OpCodes.Ldloc, resultLoc); ilg.Emit(OpCodes.Beq, faultLabel); ilg.Emit(OpCodes.Ldloc, resultLoc); // result ilg.Emit(OpCodes.Br, endLabel); ilg.MarkLabel(faultLabel); ilg.EmitFieldGet(objx.KeywordLookupSiteField(_siteIndex)); // site ilg.Emit(OpCodes.Ldloc, targetLoc); // site, target ilg.EmitCall(Compiler.Method_ILookupSite_fault); // new-thunk ilg.Emit(OpCodes.Dup); // new-thunk, new-thunk ilg.EmitFieldSet(objx.ThunkField(_siteIndex)); // new-thunk ilg.Emit(OpCodes.Ldloc, targetLoc); // new-thunk, target ilg.EmitCall(Compiler.Method_ILookupThunk_get); // result ilg.MarkLabel(endLabel); // result if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context) { return(GenCode(rhc, objx, context, false)); }
public abstract void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg);
public Expression GenCode(RHC rhc, ObjExpr objx, GenContext context) { return(Expression.Empty()); }
private void EmitComplexCall(RHC rhc, ObjExpr objx, CljILGen ilg) { // See the notes on MethodExpr.EmitComplexCall on why this is so complicated List <ParameterExpression> paramExprs = new List <ParameterExpression>(_args.Count + 1); List <Type> paramTypes = new List <Type>(_args.Count + 1); paramExprs.Add(Expression.Parameter(typeof(Type))); paramTypes.Add(typeof(Type)); int i = 0; foreach (HostArg ha in _args) { i++; Expr e = ha.ArgExpr; Type argType = e.HasClrType && e.ClrType != null && e.ClrType.IsPrimitive ? e.ClrType : typeof(object); switch (ha.ParamType) { case HostArg.ParameterType.ByRef: { Type byRefType = argType.MakeByRefType(); paramExprs.Add(Expression.Parameter(byRefType, ha.LocalBinding.Name)); paramTypes.Add(byRefType); break; } case HostArg.ParameterType.Standard: if (argType.IsPrimitive && ha.ArgExpr is MaybePrimitiveExpr) { paramExprs.Add(Expression.Parameter(argType, ha.LocalBinding != null ? ha.LocalBinding.Name : "__temp_" + i)); paramTypes.Add(argType); } else { paramExprs.Add(Expression.Parameter(typeof(object), ha.LocalBinding != null ? ha.LocalBinding.Name : "__temp_" + i)); paramTypes.Add(typeof(object)); } break; default: throw Util.UnreachableCode(); } } // Build dynamic call and lambda Type returnType = HasClrType ? ClrType : typeof(object); CreateInstanceBinder binder = new ClojureCreateInstanceBinder(ClojureContext.Default, _args.Count); #if CLR2 // Not covariant. Sigh. List <Expression> paramsAsExprs = new List <Expression>(paramExprs.Count); paramsAsExprs.AddRange(paramExprs.ToArray()); DynamicExpression dyn = Expression.Dynamic(binder, typeof(object), paramsAsExprs); #else DynamicExpression dyn = Expression.Dynamic(binder, typeof(object), paramExprs); #endif LambdaExpression lambda; Type delType; MethodBuilder mbLambda; MethodExpr.EmitDynamicCallPreamble(dyn, _spanMap, "__interop_ctor_" + RT.nextID(), returnType, paramExprs, paramTypes.ToArray(), ilg, out lambda, out delType, out mbLambda); // Emit target + args EmitTargetExpression(objx, ilg); i = 0; foreach (HostArg ha in _args) { i++; Expr e = ha.ArgExpr; Type argType = e.HasClrType && e.ClrType != null && e.ClrType.IsPrimitive ? e.ClrType : typeof(object); switch (ha.ParamType) { case HostArg.ParameterType.ByRef: MethodExpr.EmitByRefArg(ha, objx, ilg); break; case HostArg.ParameterType.Standard: if (argType.IsPrimitive && ha.ArgExpr is MaybePrimitiveExpr) { ((MaybePrimitiveExpr)ha.ArgExpr).EmitUnboxed(RHC.Expression, objx, ilg); } else { ha.ArgExpr.Emit(RHC.Expression, objx, ilg); } break; default: throw Util.UnreachableCode(); } } MethodExpr.EmitDynamicCallPostlude(lambda, delType, mbLambda, ilg); }
public override Expression GenCode(RHC rhc, ObjExpr objx, GenContext context) { return(HostExpr.GenBoxReturn(GenCodeUnboxed(rhc, objx, context), FieldType, objx, context)); }
public ParserContext(RHC rhc) { _rhc = rhc; _isAssignContext = false; }