|
public DefineConstructor ( MethodAttributes attribs, CallingConventions callConv, |
||
| attribs | MethodAttributes | |
| callConv | CallingConventions | |
| parameterTypes | ||
| return | IKVM.Reflection.Emit.ConstructorBuilder | |
private static void CreateConstructor(TypeBuilder tb)
{
ConstructorBuilder cb = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { invocationHandlerClass.TypeAsSignatureType });
CodeEmitter ilgen = CodeEmitter.Create(cb);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_1);
proxyConstructor.EmitCall(ilgen);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
private static void CreateStaticInitializer(TypeBuilder tb, List<ProxyMethod> methods)
{
ConstructorBuilder cb = tb.DefineConstructor(MethodAttributes.Static, CallingConventions.Standard, Type.EmptyTypes);
CodeEmitter ilgen = CodeEmitter.Create(cb);
CodeEmitterLocal callerID = ilgen.DeclareLocal([email protected]);
TypeBuilder tbCallerID = DynamicTypeWrapper.FinishContext.EmitCreateCallerID(tb, ilgen);
ilgen.Emit(OpCodes.Stloc, callerID);
// HACK we shouldn't create the nested type here (the outer type must be created first)
tbCallerID.CreateType();
ilgen.BeginExceptionBlock();
foreach (ProxyMethod method in methods)
{
method.mw.DeclaringType.EmitClassLiteral(ilgen);
ilgen.Emit(OpCodes.Ldstr, method.mw.Name);
TypeWrapper[] parameters = method.mw.GetParameters();
ilgen.Emit(OpCodes.Ldc_I4, parameters.Length);
ilgen.Emit(OpCodes.Newarr, CoreClasses.java.lang.Class.Wrapper.TypeAsArrayType);
for (int i = 0; i < parameters.Length; i++)
{
ilgen.Emit(OpCodes.Dup);
ilgen.Emit(OpCodes.Ldc_I4, i);
parameters[i].EmitClassLiteral(ilgen);
ilgen.Emit(OpCodes.Stelem_Ref);
}
if (javaLangClass_getMethod.HasCallerID)
{
ilgen.Emit(OpCodes.Ldloc, callerID);
}
javaLangClass_getMethod.EmitCallvirt(ilgen);
ilgen.Emit(OpCodes.Stsfld, method.fb);
}
CodeEmitterLabel label = ilgen.DefineLabel();
ilgen.Emit(OpCodes.Leave_S, label);
ilgen.BeginCatchBlock(javaLangNoSuchMethodException.TypeAsExceptionType);
javaLangThrowable_getMessage.EmitCallvirt(ilgen);
javaLangNoClassDefFoundErrorConstructor.EmitNewobj(ilgen);
ilgen.Emit(OpCodes.Throw);
ilgen.EndExceptionBlock();
ilgen.MarkLabel(label);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
protected override void EmitMapXmlMetadata(TypeBuilder typeBuilder, ClassFile classFile, FieldWrapper[] fields, MethodWrapper[] methods)
{
Dictionary<string, IKVM.Internal.MapXml.Class> mapxml = classLoader.GetMapXmlClasses();
if(mapxml != null)
{
IKVM.Internal.MapXml.Class clazz;
if(mapxml.TryGetValue(classFile.Name, out clazz))
{
if(clazz.Attributes != null)
{
PublishAttributes(typeBuilder, clazz);
}
if(clazz.Properties != null)
{
PublishProperties(typeBuilder, clazz);
}
if(clazz.Fields != null)
{
foreach(IKVM.Internal.MapXml.Field field in clazz.Fields)
{
if(field.Attributes != null)
{
foreach(FieldWrapper fw in fields)
{
if(fw.Name == field.Name && fw.Signature == field.Sig)
{
FieldBuilder fb = fw.GetField() as FieldBuilder;
if(fb != null)
{
foreach(IKVM.Internal.MapXml.Attribute attr in field.Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, fb, attr);
}
}
}
}
}
}
}
if(clazz.Constructors != null)
{
// HACK this isn't the right place to do this, but for now it suffices
foreach(IKVM.Internal.MapXml.Constructor constructor in clazz.Constructors)
{
// are we adding a new constructor?
if(GetMethodWrapper(StringConstants.INIT, constructor.Sig, false) == null)
{
if(constructor.body == null)
{
Console.Error.WriteLine("Error: Constructor {0}.<init>{1} in xml remap file doesn't have a body.", clazz.Name, constructor.Sig);
continue;
}
bool setmodifiers = false;
MethodAttributes attribs = 0;
MapModifiers(constructor.Modifiers, true, out setmodifiers, ref attribs);
Type returnType;
Type[] parameterTypes;
MapSignature(constructor.Sig, out returnType, out parameterTypes);
ConstructorBuilder cb = typeBuilder.DefineConstructor(attribs, CallingConventions.Standard, parameterTypes);
if(setmodifiers)
{
AttributeHelper.SetModifiers(cb, (Modifiers)constructor.Modifiers, false);
}
CompilerClassLoader.AddDeclaredExceptions(cb, constructor.throws);
CodeEmitter ilgen = CodeEmitter.Create(cb);
constructor.Emit(classLoader, ilgen);
ilgen.DoEmit();
if(constructor.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute attr in constructor.Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, cb, attr);
}
}
}
}
foreach(IKVM.Internal.MapXml.Constructor constructor in clazz.Constructors)
{
if(constructor.Attributes != null)
{
foreach(MethodWrapper mw in methods)
{
if(mw.Name == "<init>" && mw.Signature == constructor.Sig)
{
ConstructorBuilder mb = mw.GetMethod() as ConstructorBuilder;
if(mb != null)
{
foreach(IKVM.Internal.MapXml.Attribute attr in constructor.Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, mb, attr);
}
}
}
}
}
}
}
if(clazz.Methods != null)
{
// HACK this isn't the right place to do this, but for now it suffices
foreach(IKVM.Internal.MapXml.Method method in clazz.Methods)
{
// are we adding a new method?
if(GetMethodWrapper(method.Name, method.Sig, false) == null)
{
if(method.body == null)
{
Console.Error.WriteLine("Error: Method {0}.{1}{2} in xml remap file doesn't have a body.", clazz.Name, method.Name, method.Sig);
continue;
}
bool setmodifiers = false;
MethodAttributes attribs = method.MethodAttributes;
MapModifiers(method.Modifiers, false, out setmodifiers, ref attribs);
Type returnType;
Type[] parameterTypes;
MapSignature(method.Sig, out returnType, out parameterTypes);
MethodBuilder mb = typeBuilder.DefineMethod(method.Name, attribs, returnType, parameterTypes);
if(setmodifiers)
{
AttributeHelper.SetModifiers(mb, (Modifiers)method.Modifiers, false);
}
if(method.@override != null)
{
MethodWrapper mw = GetClassLoader().LoadClassByDottedName([email protected]).GetMethodWrapper([email protected], method.Sig, true);
mw.Link();
typeBuilder.DefineMethodOverride(mb, (MethodInfo)mw.GetMethod());
}
CompilerClassLoader.AddDeclaredExceptions(mb, method.throws);
CodeEmitter ilgen = CodeEmitter.Create(mb);
method.Emit(classLoader, ilgen);
ilgen.DoEmit();
if(method.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute attr in method.Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, mb, attr);
}
}
}
}
foreach(IKVM.Internal.MapXml.Method method in clazz.Methods)
{
if(method.Attributes != null)
{
foreach(MethodWrapper mw in methods)
{
if(mw.Name == method.Name && mw.Signature == method.Sig)
{
MethodBuilder mb = mw.GetMethod() as MethodBuilder;
if(mb != null)
{
foreach(IKVM.Internal.MapXml.Attribute attr in method.Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, mb, attr);
}
}
}
}
}
}
}
if(clazz.Interfaces != null)
{
foreach(IKVM.Internal.MapXml.Interface iface in clazz.Interfaces)
{
TypeWrapper tw = GetClassLoader().LoadClassByDottedName(iface.Name);
// NOTE since this interface won't be part of the list in the ImplementAttribute,
// it won't be visible from Java that the type implements this interface.
typeBuilder.AddInterfaceImplementation(tw.TypeAsBaseType);
if(iface.Methods != null)
{
foreach(IKVM.Internal.MapXml.Method m in iface.Methods)
{
MethodWrapper mw = tw.GetMethodWrapper(m.Name, m.Sig, false);
if(mw == null)
{
throw new InvalidOperationException("Method " + m.Name + m.Sig + " not found in interface " + tw.Name);
}
mw.Link();
MethodBuilder mb = mw.GetDefineMethodHelper().DefineMethod(this, typeBuilder, tw.Name + "/" + m.Name, MethodAttributes.Private | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.CheckAccessOnOverride);
AttributeHelper.HideFromJava(mb);
typeBuilder.DefineMethodOverride(mb, (MethodInfo)mw.GetMethod());
CodeEmitter ilgen = CodeEmitter.Create(mb);
m.Emit(classLoader, ilgen);
ilgen.DoEmit();
}
}
}
}
}
}
}
