public override IUnresolvedAssembly LoadAssemblyFile(string fileName)
{
if (fileName == null)
throw new ArgumentNullException("fileName");
using (var universe = new Universe (UniverseOptions.DisablePseudoCustomAttributeRetrieval | UniverseOptions.SupressReferenceTypeIdentityConversion | UniverseOptions.ResolveMissingMembers)) {
universe.AssemblyResolve += delegate(object sender, IKVM.Reflection.ResolveEventArgs args) {
return universe.CreateMissingAssembly(args.Name);
};
return LoadAssembly (universe.LoadFile (fileName));
}
}
static void Main(string[] args)
{
Universe u = new Universe();
var asm = u.DefineDynamicAssembly(new AssemblyName("test2"), IKVM.Reflection.Emit.AssemblyBuilderAccess.Save);
var mod = asm.DefineDynamicModule("test2", "test2.exe");
System.Func<System.Type, Type> L = ty => u.Load(ty.Assembly.FullName).GetType(ty.FullName);
var t = mod.DefineType("test2.Test", TypeAttributes.Public, L(typeof(Totem.Library.Function)));
var md = t.DefineMethod("Main", MethodAttributes.Static | MethodAttributes.Public, L(typeof(void)), Type.EmptyTypes);
asm.SetEntryPoint(md);
var ctor = t.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
var il = md.GetILGenerator();
il.Emit(OpCodes.Ldstr, "Click enter to start");
il.Emit(OpCodes.Call, L(typeof(System.Console)).GetMethod("WriteLine", new Type[] { L(typeof(string)) }));
il.Emit(OpCodes.Call, L(typeof(System.Console)).GetMethod("ReadLine", Type.EmptyTypes));
il.Emit(OpCodes.Pop);
il.Emit(OpCodes.Newobj, ctor);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Callvirt, L(typeof(TotemFunction)).GetMethod("Execute"));
il.Emit(OpCodes.Pop);
il.Emit(OpCodes.Call, L(typeof(System.Console)).GetMethod("ReadLine", Type.EmptyTypes));
il.Emit(OpCodes.Pop);
il.Emit(OpCodes.Ret);
var ctorIl = ctor.GetILGenerator();
ctorIl.Emit(OpCodes.Ldarg_0);
ctorIl.Emit(OpCodes.Call, L(typeof(TotemScope)).GetProperty("Global").GetGetMethod());
ctorIl.Emit(OpCodes.Ldstr, "Main");
ctorIl.Emit(OpCodes.Ldnull);
ctorIl.Emit(OpCodes.Call, L(typeof(TotemFunction)).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { L(typeof(TotemScope)), L(typeof(string)), L(typeof(TotemParameter[])) }, null));
ctorIl.Emit(OpCodes.Ret);
t.CreateType();
asm.Save("test2.exe");
}
public Outline (Universe universe, Assembly mscorlib, Type t, TextWriter output, bool declared_only, bool show_private, bool filter_obsolete)
{
if (universe == null)
throw new ArgumentNullException ("universe");
if (mscorlib == null)
throw new ArgumentNullException ("mscorlib");
this.universe = universe;
this.mscorlib = mscorlib;
this.t = t;
this.o = new IndentedTextWriter (output, "\t");
this.declared_only = declared_only;
this.show_private = show_private;
this.filter_obsolete = filter_obsolete;
type_multicast_delegate = mscorlib.GetType("System.MulticastDelegate");
type_object = mscorlib.GetType ("System.Object");
type_value_type = mscorlib.GetType ("System.ValueType");
type_int = mscorlib.GetType ("System.Int32");
type_flags_attribute = mscorlib.GetType ("System.FlagsAttribute");
type_obsolete_attribute = mscorlib.GetType ("System.ObsoleteAttribute");
type_param_array_attribute = mscorlib.GetType ("System.ParamArrayAttribute");
}
public AssemblyResolver(Universe universe, bool nostdlib, IEnumerable<string> references, IEnumerable<string> libpaths) {
_universe = universe;
_libpaths.Add(Environment.CurrentDirectory);
_libpaths.AddRange(libpaths);
if (!nostdlib) {
_libpaths.Add(System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory());
}
// items passed in via /lib:<path>
foreach (string path in libpaths) {
foreach (string dir in path.Split(new char[] { Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries)) {
if (Directory.Exists(dir)) {
_libpaths.Add(dir);
} else {
ConsoleOps.Warning("Directory specified ('{0}') by /lib: does not exist", dir);
}
}
}
string envLib = Environment.GetEnvironmentVariable("LIB");
if (!string.IsNullOrEmpty(envLib)) {
foreach (string dir in envLib.Split(new char[] { Path.PathSeparator }, StringSplitOptions.RemoveEmptyEntries)) {
if (Directory.Exists(dir)) {
_libpaths.Add(dir);
} else {
ConsoleOps.Warning("Directory specified ('{0}') in LIB does not exist", dir);
}
}
}
if (nostdlib) {
_mscorlibVersion = LoadMscorlib(references).GetName().Version;
} else {
_mscorlibVersion = universe.Load("mscorlib").GetName().Version;
}
_universe.AssemblyResolve += _universe_AssemblyResolve;
}
internal RuntimeTypeModel(bool isDefault)
{
#if FEAT_IKVM
universe = new IKVM.Reflection.Universe();
universe.EnableMissingMemberResolution(); // needed to avoid TypedReference issue on WinRT
#endif
AutoAddMissingTypes = true;
UseImplicitZeroDefaults = true;
SetOption(OPTIONS_IsDefaultModel, isDefault);
#if FEAT_COMPILER && !FX11 && !DEBUG
AutoCompile = true;
#endif
}
protected Module(Universe universe)
{
this.universe = universe;
}
internal Module(Universe universe)
{
this.universe = universe;
}
public IUnresolvedAssembly LoadAssemblyFile(string fileName)
{
if (fileName == null)
throw new ArgumentNullException("fileName");
using (var universe = new Universe (UniverseOptions.DisablePseudoCustomAttributeRetrieval)) {
return LoadAssembly (universe.LoadFile (fileName));
}
}
internal static Type Make(Universe universe, __StandAloneMethodSig sig)
{
return universe.CanonicalizeType(new FunctionPointerType(universe, sig));
}
public TypeMapper(Universe universe)
{
if (universe == null) throw new ArgumentNullException(nameof(universe));
this.universe = universe;
TypeInfo = new TypeInfo(this);
}
internal MissingAssembly(Universe universe, string name)
: base(universe)
{
module = new MissingModule(this, -1);
this.fullName = name;
}
private AssemblyName ReadCustomAttributesFromTemplateFile (string templateFile, AssemblyName aname)
{
// LAMESPEC: according to MSDN, the template assembly must have a
// strong name but this is not enforced
const IKR.UniverseOptions options = IKR.UniverseOptions.MetadataOnly;
var universe = new IKR.Universe (options);
var asm = universe.LoadFile (templateFile);
// Create missing assemblies, we don't want to load them!
// Code taken from ikdasm
var names = new HashSet<string> ();
IKR.AssemblyName[] assembly_refs = asm.ManifestModule.__GetReferencedAssemblies ();
var resolved_assemblies = new IKR.Assembly [assembly_refs.Length];
for (int i = 0; i < resolved_assemblies.Length; i++) {
string name = assembly_refs [i].Name;
while (names.Contains (name)) {
name = name + "_" + i;
}
names.Add (name);
resolved_assemblies [i] = universe.CreateMissingAssembly (assembly_refs [i].FullName);
}
asm.ManifestModule.__ResolveReferencedAssemblies (resolved_assemblies);
foreach (var attr_data in asm.__GetCustomAttributes (null, false)) {
string asm_name = attr_data.AttributeType.Assembly.GetName ().Name;
if (asm_name != "mscorlib")
continue;
switch (attr_data.AttributeType.FullName) {
case "System.Reflection.AssemblyKeyFileAttribute": {
if (keyfile != null)
// ignore if specified on command line
continue;
// / AssemblyKeyFileAttribute .ctor(string keyFile)
string key_file_value = (string) attr_data.ConstructorArguments [0].Value;
if (!String.IsNullOrEmpty (key_file_value))
keyfile = Path.Combine (Path.GetDirectoryName (templateFile), key_file_value);
}
break;
case "System.Reflection.AssemblyDelaySignAttribute": {
if (delaysign != DelaySign.NotSet)
// ignore if specified on command line
continue;
// AssemblyDelaySignAttribute .ctor(bool delaySign)
bool delay_sign_value = (bool) attr_data.ConstructorArguments [0].Value;
delaysign = delay_sign_value ? DelaySign.Yes : DelaySign.No;
}
break;
case "System.Reflection.AssemblyKeyNameAttribute": {
if (keyname != null)
// ignore if specified on command line
continue;
// AssemblyKeyNameAttribute .ctor(string keyName)
string key_name_value = (string) attr_data.ConstructorArguments [0].Value;
// ignore null or zero-length keyname
if (!String.IsNullOrEmpty (key_name_value))
keyname = key_name_value;
}
break;
}
}
var asm_name_for_template_file = asm.GetName ();
aname.Version = asm_name_for_template_file.Version;
aname.HashAlgorithm = asm_name_for_template_file.HashAlgorithm;
return aname;
}
protected static void WriteType(ModuleBuilder module, ByteBuffer bb, Type type)
{
while (type.HasElementType)
{
if (type.__IsVector)
{
bb.Write(ELEMENT_TYPE_SZARRAY);
}
else if (type.IsArray)
{
int rank = type.GetArrayRank();
bb.Write(ELEMENT_TYPE_ARRAY);
// LAMESPEC the Type production (23.2.12) doesn't include CustomMod* for arrays, but the verifier allows it and ildasm also supports it
WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_REQD, type.__GetRequiredCustomModifiers());
WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_OPT, type.__GetOptionalCustomModifiers());
WriteType(module, bb, type.GetElementType());
bb.WriteCompressedInt(rank);
// since a Type doesn't contain the lower/upper bounds
// (they act like a custom modifier, so they are part of the signature, but not of the Type),
// we set them to the C# compatible values and hope for the best
bb.WriteCompressedInt(0); // boundsCount
bb.WriteCompressedInt(rank); // loCount
for (int i = 0; i < rank; i++)
{
bb.WriteCompressedInt(0);
}
return;
}
else if (type.IsByRef)
{
bb.Write(ELEMENT_TYPE_BYREF);
}
else if (type.IsPointer)
{
bb.Write(ELEMENT_TYPE_PTR);
}
WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_REQD, type.__GetRequiredCustomModifiers());
WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_OPT, type.__GetOptionalCustomModifiers());
type = type.GetElementType();
}
Universe u = module.universe;
if (type == u.System_Void)
{
bb.Write(ELEMENT_TYPE_VOID);
}
else if (type == u.System_Boolean)
{
bb.Write(ELEMENT_TYPE_BOOLEAN);
}
else if (type == u.System_Char)
{
bb.Write(ELEMENT_TYPE_CHAR);
}
else if (type == u.System_SByte)
{
bb.Write(ELEMENT_TYPE_I1);
}
else if (type == u.System_Byte)
{
bb.Write(ELEMENT_TYPE_U1);
}
else if (type == u.System_Int16)
{
bb.Write(ELEMENT_TYPE_I2);
}
else if (type == u.System_UInt16)
{
bb.Write(ELEMENT_TYPE_U2);
}
else if (type == u.System_Int32)
{
bb.Write(ELEMENT_TYPE_I4);
}
else if (type == u.System_UInt32)
{
bb.Write(ELEMENT_TYPE_U4);
}
else if (type == u.System_Int64)
{
bb.Write(ELEMENT_TYPE_I8);
}
else if (type == u.System_UInt64)
{
bb.Write(ELEMENT_TYPE_U8);
}
else if (type == u.System_Single)
{
bb.Write(ELEMENT_TYPE_R4);
}
else if (type == u.System_Double)
{
bb.Write(ELEMENT_TYPE_R8);
}
else if (type == u.System_String)
{
bb.Write(ELEMENT_TYPE_STRING);
}
else if (type == u.System_IntPtr)
{
bb.Write(ELEMENT_TYPE_I);
}
else if (type == u.System_UIntPtr)
{
bb.Write(ELEMENT_TYPE_U);
}
else if (type == u.System_TypedReference)
{
bb.Write(ELEMENT_TYPE_TYPEDBYREF);
}
else if (type == u.System_Object)
{
bb.Write(ELEMENT_TYPE_OBJECT);
}
else if (type.IsGenericParameter)
{
if (type is UnboundGenericMethodParameter || type.DeclaringMethod != null)
{
bb.Write(ELEMENT_TYPE_MVAR);
}
else
{
bb.Write(ELEMENT_TYPE_VAR);
}
bb.WriteCompressedInt(type.GenericParameterPosition);
}
else if (type.IsGenericType)
{
WriteGenericSignature(module, bb, type);
}
else
{
if (type.IsValueType)
{
bb.Write(ELEMENT_TYPE_VALUETYPE);
}
else
{
bb.Write(ELEMENT_TYPE_CLASS);
}
bb.WriteTypeDefOrRefEncoded(module.GetTypeToken(type).Token);
}
}
internal Module(Universe universe)
{
this.universe = universe;
}
private int DynMain (String[] args) {
using (universe = new Universe (UniverseOptions.MetadataOnly)) {
universe.LoadFile (typeof (object).Assembly.Location);
ParseArgs (args);
DoIt ();
return 0;
}
}
private static Universe GetUniverse () {
if (_universe == null) {
_universe = new Universe (UniverseOptions.MetadataOnly);
}
return _universe;
}
private static Type ReadFieldOrPropType(Module context, ByteReader br)
{
Universe u = context.universe;
switch (br.ReadByte())
{
case Signature.ELEMENT_TYPE_BOOLEAN:
return(u.System_Boolean);
case Signature.ELEMENT_TYPE_CHAR:
return(u.System_Char);
case Signature.ELEMENT_TYPE_I1:
return(u.System_SByte);
case Signature.ELEMENT_TYPE_U1:
return(u.System_Byte);
case Signature.ELEMENT_TYPE_I2:
return(u.System_Int16);
case Signature.ELEMENT_TYPE_U2:
return(u.System_UInt16);
case Signature.ELEMENT_TYPE_I4:
return(u.System_Int32);
case Signature.ELEMENT_TYPE_U4:
return(u.System_UInt32);
case Signature.ELEMENT_TYPE_I8:
return(u.System_Int64);
case Signature.ELEMENT_TYPE_U8:
return(u.System_UInt64);
case Signature.ELEMENT_TYPE_R4:
return(u.System_Single);
case Signature.ELEMENT_TYPE_R8:
return(u.System_Double);
case Signature.ELEMENT_TYPE_STRING:
return(u.System_String);
case Signature.ELEMENT_TYPE_SZARRAY:
return(ReadFieldOrPropType(context, br).MakeArrayType());
case 0x55:
return(ReadType(context, br));
case 0x50:
return(u.System_Type);
case 0x51:
return(u.System_Object);
default:
throw new BadImageFormatException();
}
}
private FunctionPointerType(Universe universe, __StandAloneMethodSig sig)
{
this.universe = universe;
this.sig = sig;
}
private static CustomAttributeTypedArgument ReadFixedArg(Module context, ByteReader br, Type type)
{
Universe u = context.universe;
if (type == u.System_String)
{
return(new CustomAttributeTypedArgument(type, br.ReadString()));
}
else if (type == u.System_Boolean)
{
return(new CustomAttributeTypedArgument(type, br.ReadByte() != 0));
}
else if (type == u.System_Char)
{
return(new CustomAttributeTypedArgument(type, br.ReadChar()));
}
else if (type == u.System_Single)
{
return(new CustomAttributeTypedArgument(type, br.ReadSingle()));
}
else if (type == u.System_Double)
{
return(new CustomAttributeTypedArgument(type, br.ReadDouble()));
}
else if (type == u.System_SByte)
{
return(new CustomAttributeTypedArgument(type, br.ReadSByte()));
}
else if (type == u.System_Int16)
{
return(new CustomAttributeTypedArgument(type, br.ReadInt16()));
}
else if (type == u.System_Int32)
{
return(new CustomAttributeTypedArgument(type, br.ReadInt32()));
}
else if (type == u.System_Int64)
{
return(new CustomAttributeTypedArgument(type, br.ReadInt64()));
}
else if (type == u.System_Byte)
{
return(new CustomAttributeTypedArgument(type, br.ReadByte()));
}
else if (type == u.System_UInt16)
{
return(new CustomAttributeTypedArgument(type, br.ReadUInt16()));
}
else if (type == u.System_UInt32)
{
return(new CustomAttributeTypedArgument(type, br.ReadUInt32()));
}
else if (type == u.System_UInt64)
{
return(new CustomAttributeTypedArgument(type, br.ReadUInt64()));
}
else if (type == u.System_Type)
{
return(new CustomAttributeTypedArgument(type, ReadType(context, br)));
}
else if (type == u.System_Object)
{
return(ReadFixedArg(context, br, ReadFieldOrPropType(context, br)));
}
else if (type.IsArray)
{
int length = br.ReadInt32();
if (length == -1)
{
return(new CustomAttributeTypedArgument(type, null));
}
Type elementType = type.GetElementType();
CustomAttributeTypedArgument[] array = new CustomAttributeTypedArgument[length];
for (int i = 0; i < length; i++)
{
array[i] = ReadFixedArg(context, br, elementType);
}
return(new CustomAttributeTypedArgument(type, array));
}
else if (type.IsEnum)
{
return(new CustomAttributeTypedArgument(type, ReadFixedArg(context, br, type.GetEnumUnderlyingTypeImpl()).Value));
}
else
{
throw new InvalidOperationException(type.ToString());
}
}
internal static void Init(bool emitSymbols)
{
UniverseOptions options = UniverseOptions.ResolveMissingMembers | UniverseOptions.EnableFunctionPointers;
if (!emitSymbols)
{
options |= UniverseOptions.DeterministicOutput;
}
universe = new Universe(options);
universe.ResolvedMissingMember += ResolvedMissingMember;
}
internal Assembly(Universe universe)
{
this.universe = universe;
}
private static void UsingAssembly(string path, Action<Assembly> action) {
using (var universe = new Universe()) {
action(universe.LoadFile(path));
}
}
protected Module(Universe universe)
{
this.universe = universe;
}
/// <summary>
/// Generates the stub .exe file for starting the app
/// </summary>
/// <param name="config"></param>
static void GenerateExe(Config config)
{
var u = new Universe();
var aName = new AssemblyName(Path.GetFileNameWithoutExtension(new FileInfo(config.Output).Name));
if (config.FileInfoVersion != null) {
aName.Version = config.FileInfoVersion;
}
var ab = u.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Save, Path.GetDirectoryName(config.Output));
ab.DefineVersionInfoResource(config.FileInfoProduct, config.FileInfoProductVersion, config.FileInfoCompany, config.FileInfoCopyright, config.FileInfoTrademark);
var mb = ab.DefineDynamicModule(config.Output, aName.Name + (aName.Name.EndsWith(".exe") ? string.Empty : ".exe"));
var tb = mb.DefineType("PythonMain", IKVM.Reflection.TypeAttributes.Public);
if (!string.IsNullOrEmpty(config.Win32Icon)) {
ab.__DefineIconResource(File.ReadAllBytes(config.Win32Icon));
}
MethodBuilder assemblyResolveMethod = null;
ILGenerator gen = null;
if (config.Standalone) {
ConsoleOps.Info("Generating stand alone executable");
config.Embed = true;
foreach (var a in System.AppDomain.CurrentDomain.GetAssemblies()) {
var n = new AssemblyName(a.FullName);
if (!a.IsDynamic && a.EntryPoint == null && (n.Name.StartsWith("IronPython") || n.Name == "Microsoft.Dynamic" || n.Name == "Microsoft.Scripting")) {
ConsoleOps.Info("\tEmbedded {0} {1}", n.Name, n.Version);
var f = new FileStream(a.Location, FileMode.Open, FileAccess.Read);
mb.DefineManifestResource("Dll." + n.Name, f, IKVM.Reflection.ResourceAttributes.Public);
}
}
// we currently do no error checking on what is passed in to the assemblyresolve event handler
assemblyResolveMethod = tb.DefineMethod("AssemblyResolve", MethodAttributes.Public | MethodAttributes.Static, u.Import(typeof(System.Reflection.Assembly)), new IKVM.Reflection.Type[] { u.Import(typeof(System.Object)), u.Import(typeof(System.ResolveEventArgs)) });
gen = assemblyResolveMethod.GetILGenerator();
var s = gen.DeclareLocal(u.Import(typeof(System.IO.Stream))); // resource stream
gen.Emit(OpCodes.Ldnull);
gen.Emit(OpCodes.Stloc, s);
var d = gen.DeclareLocal(u.Import(typeof(byte[]))); // data buffer;
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("GetEntryAssembly"), Type.EmptyTypes);
gen.Emit(OpCodes.Ldstr, "Dll.");
gen.Emit(OpCodes.Ldarg_1); // The event args
gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.ResolveEventArgs)).GetMethod("get_Name"), Type.EmptyTypes);
gen.Emit(OpCodes.Newobj, u.Import(typeof(System.Reflection.AssemblyName)).GetConstructor(new IKVM.Reflection.Type[] { u.Import(typeof(string)) }));
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.AssemblyName)).GetMethod("get_Name"), Type.EmptyTypes);
gen.EmitCall(OpCodes.Call, u.Import(typeof(string)).GetMethod("Concat", new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(string)) }), Type.EmptyTypes);
gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.Reflection.Assembly)).GetMethod("GetManifestResourceStream", new IKVM.Reflection.Type[] { u.Import(typeof(string)) }), Type.EmptyTypes);
gen.Emit(OpCodes.Stloc, s);
gen.Emit(OpCodes.Ldloc, s);
gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.IO.Stream)).GetMethod("get_Length"), Type.EmptyTypes);
gen.Emit(OpCodes.Newarr, u.Import(typeof(System.Byte)));
gen.Emit(OpCodes.Stloc, d);
gen.Emit(OpCodes.Ldloc, s);
gen.Emit(OpCodes.Ldloc, d);
gen.Emit(OpCodes.Ldc_I4_0);
gen.Emit(OpCodes.Ldloc, s);
gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.IO.Stream)).GetMethod("get_Length"), Type.EmptyTypes);
gen.Emit(OpCodes.Conv_I4);
gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.IO.Stream)).GetMethod("Read", new IKVM.Reflection.Type[] { u.Import(typeof(byte[])), u.Import(typeof(int)), u.Import(typeof(int)) }), Type.EmptyTypes);
gen.Emit(OpCodes.Pop);
gen.Emit(OpCodes.Ldloc, d);
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("Load", new IKVM.Reflection.Type[] { u.Import(typeof(byte[])) }), Type.EmptyTypes);
gen.Emit(OpCodes.Ret);
// generate a static constructor to assign the AssemblyResolve handler (otherwise it tries to use IronPython before it adds the handler)
// the other way of handling this would be to move the call to InitializeModule into a separate method.
var staticConstructor = tb.DefineConstructor(MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, Type.EmptyTypes);
gen = staticConstructor.GetILGenerator();
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.AppDomain)).GetMethod("get_CurrentDomain"), Type.EmptyTypes);
gen.Emit(OpCodes.Ldnull);
gen.Emit(OpCodes.Ldftn, assemblyResolveMethod);
gen.Emit(OpCodes.Newobj, u.Import(typeof(System.ResolveEventHandler)).GetConstructor(new IKVM.Reflection.Type[] { u.Import(typeof(object)), u.Import(typeof(System.IntPtr)) }));
gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.AppDomain)).GetMethod("add_AssemblyResolve"), Type.EmptyTypes);
gen.Emit(OpCodes.Ret);
}
var mainMethod = tb.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, u.Import(typeof(int)), Type.EmptyTypes);
if (config.Target == PEFileKinds.WindowApplication && config.UseMta) {
mainMethod.SetCustomAttribute(u.Import(typeof(System.MTAThreadAttribute)).GetConstructor(Type.EmptyTypes), new byte[0]);
} else if (config.Target == PEFileKinds.WindowApplication) {
mainMethod.SetCustomAttribute(u.Import(typeof(System.STAThreadAttribute)).GetConstructor(Type.EmptyTypes), new byte[0]);
}
gen = mainMethod.GetILGenerator();
// variables for saving original working directory and return code of script
var strVar = gen.DeclareLocal(u.Import(typeof(string)));
var intVar = gen.DeclareLocal(u.Import(typeof(int)));
Label tryStart = gen.BeginExceptionBlock();
// get the ScriptCode assembly...
if (config.Embed) {
// put the generated DLL into the resources for the stub exe
var mem = new MemoryStream();
var rw = new ResourceWriter(mem);
rw.AddResource("IPDll." + Path.GetFileNameWithoutExtension(config.Output) + ".dll", File.ReadAllBytes(config.Output + ".dll"));
rw.Generate();
mem.Position = 0;
mb.DefineManifestResource("IPDll.resources", mem, ResourceAttributes.Public);
File.Delete(config.Output + ".dll");
// generate code to load the resource
gen.Emit(OpCodes.Ldstr, "IPDll");
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("GetEntryAssembly"), Type.EmptyTypes);
gen.Emit(OpCodes.Newobj, u.Import(typeof(System.Resources.ResourceManager)).GetConstructor(new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(System.Reflection.Assembly)) }));
gen.Emit(OpCodes.Ldstr, "IPDll." + Path.GetFileNameWithoutExtension(config.Output) + ".dll");
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Resources.ResourceManager)).GetMethod("GetObject", new IKVM.Reflection.Type[] { u.Import(typeof(string)) }), Type.EmptyTypes);
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("Load", new IKVM.Reflection.Type[] { u.Import(typeof(byte[])) }), Type.EmptyTypes);
} else {
// save current working directory
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Environment)).GetMethod("get_CurrentDirectory"), Type.EmptyTypes);
gen.Emit(OpCodes.Stloc, strVar);
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("GetEntryAssembly"), Type.EmptyTypes);
gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.Reflection.Assembly)).GetMethod("get_Location"), Type.EmptyTypes);
gen.Emit(OpCodes.Newobj, u.Import(typeof(System.IO.FileInfo)).GetConstructor(new IKVM.Reflection.Type[] { u.Import(typeof(string)) }));
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.IO.FileInfo)).GetMethod("get_Directory"), Type.EmptyTypes);
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.IO.DirectoryInfo)).GetMethod("get_FullName"), Type.EmptyTypes);
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Environment)).GetMethod("set_CurrentDirectory"), Type.EmptyTypes);
gen.Emit(OpCodes.Ldstr, config.Output + ".dll");
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.IO.Path)).GetMethod("GetFullPath", new IKVM.Reflection.Type[] { u.Import(typeof(string)) }), Type.EmptyTypes);
// result of GetFullPath stays on the stack during the restore of the
// original working directory
// restore original working directory
gen.Emit(OpCodes.Ldloc, strVar);
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Environment)).GetMethod("set_CurrentDirectory"), Type.EmptyTypes);
// for the LoadFile() call, the full path of the assembly is still is on the stack
// as the result from the call to GetFullPath()
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("LoadFile", new IKVM.Reflection.Type[] { u.Import(typeof(string)) }), Type.EmptyTypes);
}
// emit module name
gen.Emit(OpCodes.Ldstr, "__main__"); // main module name
gen.Emit(OpCodes.Ldnull); // no references
gen.Emit(OpCodes.Ldc_I4_0); // don't ignore environment variables for engine startup
// call InitializeModule
// (this will also run the script)
// and put the return code on the stack
gen.EmitCall(OpCodes.Call, u.Import(typeof(PythonOps)).GetMethod("InitializeModuleEx"), Type.EmptyTypes);
gen.Emit(OpCodes.Stloc, intVar);
gen.BeginCatchBlock(u.Import(typeof(Exception)));
if (config.Target == PEFileKinds.ConsoleApplication) {
gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.Exception)).GetMethod("get_Message", Type.EmptyTypes), Type.EmptyTypes);
gen.Emit(OpCodes.Stloc, strVar);
gen.Emit(OpCodes.Ldstr, config.ErrorMessageFormat);
gen.Emit(OpCodes.Ldloc, strVar);
gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Console)).GetMethod("WriteLine", new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(string)) }), Type.EmptyTypes);
} else {
// what do we want to do in the case of a Windows app, show a MessageBox?
}
gen.Emit(OpCodes.Ldc_I4, -1); // return code is -1 to show failure
gen.Emit(OpCodes.Stloc, intVar);
gen.EndExceptionBlock();
gen.Emit(OpCodes.Ldloc, intVar);
gen.Emit(OpCodes.Ret);
tb.CreateType();
ab.SetEntryPoint(mainMethod, config.Target);
string fileName = aName.Name.EndsWith(".exe") ? aName.Name : aName.Name + ".exe";
ab.Save(fileName, config.Platform, config.Machine);
}
protected NonPEModule(Universe universe)
: base(universe)
{
}
protected string fullName; // AssemblyBuilder needs access to this field to clear it when the name changes
internal Assembly(Universe universe)
{
this.universe = universe;
}
private AssemblyName ReadCustomAttributesFromTemplateFile(string templateFile, AssemblyName aname)
{
// LAMESPEC: according to MSDN, the template assembly must have a
// strong name but this is not enforced
const IKR.UniverseOptions options = IKR.UniverseOptions.MetadataOnly;
var universe = new IKR.Universe(options);
var asm = universe.LoadFile(templateFile);
// Create missing assemblies, we don't want to load them!
// Code taken from ikdasm
var names = new HashSet <string> ();
IKR.AssemblyName[] assembly_refs = asm.ManifestModule.__GetReferencedAssemblies();
var resolved_assemblies = new IKR.Assembly [assembly_refs.Length];
for (int i = 0; i < resolved_assemblies.Length; i++)
{
string name = assembly_refs [i].Name;
while (names.Contains(name))
{
name = name + "_" + i;
}
names.Add(name);
resolved_assemblies [i] = universe.CreateMissingAssembly(assembly_refs [i].FullName);
}
asm.ManifestModule.__ResolveReferencedAssemblies(resolved_assemblies);
foreach (var attr_data in asm.__GetCustomAttributes(null, false))
{
string asm_name = attr_data.AttributeType.Assembly.GetName().Name;
if (asm_name != "mscorlib")
{
continue;
}
switch (attr_data.AttributeType.FullName)
{
case "System.Reflection.AssemblyKeyFileAttribute": {
if (keyfile != null)
{
// ignore if specified on command line
continue;
}
// / AssemblyKeyFileAttribute .ctor(string keyFile)
string key_file_value = (string)attr_data.ConstructorArguments [0].Value;
if (!String.IsNullOrEmpty(key_file_value))
{
keyfile = Path.Combine(Path.GetDirectoryName(templateFile), key_file_value);
}
}
break;
case "System.Reflection.AssemblyDelaySignAttribute": {
if (delaysign != DelaySign.NotSet)
{
// ignore if specified on command line
continue;
}
// AssemblyDelaySignAttribute .ctor(bool delaySign)
bool delay_sign_value = (bool)attr_data.ConstructorArguments [0].Value;
delaysign = delay_sign_value ? DelaySign.Yes : DelaySign.No;
}
break;
case "System.Reflection.AssemblyKeyNameAttribute": {
if (keyname != null)
{
// ignore if specified on command line
continue;
}
// AssemblyKeyNameAttribute .ctor(string keyName)
string key_name_value = (string)attr_data.ConstructorArguments [0].Value;
// ignore null or zero-length keyname
if (!String.IsNullOrEmpty(key_name_value))
{
keyname = key_name_value;
}
}
break;
}
}
var asm_name_for_template_file = asm.GetName();
aname.Version = asm_name_for_template_file.Version;
aname.HashAlgorithm = asm_name_for_template_file.HashAlgorithm;
return(aname);
}
protected NonPEModule(Universe universe)
: base(universe)
{
}
internal Type GetType(Universe universe, Module context, bool throwOnError, string originalName, bool resolve, bool ignoreCase)
{
Debug.Assert(!resolve || !ignoreCase);
TypeName name = TypeName.Split(this.name);
Type type;
if (assemblyName != null)
{
Assembly asm = universe.Load(assemblyName, context, throwOnError);
if (asm == null)
{
return(null);
}
if (resolve)
{
type = asm.ResolveType(context, name);
}
else if (ignoreCase)
{
type = asm.FindTypeIgnoreCase(name.ToLowerInvariant());
}
else
{
type = asm.FindType(name);
}
}
else if (context == null)
{
if (resolve)
{
type = universe.Mscorlib.ResolveType(context, name);
}
else if (ignoreCase)
{
type = universe.Mscorlib.FindTypeIgnoreCase(name.ToLowerInvariant());
}
else
{
type = universe.Mscorlib.FindType(name);
}
}
else
{
if (ignoreCase)
{
name = name.ToLowerInvariant();
type = context.FindTypeIgnoreCase(name);
}
else
{
type = context.FindType(name);
}
if (type == null && context != universe.Mscorlib.ManifestModule)
{
if (ignoreCase)
{
type = universe.Mscorlib.FindTypeIgnoreCase(name);
}
else
{
type = universe.Mscorlib.FindType(name);
}
}
if (type == null && resolve)
{
if (universe.Mscorlib.__IsMissing && !context.__IsMissing)
{
type = universe.Mscorlib.ResolveType(context, name);
}
else
{
type = context.Assembly.ResolveType(context, name);
}
}
}
return(Expand(type, context, throwOnError, originalName, resolve, ignoreCase));
}
internal MissingAssembly(Universe universe, string name)
: base(universe)
{
module = new MissingModule(this, -1);
this.fullName = name;
}
private static CustomAttributeTypedArgument ReadFixedArg(Assembly asm, ByteReader br, Type type)
{
Universe u = asm.universe;
if (type == u.System_String)
{
return(new CustomAttributeTypedArgument(type, br.ReadString()));
}
else if (type == u.System_Type)
{
return(new CustomAttributeTypedArgument(type, ReadType(asm, br)));
}
else if (type == u.System_Object)
{
return(ReadFixedArg(asm, br, ReadFieldOrPropType(asm, br)));
}
else if (type.IsArray)
{
int length = br.ReadInt32();
if (length == -1)
{
return(new CustomAttributeTypedArgument(type, null));
}
Type elementType = type.GetElementType();
CustomAttributeTypedArgument[] array = new CustomAttributeTypedArgument[length];
for (int i = 0; i < length; i++)
{
array[i] = ReadFixedArg(asm, br, elementType);
}
return(new CustomAttributeTypedArgument(type, array));
}
else if (type.IsEnum)
{
return(new CustomAttributeTypedArgument(type, ReadFixedArg(asm, br, type.GetEnumUnderlyingTypeImpl()).Value));
}
else
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
return(new CustomAttributeTypedArgument(type, br.ReadByte() != 0));
case TypeCode.Char:
return(new CustomAttributeTypedArgument(type, br.ReadChar()));
case TypeCode.Single:
return(new CustomAttributeTypedArgument(type, br.ReadSingle()));
case TypeCode.Double:
return(new CustomAttributeTypedArgument(type, br.ReadDouble()));
case TypeCode.SByte:
return(new CustomAttributeTypedArgument(type, br.ReadSByte()));
case TypeCode.Int16:
return(new CustomAttributeTypedArgument(type, br.ReadInt16()));
case TypeCode.Int32:
return(new CustomAttributeTypedArgument(type, br.ReadInt32()));
case TypeCode.Int64:
return(new CustomAttributeTypedArgument(type, br.ReadInt64()));
case TypeCode.Byte:
return(new CustomAttributeTypedArgument(type, br.ReadByte()));
case TypeCode.UInt16:
return(new CustomAttributeTypedArgument(type, br.ReadUInt16()));
case TypeCode.UInt32:
return(new CustomAttributeTypedArgument(type, br.ReadUInt32()));
case TypeCode.UInt64:
return(new CustomAttributeTypedArgument(type, br.ReadUInt64()));
default:
throw new InvalidOperationException();
}
}
}
