private void EmitWithCatchBlock(CodeGen cg, Slot exc, Slot exit)
{
cg.BeginCatchBlock(typeof(Exception));
// Extract state from the carrier exception
cg.EmitCallerContext();
cg.EmitCall(typeof(Ops), "ExtractException",
new Type[] { typeof(Exception), typeof(ICallerContext) });
cg.Emit(OpCodes.Pop);
// except body
cg.PushExceptionBlock(Targets.TargetBlockType.Catch, null, null);
cg.EmitConstantBoxed(false);
exc.EmitSet(cg);
cg.EmitCallerContext();
exit.EmitGet(cg);
cg.EmitObjectArray(new Expression[0]);
cg.EmitCallerContext();
cg.EmitCall(typeof(Ops), "ExtractSysExcInfo");
cg.EmitCall(typeof(Ops), "CallWithArgsTupleAndContext", new Type[] { typeof(ICallerContext), typeof(object), typeof(object[]), typeof(object) });
Label afterRaise = cg.DefineLabel();
cg.EmitTestTrue();
cg.Emit(OpCodes.Brtrue, afterRaise);
cg.EmitCall(typeof(Ops), "Raise", new Type[0]); //, new Type[] { typeof(object), typeof(SymbolId) });
cg.MarkLabel(afterRaise);
cg.EmitCallerContext();
cg.EmitCall(typeof(Ops), "ClearException", new Type[] { typeof(ICallerContext) });
cg.PopTargets();
}
private void EmitYieldDispatch(List<YieldTarget> yieldTargets, Slot isYielded, Slot choiceVar, CodeGen cg)
{
if (IsBlockYieldable(yieldTargets)) {
cg.EmitFieldGet(typeof(Ops).GetField("FALSE"));
isYielded.EmitSet(cg);
int index = 0;
foreach (YieldTarget yt in yieldTargets) {
choiceVar.EmitGet(cg);
cg.EmitInt(index);
cg.Emit(OpCodes.Beq, yt.YieldContinuationTarget);
index++;
}
}
}
private void EmitTopYieldTargetLabels(List<YieldTarget> yieldTargets, Slot choiceVar, CodeGen cg)
{
if (IsBlockYieldable(yieldTargets)) {
Label label = cg.DefineLabel();
cg.EmitInt(-1);
choiceVar.EmitSet(cg);
cg.Emit(OpCodes.Br, label);
int index = 0;
foreach (YieldTarget yt in yieldTargets) {
cg.MarkLabel(yt.TopBranchTarget);
cg.EmitInt(index++);
choiceVar.EmitSet(cg);
cg.Emit(OpCodes.Br, label);
}
cg.MarkLabel(label);
}
}
private static CodeGen AddIDynamicObject(TypeGen newType, Slot dictSlot)
{
Slot classSlot = newType.AddStaticField(typeof(DynamicType), FieldAttributes.Private, "$class");
newType.myType.AddInterfaceImplementation(typeof(ISuperDynamicObject));
/* GetDynamicType */
CodeGen gdtCg = newType.DefineMethodOverride(typeof(IDynamicObject).GetMethod("GetDynamicType"));
CodeGen cg = newType.DefineUserHiddenMethod(MethodAttributes.FamORAssem | MethodAttributes.Static,
"$$GetOrMakeDynamicType", typeof(DynamicType), new Type[0]);
DoLazyInitCheck(cg, classSlot,
delegate() {
// if not null, just return the value.
classSlot.EmitGet(cg);
cg.EmitReturn();
},
delegate() {
// initialization code
// CompiledType GetTypeForType(Type t)
cg.EmitType(newType.myType);
cg.EmitCall(typeof(CompiledType), "GetTypeForType");
cg.Emit(OpCodes.Dup);
classSlot.EmitSet(cg);
cg.EmitReturn();
});
cg.Finish();
CodeGen ret = cg;
// just a call to the helper method
gdtCg.EmitThis();
gdtCg.EmitCall(typeof(object), "GetType");
gdtCg.EmitType(newType.myType);
Label differ = gdtCg.DefineLabel();
gdtCg.Emit(OpCodes.Bne_Un, differ);
gdtCg.EmitCall(cg.MethodInfo);
gdtCg.EmitReturn();
gdtCg.MarkLabel(differ);
gdtCg.EmitThis();
gdtCg.EmitCall(typeof(object), "GetType");
gdtCg.EmitCall(typeof(Ops), "GetDynamicTypeFromType");
gdtCg.EmitReturn();
gdtCg.Finish();
/* GetDict */
cg = newType.DefineMethodOverride(typeof(ISuperDynamicObject).GetMethod("GetDict"));
DoLazyInitCheck(cg, dictSlot,
delegate() {
// if not null, just return the value.
dictSlot.EmitGet(cg);
cg.EmitReturn();
},
delegate() {
// initialization code - dictSlot = new CustomOldClassDict()
cg.EmitNew(typeof(CustomOldClassDict).GetConstructor(new Type[0]));
cg.Emit(OpCodes.Dup);
dictSlot.EmitSet(cg);
cg.EmitReturn();
});
cg.Finish();
/* SetDict */
cg = newType.DefineMethodOverride(typeof(ISuperDynamicObject).GetMethod("SetDict"));
cg.EmitString("SetDict");
cg.EmitInt(0);
cg.Emit(OpCodes.Newarr, typeof(object));
cg.EmitCall(typeof(Ops), "NotImplementedError");
cg.Emit(OpCodes.Throw);
/* SetDynamicType */
cg = newType.DefineMethodOverride(typeof(ISuperDynamicObject).GetMethod("SetDynamicType"));
cg.EmitString("SetDynamicType");
cg.EmitInt(0);
cg.Emit(OpCodes.Newarr, typeof(object));
cg.EmitCall(typeof(Ops), "NotImplementedError");
cg.Emit(OpCodes.Throw);
return ret;
}
/// <summary>
/// Emits a call into the PythonModule to register this module, and then
/// returns the resulting PythonModule
/// </summary>
public static void EmitModuleConstruction(TypeGen tg, CodeGen main, string moduleName, Slot initialize, IList<string> referencedAssemblies)
{
// calling PythonModule InitializeModule(CustomDict compiled, string fullName)
main.EmitNew(tg.DefaultConstructor); // Emit instance for the InitializeModule call (compiled)
initialize.EmitSet(main);
initialize.EmitGet(main);
main.EmitString(moduleName); // emit module name (fullName)
// emit the references assemblies
if (referencedAssemblies != null) {
for (int i = 0; i < referencedAssemblies.Count; i++) {
if (referencedAssemblies[i].ToLower().EndsWith("\\ironpython.dll")) {
referencedAssemblies.RemoveAt(i);
i--;
} else {
if (referencedAssemblies[i].IndexOf(Path.DirectorySeparatorChar) != -1) {
referencedAssemblies[i] = referencedAssemblies[i].Substring(referencedAssemblies[i].LastIndexOf(Path.DirectorySeparatorChar) + 1);
}
if (referencedAssemblies[i].ToLower().EndsWith(".dll")) {
referencedAssemblies[i] = referencedAssemblies[i].Substring(0, referencedAssemblies[i].Length - 4);
}
}
}
main.EmitStringArray(referencedAssemblies);
} else main.Emit(OpCodes.Ldnull);
// Call InitializeModule
main.EmitCall(typeof(Ops), "InitializeModule");
}
public override void EmitSet(CodeGen cg, Slot val)
{
val.EmitGet(cg);
cg.EmitConvertToObject(Type);
val = cg.GetLocalTmp(typeof(object));
val.EmitSet(cg);
instance.EmitGet(cg);
cg.EmitInt(index);
val.EmitGet(cg);
cg.Emit(OpCodes.Stelem_Ref);
}