internal void Write(IKVM.Reflection.Writer.MetadataWriter mw)
{
mw.Write(Cb);
mw.Write(MajorRuntimeVersion);
mw.Write(MinorRuntimeVersion);
MetaData.Write(mw);
mw.Write(Flags);
mw.Write(EntryPointToken);
Resources.Write(mw);
StrongNameSignature.Write(mw);
CodeManagerTable.Write(mw);
VTableFixups.Write(mw);
ExportAddressTableJumps.Write(mw);
ManagedNativeHeader.Write(mw);
}
public static bool helperDoLoad(
IKVM.Reflection.Type typ,
IKVM.Reflection.ConstructorInfo ikSymtabCtor)
{
// note (1): ikSymtabAttr stands here for loaders.clrTypes.SCALA_SYMTAB_ATTR
// ie. the result of getTypeSafe("scala.runtime.SymtabAttribute")
// note (2): ikSymtabCtor stands here for loaders.clrTypes.SYMTAB_CONSTR
// ie. the result of ikSymtabAttr.GetConstructor(Array(UBYTE.MakeArrayType()))
IKVM.Reflection.Type ikSymtabAttr = ikSymtabCtor.DeclaringType;
IList<IKVM.Reflection.CustomAttributeData> cads = typ.__GetCustomAttributes(null, false); // this prevents ReadFixedArg from being called
foreach(IKVM.Reflection.CustomAttributeData cad in cads) {
if (cad.Constructor.DeclaringType == ikSymtabAttr) {
bool res = (cad.Constructor == ikSymtabCtor);
return res;
}
}
return true; // always load non-scala types
}
internal void Write(IKVM.Reflection.Writer.MetadataWriter mw)
{
mw.Write(Cb);
mw.Write(MajorRuntimeVersion);
mw.Write(MinorRuntimeVersion);
mw.Write(MetaDataRVA);
mw.Write(MetaDataSize);
mw.Write(Flags);
mw.Write(EntryPointToken);
mw.Write(ResourcesRVA);
mw.Write(ResourcesSize);
mw.Write(StrongNameSignatureRVA);
mw.Write(StrongNameSignatureSize);
mw.Write(CodeManagerTable);
mw.Write(VTableFixupsRVA);
mw.Write(VTableFixupsSize);
mw.Write(ExportAddressTableJumps);
mw.Write(ManagedNativeHeader);
}
Assembly _universe_AssemblyResolve(object sender, IKVM.Reflection.ResolveEventArgs args) {
AssemblyName name = new AssemblyName(args.Name);
AssemblyName previousMatch = null;
int previousMatchLevel = 0;
foreach (Assembly asm in _universe.GetAssemblies()) {
if (Match(asm.GetName(), name, ref previousMatch, ref previousMatchLevel)) {
return asm;
}
}
foreach (string file in FindAssemblyPath(name.Name + ".dll")) {
if (Match(AssemblyName.GetAssemblyName(file), name, ref previousMatch, ref previousMatchLevel)) {
return LoadFile(file);
}
}
if (args.RequestingAssembly != null) {
string path = Path.Combine(Path.GetDirectoryName(args.RequestingAssembly.Location), name.Name + ".dll");
if (File.Exists(path) && Match(AssemblyName.GetAssemblyName(path), name, ref previousMatch, ref previousMatchLevel)) {
return LoadFile(path);
}
}
string hintpath;
if (_hintpaths.TryGetValue(name.FullName, out hintpath)) {
string path = Path.Combine(hintpath, name.Name + ".dll");
if (File.Exists(path) && Match(AssemblyName.GetAssemblyName(path), name, ref previousMatch, ref previousMatchLevel)) {
return LoadFile(path);
}
}
if (previousMatch != null) {
if (previousMatchLevel == 2) {
ConsoleOps.Warning("assuming assembly reference '{0}' matches '{1}', you may need to supply runtime policy", previousMatch.FullName, name.FullName);
return LoadFile(new Uri(previousMatch.CodeBase).LocalPath);
} else if (args.RequestingAssembly != null) {
ConsoleOps.Error(true, "Assembly '{0}' uses '{1}' which has a higher version than referenced assembly '{2}'", args.RequestingAssembly.FullName, name.FullName, previousMatch.FullName);
} else {
ConsoleOps.Error(true, "Assembly '{0}' was requested which is a higher version than referenced assembly '{1}'", name.FullName, previousMatch.FullName);
}
} else {
ConsoleOps.Error(true, "unable to find assembly '{0}' {1}", args.Name, args.RequestingAssembly != null ? string.Format(" (a dependency of '{0}')", args.RequestingAssembly.FullName) : string.Empty);
}
return null;
}
public static byte[] helperGetPickle(
IKVM.Reflection.Type typ,
IKVM.Reflection.ConstructorInfo ikSymtabCtor)
{
// note: ikSymtabCtor stands here for loaders.clrTypes.SYMTAB_CONSTR
// ie. the result of getTypeSafe("scala.runtime.SymtabAttribute").GetConstructor(Array(UBYTE.MakeArrayType()))
IList<IKVM.Reflection.CustomAttributeData> cads = typ.__GetCustomAttributes(null, false); // this prevents ReadFixedArg from being called
foreach(IKVM.Reflection.CustomAttributeData cad in cads) {
if (cad.Constructor == ikSymtabCtor) {
byte[] blob = cad.__GetBlob();
// blob starts with
// prolog 01 00
// length LL LH HL HH
// where
// int pos = 2;
// int length = ((int) blob[pos++] | (int) blob[pos++] << 8 | (int) blob[pos++] << 16 | (int) blob[pos++] << 24);
// and then comes the real data starting with blob[6] inclusive. That's why we give 6 as offset to unpickle.
// byte[] dest = new byte[length];
// Array.Copy(blob, 6, dest, 0, length);
return blob;
}
}
return null;
}
private void SetupGhosts(IKVM.Internal.MapXml.Root map)
{
ghosts = new Dictionary<string, List<TypeWrapper>>();
// find the ghost interfaces
foreach(IKVM.Internal.MapXml.Class c in map.assembly.Classes)
{
if(c.Shadows != null && c.Interfaces != null)
{
// NOTE we don't support interfaces that inherit from other interfaces
// (actually, if they are explicitly listed it would probably work)
TypeWrapper typeWrapper = GetLoadedClass(c.Name);
foreach(IKVM.Internal.MapXml.Interface iface in c.Interfaces)
{
TypeWrapper ifaceWrapper = GetLoadedClass(iface.Name);
if(ifaceWrapper == null || !ifaceWrapper.TypeAsTBD.IsAssignableFrom(typeWrapper.TypeAsTBD))
{
AddGhost(iface.Name, typeWrapper);
}
}
}
}
// we manually add the array ghost interfaces
TypeWrapper array = ClassLoaderWrapper.GetWrapperFromType(Types.Array);
AddGhost("java.io.Serializable", array);
AddGhost("java.lang.Cloneable", array);
}
private bool ValidateAndSetMap(IKVM.Internal.MapXml.Root map)
{
bool valid = true;
if (map.assembly != null)
{
if (map.assembly.Classes != null)
{
foreach (IKVM.Internal.MapXml.Class c in map.assembly.Classes)
{
if (c.Fields != null)
{
foreach (IKVM.Internal.MapXml.Field f in c.Fields)
{
ValidateNameSig("field", c.Name, f.Name, f.Sig, ref valid, true);
}
}
if (c.Methods != null)
{
foreach (IKVM.Internal.MapXml.Method m in c.Methods)
{
ValidateNameSig("method", c.Name, m.Name, m.Sig, ref valid, false);
}
}
if (c.Constructors != null)
{
foreach (IKVM.Internal.MapXml.Constructor ctor in c.Constructors)
{
ValidateNameSig("constructor", c.Name, "<init>", ctor.Sig, ref valid, false);
}
}
if (c.Properties != null)
{
foreach (IKVM.Internal.MapXml.Property prop in c.Properties)
{
ValidateNameSig("property", c.Name, prop.Name, prop.Sig, ref valid, false);
ValidatePropertyGetterSetter("getter", c.Name, prop.Name, prop.getter, ref valid);
ValidatePropertyGetterSetter("setter", c.Name, prop.Name, prop.setter, ref valid);
}
}
}
}
}
this.map = map;
return valid;
}
private void AddMapXmlMethods(string className, IKVM.Internal.MapXml.MethodBase[] methods)
{
if(methods != null)
{
foreach(IKVM.Internal.MapXml.MethodBase method in methods)
{
AddMapXmlMethod(className, method);
}
}
}
private void AddMapXmlMethod(string className, IKVM.Internal.MapXml.MethodBase method)
{
if(method.body != null)
{
mapxml_MethodBodies.Add(method.ToMethodKey(className), method.body);
}
if(method.ReplaceMethodCalls != null)
{
mapxml_ReplacedMethods.Add(method.ToMethodKey(className), method.ReplaceMethodCalls);
}
if (method.prologue != null)
{
mapxml_MethodPrologues.Add(method.ToMethodKey(className), method.prologue);
}
}
internal void LoadInterfaces(IKVM.Internal.MapXml.Class c)
{
if (c.Interfaces != null)
{
interfaceWrappers = new TypeWrapper[c.Interfaces.Length];
for (int i = 0; i < c.Interfaces.Length; i++)
{
interfaceWrappers[i] = classLoader.LoadClassByDottedName(c.Interfaces[i].Name);
}
}
else
{
interfaceWrappers = TypeWrapper.EmptyArray;
}
}
internal void Write(IKVM.Reflection.Writer.MetadataWriter mw)
{
mw.Write(VirtualAddress);
mw.Write(Size);
}
internal static void AddDeclaredExceptions(MethodBase mb, IKVM.Internal.MapXml.Throws[] throws)
{
if (throws != null)
{
string[] exceptions = new string[throws.Length];
for (int i = 0; i < exceptions.Length; i++)
{
exceptions[i] = throws[i].Class;
}
AttributeHelper.SetThrowsAttribute(mb, exceptions);
}
}
private static TypeWrapper GetBaseWrapper(IKVM.Internal.MapXml.Class c)
{
if((c.Modifiers & IKVM.Internal.MapXml.MapModifiers.Interface) != 0)
{
return null;
}
if(c.Name == "java.lang.Object")
{
return null;
}
return CoreClasses.java.lang.Object.Wrapper;
}
private static void SetParameters(ClassLoaderWrapper loader, ConstructorBuilder cb, IKVM.Internal.MapXml.Param[] parameters)
{
if(parameters != null)
{
for(int i = 0; i < parameters.Length; i++)
{
ParameterBuilder pb = cb.DefineParameter(i + 1, ParameterAttributes.None, parameters[i].Name);
if(parameters[i].Attributes != null)
{
for(int j = 0; j < parameters[i].Attributes.Length; j++)
{
AttributeHelper.SetCustomAttribute(loader, pb, parameters[i].Attributes[j]);
}
}
}
}
}
internal void Process2ndPassStep2(IKVM.Internal.MapXml.Root map)
{
IKVM.Internal.MapXml.Class c = classDef;
TypeBuilder tb = typeBuilder;
List<FieldWrapper> fields = new List<FieldWrapper>();
// TODO fields should be moved to the RemapperTypeWrapper constructor as well
if(c.Fields != null)
{
foreach(IKVM.Internal.MapXml.Field f in c.Fields)
{
{
FieldAttributes attr = MapFieldAccessModifiers(f.Modifiers);
if(f.Constant != null)
{
attr |= FieldAttributes.Literal;
}
else if((f.Modifiers & IKVM.Internal.MapXml.MapModifiers.Final) != 0)
{
attr |= FieldAttributes.InitOnly;
}
if((f.Modifiers & IKVM.Internal.MapXml.MapModifiers.Static) != 0)
{
attr |= FieldAttributes.Static;
}
FieldBuilder fb = tb.DefineField(f.Name, GetClassLoader().FieldTypeWrapperFromSig(f.Sig).TypeAsSignatureType, attr);
if(f.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute custattr in f.Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, fb, custattr);
}
}
object constant;
if(f.Constant != null)
{
switch(f.Sig[0])
{
case 'J':
constant = long.Parse(f.Constant);
break;
default:
// TODO support other types
throw new NotImplementedException("remapped constant field of type: " + f.Sig);
}
fb.SetConstant(constant);
fields.Add(new ConstantFieldWrapper(this, GetClassLoader().FieldTypeWrapperFromSig(f.Sig), f.Name, f.Sig, (Modifiers)f.Modifiers, fb, constant, MemberFlags.None));
}
else
{
fields.Add(FieldWrapper.Create(this, GetClassLoader().FieldTypeWrapperFromSig(f.Sig), fb, f.Name, f.Sig, new ExModifiers((Modifiers)f.Modifiers, false)));
}
}
}
}
SetFields(fields.ToArray());
}
private static bool IsHideFromJava(IKVM.Internal.MapXml.Method m)
{
if (m.Attributes != null)
{
foreach (MapXml.Attribute attr in m.Attributes)
{
if (attr.Type == "IKVM.Attributes.HideFromJavaAttribute")
{
return true;
}
}
}
return false;
}
internal RemappedMethodWrapper(RemapperTypeWrapper typeWrapper, IKVM.Internal.MapXml.Method m, IKVM.Internal.MapXml.Root map, bool inherited)
: base(typeWrapper, m.Name, m.Sig, (Modifiers)m.Modifiers)
{
this.m = m;
this.map = map;
this.inherited = inherited;
}
internal RemappedConstructorWrapper(RemapperTypeWrapper typeWrapper, IKVM.Internal.MapXml.Constructor m)
: base(typeWrapper, "<init>", m.Sig, (Modifiers)m.Modifiers)
{
this.m = m;
}
private static void ValidatePropertyGetterSetter(string getterOrSetter, string clazz, string property, IKVM.Internal.MapXml.Method method, ref bool valid)
{
if (method != null)
{
if (!IsValidName(method.Name))
{
valid = false;
StaticCompiler.IssueMessage(Message.InvalidPropertyNameInMapFile, getterOrSetter, clazz, property, method.Name);
}
if (!ClassFile.IsValidMethodSig(method.Sig))
{
valid = false;
StaticCompiler.IssueMessage(Message.InvalidPropertySignatureInMapFile, getterOrSetter, clazz, property, method.Sig);
}
}
}
internal void LoadMappedExceptions(IKVM.Internal.MapXml.Root map)
{
if(map.exceptionMappings != null)
{
mappedExceptionsAllSubClasses = new bool[map.exceptionMappings.Length];
mappedExceptions = new TypeWrapper[map.exceptionMappings.Length];
for(int i = 0; i < mappedExceptions.Length; i++)
{
string dst = map.exceptionMappings[i].dst;
if(dst[0] == '*')
{
mappedExceptionsAllSubClasses[i] = true;
dst = dst.Substring(1);
}
mappedExceptions[i] = LoadClassByDottedName(dst);
}
// HACK we need to find the <exceptionMapping /> element and bind it
foreach(IKVM.Internal.MapXml.Class c in map.assembly.Classes)
{
if(c.Methods != null)
{
foreach(IKVM.Internal.MapXml.Method m in c.Methods)
{
if(m.body != null && m.body.invoke != null)
{
foreach(IKVM.Internal.MapXml.Instruction instr in m.body.invoke)
{
IKVM.Internal.MapXml.EmitExceptionMapping eem = instr as IKVM.Internal.MapXml.EmitExceptionMapping;
if(eem != null)
{
eem.mapping = map.exceptionMappings;
}
}
}
}
}
}
}
}
private static FieldAttributes MapFieldAccessModifiers(IKVM.Internal.MapXml.MapModifiers mod)
{
const IKVM.Internal.MapXml.MapModifiers access = IKVM.Internal.MapXml.MapModifiers.Public | IKVM.Internal.MapXml.MapModifiers.Protected | IKVM.Internal.MapXml.MapModifiers.Private;
switch(mod & access)
{
case IKVM.Internal.MapXml.MapModifiers.Public:
return FieldAttributes.Public;
case IKVM.Internal.MapXml.MapModifiers.Protected:
return FieldAttributes.FamORAssem;
case IKVM.Internal.MapXml.MapModifiers.Private:
return FieldAttributes.Private;
default:
return FieldAttributes.Assembly;
}
}
internal override int ImportTo(IKVM.Reflection.Emit.ModuleBuilder module)
{
MethodInfo method = TryGetForwarder();
if (method != null)
{
return method.ImportTo(module);
}
return module.ImportMethodOrField(declaringType, this.Name, this.MethodSignature);
}
internal RemapperTypeWrapper(CompilerClassLoader classLoader, IKVM.Internal.MapXml.Class c, IKVM.Internal.MapXml.Root map)
: base((Modifiers)c.Modifiers, c.Name)
{
this.classLoader = classLoader;
this.baseTypeWrapper = GetBaseWrapper(c);
classDef = c;
bool baseIsSealed = false;
shadowType = StaticCompiler.Universe.GetType(c.Shadows, true);
classLoader.SetRemappedType(shadowType, this);
Type baseType = shadowType;
Type baseInterface = null;
if(baseType.IsInterface)
{
baseInterface = baseType;
}
TypeAttributes attrs = TypeAttributes.Public;
if((c.Modifiers & IKVM.Internal.MapXml.MapModifiers.Interface) == 0)
{
attrs |= TypeAttributes.Class;
if(baseType.IsSealed)
{
baseIsSealed = true;
attrs |= TypeAttributes.Abstract | TypeAttributes.Sealed;
}
}
else
{
attrs |= TypeAttributes.Interface | TypeAttributes.Abstract;
baseType = null;
}
if((c.Modifiers & IKVM.Internal.MapXml.MapModifiers.Abstract) != 0)
{
attrs |= TypeAttributes.Abstract;
}
string name = c.Name.Replace('/', '.');
typeBuilder = classLoader.GetTypeWrapperFactory().ModuleBuilder.DefineType(name, attrs, baseIsSealed ? Types.Object : baseType);
if(c.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute custattr in c.Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, typeBuilder, custattr);
}
}
if(baseInterface != null)
{
typeBuilder.AddInterfaceImplementation(baseInterface);
}
if(classLoader.EmitStackTraceInfo)
{
AttributeHelper.SetSourceFile(typeBuilder, Path.GetFileName(classLoader.options.remapfile));
}
if(baseIsSealed)
{
AttributeHelper.SetModifiers(typeBuilder, (Modifiers)c.Modifiers, false);
}
if(c.scope == IKVM.Internal.MapXml.Scope.Public)
{
// FXBUG we would like to emit an attribute with a Type argument here, but that doesn't work because
// of a bug in SetCustomAttribute that causes type arguments to be serialized incorrectly (if the type
// is in the same assembly). Normally we use AttributeHelper.FreezeDry to get around this, but that doesn't
// work in this case (no attribute is emitted at all). So we work around by emitting a string instead
AttributeHelper.SetRemappedClass(classLoader.assemblyBuilder, name, shadowType);
AttributeHelper.SetRemappedType(typeBuilder, shadowType);
}
List<MethodWrapper> methods = new List<MethodWrapper>();
if(c.Constructors != null)
{
foreach(IKVM.Internal.MapXml.Constructor m in c.Constructors)
{
methods.Add(new RemappedConstructorWrapper(this, m));
}
}
if(c.Methods != null)
{
foreach(IKVM.Internal.MapXml.Method m in c.Methods)
{
methods.Add(new RemappedMethodWrapper(this, m, map, false));
}
}
// add methods from our super classes (e.g. Throwable should have Object's methods)
if(!this.IsFinal && !this.IsInterface && this.BaseTypeWrapper != null)
{
foreach(MethodWrapper mw in BaseTypeWrapper.GetMethods())
{
RemappedMethodWrapper rmw = mw as RemappedMethodWrapper;
if(rmw != null && (rmw.IsPublic || rmw.IsProtected))
{
if(!FindMethod(methods, rmw.Name, rmw.Signature))
{
methods.Add(new RemappedMethodWrapper(this, rmw.XmlMethod, map, true));
}
}
}
}
SetMethods(methods.ToArray());
}
internal ReplacedMethodWrapper(TypeWrapper tw, string name, string sig, IKVM.Internal.MapXml.InstructionList code)
: base(tw, name, sig, null, null, null, Modifiers.Public, MemberFlags.None)
{
this.code = code;
}
internal override void ExportTypes(int fileToken, IKVM.Reflection.Emit.ModuleBuilder manifestModule)
{
throw new MissingModuleException(this);
}
internal ReplacedMethodWrapper(ClassFile.ConstantPoolItemMI cpi, IKVM.Internal.MapXml.InstructionList code)
: base(cpi.GetClassType(), cpi.Name, cpi.Signature, null, cpi.GetRetType(), cpi.GetArgTypes(), Modifiers.Public, MemberFlags.None)
{
this.code = code;
}
internal ExceptionMapEmitter(IKVM.Internal.MapXml.ExceptionMapping[] map)
{
this.map = map;
}
private void PublishProperties(TypeBuilder typeBuilder, IKVM.Internal.MapXml.Class clazz)
{
foreach(IKVM.Internal.MapXml.Property prop in clazz.Properties)
{
TypeWrapper typeWrapper = GetClassLoader().RetTypeWrapperFromSigNoThrow(prop.Sig);
TypeWrapper[] propargs = GetClassLoader().ArgTypeWrapperListFromSigNoThrow(prop.Sig);
Type[] indexer = new Type[propargs.Length];
for(int i = 0; i < propargs.Length; i++)
{
indexer[i] = propargs[i].TypeAsSignatureType;
}
PropertyBuilder propbuilder = typeBuilder.DefineProperty(prop.Name, PropertyAttributes.None, typeWrapper.TypeAsSignatureType, indexer);
AttributeHelper.HideFromJava(propbuilder);
if(prop.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute attr in prop.Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, propbuilder, attr);
}
}
MethodWrapper getter = null;
MethodWrapper setter = null;
if(prop.getter != null)
{
getter = GetMethodWrapper(prop.getter.Name, prop.getter.Sig, true);
if(getter == null)
{
Console.Error.WriteLine("Warning: getter not found for {0}::{1}", clazz.Name, prop.Name);
}
}
if(prop.setter != null)
{
setter = GetMethodWrapper(prop.setter.Name, prop.setter.Sig, true);
if(setter == null)
{
Console.Error.WriteLine("Warning: setter not found for {0}::{1}", clazz.Name, prop.Name);
}
}
bool final = (getter != null && getter.IsFinal) || (setter != null && setter.IsFinal);
if(getter != null)
{
MethodWrapper mw = getter;
if(!CheckPropertyArgs(mw.GetParametersForDefineMethod(), indexer) || mw.ReturnType != typeWrapper)
{
Console.Error.WriteLine("Warning: ignoring invalid property getter for {0}::{1}", clazz.Name, prop.Name);
}
else
{
MethodBuilder mb = mw.GetMethod() as MethodBuilder;
if(mb == null || mb.DeclaringType != typeBuilder || (!mb.IsFinal && final))
{
mb = typeBuilder.DefineMethod("get_" + prop.Name, GetPropertyMethodAttributes(mw, final), typeWrapper.TypeAsSignatureType, indexer);
AttributeHelper.HideFromJava(mb);
CodeEmitter ilgen = CodeEmitter.Create(mb);
if(mw.IsStatic)
{
for(int i = 0; i < indexer.Length; i++)
{
ilgen.EmitLdarg(i);
}
mw.EmitCall(ilgen);
}
else
{
ilgen.Emit(OpCodes.Ldarg_0);
for(int i = 0; i < indexer.Length; i++)
{
ilgen.EmitLdarg(i + 1);
}
mw.EmitCallvirt(ilgen);
}
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
propbuilder.SetGetMethod(mb);
}
}
if(setter != null)
{
MethodWrapper mw = setter;
Type[] args = new Type[indexer.Length + 1];
indexer.CopyTo(args, 0);
args[args.Length - 1] = typeWrapper.TypeAsSignatureType;
if(!CheckPropertyArgs(args, mw.GetParametersForDefineMethod()))
{
Console.Error.WriteLine("Warning: ignoring invalid property setter for {0}::{1}", clazz.Name, prop.Name);
}
else
{
MethodBuilder mb = mw.GetMethod() as MethodBuilder;
if(mb == null || mb.DeclaringType != typeBuilder || (!mb.IsFinal && final))
{
mb = typeBuilder.DefineMethod("set_" + prop.Name, GetPropertyMethodAttributes(mw, final), mw.ReturnTypeForDefineMethod, args);
AttributeHelper.HideFromJava(mb);
CodeEmitter ilgen = CodeEmitter.Create(mb);
if(mw.IsStatic)
{
for(int i = 0; i <= indexer.Length; i++)
{
ilgen.EmitLdarg(i);
}
mw.EmitCall(ilgen);
}
else
{
ilgen.Emit(OpCodes.Ldarg_0);
for(int i = 0; i <= indexer.Length; i++)
{
ilgen.EmitLdarg(i + 1);
}
mw.EmitCallvirt(ilgen);
}
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
propbuilder.SetSetMethod(mb);
}
}
}
}
internal override void ExportTypes(int fileToken, IKVM.Reflection.Emit.ModuleBuilder manifestModule)
{
PopulateTypeDef();
manifestModule.ExportTypes(typeDefs, fileToken);
}
internal void Emit(IKVM.Internal.MapXml.CodeGenContext context, CodeEmitter ilgen)
{
MethodWrapper mwSuppressFillInStackTrace = CoreClasses.java.lang.Throwable.Wrapper.GetMethodWrapper("__<suppressFillInStackTrace>", "()V", false);
mwSuppressFillInStackTrace.Link();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Callvirt, Compiler.getTypeMethod);
for(int i = 0; i < map.Length; i++)
{
ilgen.Emit(OpCodes.Dup);
ilgen.Emit(OpCodes.Ldtoken, StaticCompiler.Universe.GetType(map[i].src, true));
ilgen.Emit(OpCodes.Call, Compiler.getTypeFromHandleMethod);
ilgen.Emit(OpCodes.Ceq);
CodeEmitterLabel label = ilgen.DefineLabel();
ilgen.Emit(OpCodes.Brfalse_S, label);
ilgen.Emit(OpCodes.Pop);
if(map[i].code != null)
{
ilgen.Emit(OpCodes.Ldarg_0);
if(map[i].code.invoke != null)
{
foreach(MapXml.Instruction instr in map[i].code.invoke)
{
MapXml.NewObj newobj = instr as MapXml.NewObj;
if(newobj != null
&& newobj.Class != null
&& context.ClassLoader.LoadClassByDottedName(newobj.Class).IsSubTypeOf(CoreClasses.java.lang.Throwable.Wrapper))
{
mwSuppressFillInStackTrace.EmitCall(ilgen);
}
instr.Generate(context, ilgen);
}
}
ilgen.Emit(OpCodes.Ret);
}
else
{
TypeWrapper tw = context.ClassLoader.LoadClassByDottedName(map[i].dst);
MethodWrapper mw = tw.GetMethodWrapper("<init>", "()V", false);
mw.Link();
mwSuppressFillInStackTrace.EmitCall(ilgen);
mw.EmitNewobj(ilgen);
ilgen.Emit(OpCodes.Ret);
}
ilgen.MarkLabel(label);
}
ilgen.Emit(OpCodes.Pop);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ret);
}
