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);
}
}
