public override void Emit(CodeGen cg) { cg.EmitPosition(start, end); if (cg.printExprStmts) { // emit & print expression. cg.EmitSystemState(); expr.Emit(cg); Label noSet = cg.DefineLabel(); // only set _ if the last expression is not None. cg.Emit(OpCodes.Dup); cg.Emit(OpCodes.Ldnull); cg.Emit(OpCodes.Beq, noSet); cg.Emit(OpCodes.Dup); cg.EmitSet(Name.Make("_")); cg.MarkLabel(noSet); // finally emit the call to print the value. cg.EmitCall(typeof(Ops), "PrintNotNoneRepr", new Type[] { typeof(SystemState), typeof(object) }); } else { // expression needs to be emitted incase it has side-effects. expr.Emit(cg); cg.Emit(OpCodes.Pop); } }
public override void Emit(CodeGen cg) { cg.EmitCallerContext(); target.Emit(cg); cg.EmitSymbolId(name.GetString()); cg.EmitCall(typeof(Ops), "GetAttr"); //, new Type[] { typeof(object), typeof(SymbolId) }); }
public override void Emit(CodeGen cg) { Label eol = cg.DefineLabel(); Label breakTarget = cg.DefineLabel(); Label continueTarget = cg.DefineLabel(); cg.EmitPosition(start, header); list.Emit(cg); cg.EmitCall(typeof(Ops), "GetEnumerator"); Slot iter; if (cg.IsGenerator()) { iter = cg.Names.GetTempSlot("iter", typeof(IEnumerator)); } else { iter = cg.GetLocalTmp(typeof(IEnumerator)); } iter.EmitSet(cg); cg.MarkLabel(continueTarget); iter.EmitGet(cg); cg.EmitCall(typeof(IEnumerator), "MoveNext"); cg.Emit(OpCodes.Brfalse, eol); cg.PushTargets(breakTarget, continueTarget); iter.EmitGet(cg); cg.EmitCall(typeof(IEnumerator).GetProperty("Current").GetGetMethod()); lhs.EmitSet(cg); body.Emit(cg); cg.Emit(OpCodes.Br, continueTarget); cg.PopTargets(); cg.MarkLabel(eol); if (elseStmt != null) { elseStmt.Emit(cg); } cg.MarkLabel(breakTarget); if (cg.IsGenerator()) { //!!! need to free my temp } else { cg.FreeLocalTmp(iter); } }
public override void Emit(CodeGen cg) { cg.EmitPosition(start, end); // if lhs is a complex expression (eg foo[x] or foo.bar) // then it's EmitSet needs to do the right thing. lhs.Emit(cg); rhs.Emit(cg); op.EmitInPlace(cg); lhs.EmitSet(cg); }
public override void Emit(CodeGen cg) { cg.EmitPosition(start, end); rhs.Emit(cg); for (int i = 0; i < lhs.Length; i++) { if (i < lhs.Length - 1) { cg.Emit(OpCodes.Dup); } lhs[i].EmitSet(cg); } }
public override void Emit(CodeGen cg) { left.Emit(cg); if (IsComparision() && IsComparision(right)) { FinishCompare(cg); } else { right.Emit(cg); op.Emit(cg); } }
public override void Emit(CodeGen cg) { left.Emit(cg); cg.Emit(OpCodes.Dup); cg.EmitCall(typeof(Ops), "IsTrue"); //cg.emitNonzero(left); Label l = cg.DefineLabel(); cg.Emit(OpCodes.Brtrue, l); cg.Emit(OpCodes.Pop); right.Emit(cg); cg.MarkLabel(l); }
public override void Emit(CodeGen cg) { cg.EmitPosition(start, end); string suffix = ""; if (dest != null) { suffix = "WithDest"; } if (exprs.Length == 0) { cg.EmitSystemState(); if (dest != null) { dest.Emit(cg); } cg.EmitCall(typeof(Ops), "PrintNewline" + suffix); } for (int i = 0; i < exprs.Length; i++) { cg.EmitSystemState(); if (dest != null) { dest.Emit(cg); //!!! need to put in a temp } exprs[i].Emit(cg); if (i < exprs.Length - 1 || trailingComma) { cg.EmitCall(typeof(Ops), "PrintComma" + suffix); } else { cg.EmitCall(typeof(Ops), "Print" + suffix); } } }
public override void Emit(CodeGen cg) { cg.EmitPosition(start, end); cg.EmitCallerContext(); code.Emit(cg); if (locals == null) { if (globals == null) { // pass in the current module's globals. cg.EmitCall(typeof(Ops), "Exec", new Type[] { typeof(ICallerContext), typeof(object), }); } else { // user provided only globals, this gets used as both dictionarys. globals.Emit(cg); cg.EmitCastFromObject(typeof(IDictionary <object, object>)); globals.Emit(cg); cg.EmitCastFromObject(typeof(IDictionary <object, object>)); cg.EmitCall(typeof(Ops), "Exec", new Type[] { typeof(ICallerContext), typeof(object), typeof(System.Collections.Generic.IDictionary <object, object>), typeof(System.Collections.Generic.IDictionary <object, object>) }); } } else { // locals is last so both are defined locals.Emit(cg); cg.EmitCastFromObject(typeof(System.Collections.Generic.IDictionary <object, object>)); globals.Emit(cg); cg.EmitCastFromObject(typeof(System.Collections.Generic.IDictionary <object, object>)); cg.EmitCall(typeof(Ops), "Exec", new Type[] { typeof(ICallerContext), typeof(object), typeof(System.Collections.Generic.IDictionary <object, object>), typeof(System.Collections.Generic.IDictionary <object, object>) }); } }
public override void Emit(CodeGen cg) { expr.Emit(cg); cg.EmitCall(op.target.Method); }
public override void Emit(CodeGen cg) { expr.Emit(cg); }
public override void Emit(CodeGen cg) { expr.Emit(cg); cg.EmitCall(typeof(Ops), "Repr"); }
public override void Emit(CodeGen cg) { target.Emit(cg); index.Emit(cg); cg.EmitCall(typeof(Ops), "GetIndex"); }
public override void Emit(CodeGen cg) { //!!! first optimize option comes here // if (target is FieldExpr && !hasSpecialArgs()) { // generateInvoke((FieldExpr)target, cg); // return; // } Label done = new Label(); bool emitDone = false; Expr[] exprs = new Expr[args.Length - extraArgs]; Expr argsTuple = null, keywordDict = null; string[] keywordNames = new string[keywordCount]; int index = 0, keywordIndex = 0; foreach (Arg arg in args) { if (arg.name == ParamsName) { argsTuple = arg.expr; continue; } else if (arg.name == DictionaryName) { keywordDict = arg.expr; continue; } else if (arg.name != null) { keywordNames[keywordIndex++] = arg.name.GetString(); } exprs[index++] = arg.expr; } if (hasKeywordDict || (hasArgsTuple && keywordCount > 0)) { cg.EmitCallerContext(); target.Emit(cg); cg.EmitObjectArray(exprs); cg.EmitStringArray(keywordNames); cg.EmitExprOrNone(argsTuple); cg.EmitExprOrNone(keywordDict); cg.EmitCall(typeof(Ops), "CallWithArgsTupleAndKeywordDictAndContext", new Type[] { typeof(ICallerContext), typeof(object), typeof(object[]), typeof(string[]), typeof(object), typeof(object) }); } else if (hasArgsTuple) { cg.EmitCallerContext(); target.Emit(cg); cg.EmitObjectArray(exprs); cg.EmitExprOrNone(argsTuple); cg.EmitCall(typeof(Ops), "CallWithArgsTupleAndContext", new Type[] { typeof(ICallerContext), typeof(object), typeof(object[]), typeof(object) }); } else if (keywordCount > 0) { target.Emit(cg); cg.EmitObjectArray(exprs); cg.EmitStringArray(keywordNames); cg.EmitCall(typeof(Ops), "Call", new Type[] { typeof(object), typeof(object[]), typeof(string[]) }); } else { cg.EmitCallerContext(); target.Emit(cg); if (args.Length <= 4) { Type[] argTypes = new Type[args.Length + 2]; int i = 0; argTypes[i++] = typeof(ICallerContext); argTypes[i++] = typeof(object); foreach (Expr e in exprs) { e.Emit(cg); argTypes[i++] = typeof(object); } cg.EmitCall(typeof(Ops), "CallWithContext", argTypes); } else { cg.EmitObjectArray(exprs); cg.EmitCall(typeof(Ops), "CallWithContext", new Type[] { typeof(ICallerContext), typeof(object), typeof(object[]) }); } } if (emitDone) { cg.MarkLabel(done); } }
public override void Emit(CodeGen cg) { cg.EmitPosition(start, header); SignatureInfo sigInfo = SignatureInfo.Get(this, cg); FlowChecker.Check(this); string mname = name.GetString() + "$f" + counter++; // create the new method & setup it's locals CodeGen impl = cg.DefineMethod(mname, typeof(object), sigInfo.ParamTypes, sigInfo.ParamNames); impl.Names = CodeGen.CreateLocalNamespace(impl); impl.Context = cg.Context; for (int arg = sigInfo.HasContext ? 1 : 0; arg < sigInfo.ParamNames.Length; arg++) { impl.Names.SetSlot(sigInfo.ParamNames[arg], impl.GetArgumentSlot(arg)); } // then generate the actual method EmitFunctionImplementation(cg, impl, sigInfo.HasContext); if (NeedsWrapperMethod()) { impl = MakeWrapperMethodN(cg, impl.MethodInfo, sigInfo.HasContext); } // Create instance of the Function? object Type funcType, targetType; using (impl) { GetFunctionType(out funcType, out targetType); cg.EmitModuleInstance(); cg.EmitString(name.GetString()); cg.EmitDelegate(impl, targetType, sigInfo.ContextSlot); } int first = sigInfo.HasContext ? 1 : 0; // Emit string array (minus the first environment argument) cg.EmitInt(sigInfo.ParamNames.Length - first); cg.Emit(OpCodes.Newarr, typeof(string)); for (int i = first; i < sigInfo.ParamNames.Length; i++) { cg.Emit(OpCodes.Dup); cg.EmitInt(i - first); cg.EmitStringOrNull(sigInfo.ParamNames[i].GetString()); cg.Emit(OpCodes.Stelem_Ref); } cg.EmitObjectArray(defaults); if (flags == FuncDefType.None) { cg.Emit(OpCodes.Newobj, funcType.GetConstructor( new Type[] { typeof(PythonModule), typeof(string), targetType, typeof(string[]), typeof(object[]) })); } else { cg.EmitInt((int)flags); cg.Emit(OpCodes.Newobj, funcType.GetConstructor( new Type[] { typeof(PythonModule), typeof(string), targetType, typeof(string[]), typeof(object[]), typeof(FuncDefType) })); } string doc = body.GetDocString(); if (doc != null) { cg.Emit(OpCodes.Dup); cg.EmitString(doc); cg.EmitCall(typeof(PythonFunction).GetProperty("Documentation").GetSetMethod()); } // update func_code w/ appropriate state. cg.Emit(OpCodes.Dup); cg.EmitCall(typeof(PythonFunction).GetProperty("FunctionCode").GetGetMethod()); cg.Emit(OpCodes.Castclass, typeof(FunctionCode)); cg.Emit(OpCodes.Dup); cg.EmitInt(this.start.line); cg.EmitCall(typeof(FunctionCode), "SetLineNumber"); cg.EmitString(this.filename); cg.EmitCall(typeof(FunctionCode), "SetFilename"); cg.EmitSet(name); if (decorators != null) { decorators.Emit(cg); cg.EmitSet(name); } }