private void PatchCallingConvention(MethodBuilder mdBuilder)
{
if (patchCallingConvention && !mdBuilder.IsStatic)
{
sig.HasThis = true;
}
}
public void AddOtherMethod(MethodBuilder mdBuilder)
{
Accessor acc;
acc.Semantics = MethodSemanticsTable.Other;
acc.Method = mdBuilder;
accessors.Add(acc);
}
public void AddOtherMethod(MethodBuilder mdBuilder)
{
if (otherMethods == null)
{
otherMethods = new List<MethodBuilder>();
}
otherMethods.Add(mdBuilder);
}
public void SetSetMethod(MethodBuilder mdBuilder)
{
setter = mdBuilder;
Accessor acc;
acc.Semantics = MethodSemanticsTable.Setter;
acc.Method = mdBuilder;
accessors.Add(acc);
}
public void SetRemoveOnMethod(MethodBuilder mdBuilder)
{
removeOnMethod = mdBuilder;
Accessor acc;
acc.Semantics = MethodSemanticsTable.RemoveOn;
acc.Method = mdBuilder;
accessors.Add(acc);
}
public void SetRaiseMethod(MethodBuilder mdBuilder)
{
fireMethod = mdBuilder;
Accessor acc;
acc.Semantics = MethodSemanticsTable.Fire;
acc.Method = mdBuilder;
accessors.Add(acc);
}
public void AddOtherMethod(MethodBuilder mdBuilder)
{
PatchCallingConvention(mdBuilder);
if (otherMethods == null)
{
otherMethods = new List<MethodBuilder>();
}
otherMethods.Add(mdBuilder);
}
internal GenericTypeParameterBuilder(string name, TypeBuilder type, MethodBuilder method, int position)
{
this.name = name;
this.type = type;
this.method = method;
this.position = position;
GenericParamTable.Record rec = new GenericParamTable.Record();
rec.Number = (short)position;
rec.Flags = 0;
rec.Owner = type != null ? type.MetadataToken : method.MetadataToken;
rec.Name = this.ModuleBuilder.Strings.Add(name);
this.paramPseudoIndex = this.ModuleBuilder.GenericParam.AddRecord(rec);
}
internal override int ImportTo(Emit.ModuleBuilder module)
{
if (methodArgs == null)
{
return(module.ImportMethodOrField(declaringType, method.Name, method.MethodSignature));
}
else
{
Writer.ByteBuffer spec = new Writer.ByteBuffer(10);
Signature.WriteMethodSpec(module, spec, methodArgs);
Metadata.MethodSpecTable.Record rec = new Metadata.MethodSpecTable.Record();
Emit.MethodBuilder mb = method as Emit.MethodBuilder;
if (mb != null && mb.ModuleBuilder == module && !declaringType.IsGenericType)
{
rec.Method = mb.MetadataToken;
}
else
{
rec.Method = module.ImportMember(GetGenericMethodDefinition());
}
rec.Instantiation = module.Blobs.Add(spec);
return(0x2B000000 | module.MethodSpec.FindOrAddRecord(rec));
}
}
internal override MethodBase DoLink()
{
RemapperTypeWrapper typeWrapper = (RemapperTypeWrapper)DeclaringType;
if(typeWrapper.IsInterface)
{
if(m.@override == null)
{
throw new InvalidOperationException(typeWrapper.Name + "." + m.Name + m.Sig);
}
MethodInfo interfaceMethod = typeWrapper.shadowType.GetMethod([email protected], typeWrapper.GetClassLoader().ArgTypeListFromSig(m.Sig));
if(interfaceMethod == null)
{
throw new InvalidOperationException(typeWrapper.Name + "." + m.Name + m.Sig);
}
// if any of the remapped types has a body for this interface method, we need a helper method
// to special invocation through this interface for that type
List<IKVM.Internal.MapXml.Class> specialCases = null;
foreach(IKVM.Internal.MapXml.Class c in map.assembly.Classes)
{
if(c.Methods != null)
{
foreach(IKVM.Internal.MapXml.Method mm in c.Methods)
{
if(mm.Name == m.Name && mm.Sig == m.Sig && mm.body != null)
{
if(specialCases == null)
{
specialCases = new List<IKVM.Internal.MapXml.Class>();
}
specialCases.Add(c);
break;
}
}
}
}
string[] throws;
if (m.throws == null)
{
throws = new string[0];
}
else
{
throws = new string[m.throws.Length];
for (int i = 0; i < throws.Length; i++)
{
throws[i] = m.throws[i].Class;
}
}
AttributeHelper.SetRemappedInterfaceMethod(typeWrapper.typeBuilder, m.Name, [email protected], throws);
MethodBuilder helper = null;
if(specialCases != null)
{
CodeEmitter ilgen;
Type[] temp = typeWrapper.GetClassLoader().ArgTypeListFromSig(m.Sig);
Type[] argTypes = new Type[temp.Length + 1];
temp.CopyTo(argTypes, 1);
argTypes[0] = typeWrapper.shadowType;
if(typeWrapper.helperTypeBuilder == null)
{
// FXBUG we use a nested helper class, because Reflection.Emit won't allow us to add a static method to the interface
// TODO now that we're on Whidbey we can remove this workaround
typeWrapper.helperTypeBuilder = typeWrapper.typeBuilder.DefineNestedType("__Helper", TypeAttributes.NestedPublic | TypeAttributes.Class | TypeAttributes.Sealed);
ilgen = CodeEmitter.Create(typeWrapper.helperTypeBuilder.DefineConstructor(MethodAttributes.Private, CallingConventions.Standard, Type.EmptyTypes));
ilgen.Emit(OpCodes.Ldnull);
ilgen.Emit(OpCodes.Throw);
ilgen.DoEmit();
AttributeHelper.HideFromJava(typeWrapper.helperTypeBuilder);
}
helper = typeWrapper.helperTypeBuilder.DefineMethod(m.Name, MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static, typeWrapper.GetClassLoader().RetTypeWrapperFromSig(m.Sig).TypeAsSignatureType, argTypes);
if(m.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute custattr in m.Attributes)
{
AttributeHelper.SetCustomAttribute(DeclaringType.GetClassLoader(), helper, custattr);
}
}
SetParameters(DeclaringType.GetClassLoader(), helper, m.Params);
ilgen = CodeEmitter.Create(helper);
foreach(IKVM.Internal.MapXml.Class c in specialCases)
{
TypeWrapper tw = typeWrapper.GetClassLoader().LoadClassByDottedName(c.Name);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Isinst, tw.TypeAsTBD);
ilgen.Emit(OpCodes.Dup);
CodeEmitterLabel label = ilgen.DefineLabel();
ilgen.Emit(OpCodes.Brfalse_S, label);
for(int i = 1; i < argTypes.Length; i++)
{
ilgen.Emit(OpCodes.Ldarg, (short)i);
}
MethodWrapper mw = tw.GetMethodWrapper(m.Name, m.Sig, false);
mw.Link();
mw.EmitCallvirt(ilgen);
ilgen.Emit(OpCodes.Ret);
ilgen.MarkLabel(label);
ilgen.Emit(OpCodes.Pop);
}
for(int i = 0; i < argTypes.Length; i++)
{
ilgen.Emit(OpCodes.Ldarg, (short)i);
}
ilgen.Emit(OpCodes.Callvirt, interfaceMethod);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
mbHelper = helper;
return interfaceMethod;
}
else
{
MethodBuilder mbCore = null;
Type[] paramTypes = typeWrapper.GetClassLoader().ArgTypeListFromSig(m.Sig);
Type retType = typeWrapper.GetClassLoader().RetTypeWrapperFromSig(m.Sig).TypeAsSignatureType;
if(typeWrapper.shadowType.IsSealed && (m.Modifiers & IKVM.Internal.MapXml.MapModifiers.Static) == 0)
{
// skip instance methods in sealed types, but we do need to add them to the overriders
if(typeWrapper.BaseTypeWrapper != null && (m.Modifiers & IKVM.Internal.MapXml.MapModifiers.Private) == 0)
{
RemappedMethodWrapper baseMethod = typeWrapper.BaseTypeWrapper.GetMethodWrapper(m.Name, m.Sig, true) as RemappedMethodWrapper;
if(baseMethod != null &&
!baseMethod.IsFinal &&
!baseMethod.IsPrivate &&
(baseMethod.m.@override != null ||
baseMethod.m.redirect != null ||
baseMethod.m.body != null ||
baseMethod.m.alternateBody != null))
{
baseMethod.overriders.Add(typeWrapper);
}
}
}
else
{
MethodInfo overrideMethod = null;
MethodAttributes attr = MapMethodAccessModifiers(m.Modifiers) | MethodAttributes.HideBySig;
if((m.Modifiers & IKVM.Internal.MapXml.MapModifiers.Static) != 0)
{
attr |= MethodAttributes.Static;
}
else if((m.Modifiers & IKVM.Internal.MapXml.MapModifiers.Private) == 0 && (m.Modifiers & IKVM.Internal.MapXml.MapModifiers.Final) == 0)
{
attr |= MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.CheckAccessOnOverride;
if(!typeWrapper.shadowType.IsSealed)
{
MethodInfo autoOverride = typeWrapper.shadowType.GetMethod(m.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, paramTypes, null);
if(autoOverride != null && autoOverride.ReturnType == retType && !autoOverride.IsFinal)
{
// the method we're processing is overriding a method in its shadowType (which is the actual base type)
attr &= ~MethodAttributes.NewSlot;
}
}
if(typeWrapper.BaseTypeWrapper != null)
{
RemappedMethodWrapper baseMethod = typeWrapper.BaseTypeWrapper.GetMethodWrapper(m.Name, m.Sig, true) as RemappedMethodWrapper;
if(baseMethod != null)
{
baseMethod.overriders.Add(typeWrapper);
if(baseMethod.m.@override != null)
{
overrideMethod = typeWrapper.BaseTypeWrapper.TypeAsTBD.GetMethod([email protected], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, paramTypes, null);
if(overrideMethod == null)
{
throw new InvalidOperationException();
}
}
}
}
}
mbCore = typeWrapper.typeBuilder.DefineMethod(m.Name, attr, CallingConventions.Standard, retType, paramTypes);
if(m.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute custattr in m.Attributes)
{
AttributeHelper.SetCustomAttribute(DeclaringType.GetClassLoader(), mbCore, custattr);
}
}
SetParameters(DeclaringType.GetClassLoader(), mbCore, m.Params);
if(overrideMethod != null && !inherited)
{
typeWrapper.typeBuilder.DefineMethodOverride(mbCore, overrideMethod);
}
if(inherited)
{
AttributeHelper.HideFromReflection(mbCore);
}
AddDeclaredExceptions(mbCore, m.throws);
}
if((m.Modifiers & IKVM.Internal.MapXml.MapModifiers.Static) == 0 && !IsHideFromJava(m))
{
// instance methods must have an instancehelper method
MethodAttributes attr = MapMethodAccessModifiers(m.Modifiers) | MethodAttributes.HideBySig | MethodAttributes.Static;
// NOTE instancehelpers for protected methods are made internal
// and special cased in DotNetTypeWrapper.LazyPublishMembers
if((m.Modifiers & IKVM.Internal.MapXml.MapModifiers.Protected) != 0)
{
attr &= ~MethodAttributes.MemberAccessMask;
attr |= MethodAttributes.Assembly;
}
Type[] exParamTypes = new Type[paramTypes.Length + 1];
Array.Copy(paramTypes, 0, exParamTypes, 1, paramTypes.Length);
exParamTypes[0] = typeWrapper.shadowType;
mbHelper = typeWrapper.typeBuilder.DefineMethod("instancehelper_" + m.Name, attr, CallingConventions.Standard, retType, exParamTypes);
if(m.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute custattr in m.Attributes)
{
AttributeHelper.SetCustomAttribute(DeclaringType.GetClassLoader(), mbHelper, custattr);
}
}
IKVM.Internal.MapXml.Param[] parameters;
if(m.Params == null)
{
parameters = new IKVM.Internal.MapXml.Param[1];
}
else
{
parameters = new IKVM.Internal.MapXml.Param[m.Params.Length + 1];
m.Params.CopyTo(parameters, 1);
}
parameters[0] = new IKVM.Internal.MapXml.Param();
parameters[0].Name = "this";
SetParameters(DeclaringType.GetClassLoader(), mbHelper, parameters);
if(!typeWrapper.IsFinal)
{
AttributeHelper.SetEditorBrowsableNever(mbHelper);
}
AttributeHelper.SetModifiers(mbHelper, (Modifiers)m.Modifiers, false);
AttributeHelper.SetNameSig(mbHelper, m.Name, m.Sig);
AddDeclaredExceptions(mbHelper, m.throws);
mbHelper.SetCustomAttribute(new CustomAttributeBuilder(JVM.Import(typeof(ObsoleteAttribute)).GetConstructor(new Type[] { Types.String }), new object[] { "This function will be removed from future versions. Please use extension methods from ikvm.extensions namespace instead." }));
}
return mbCore;
}
}
internal override MethodBase DoLink()
{
MethodAttributes attr = MapMethodAccessModifiers(m.Modifiers);
RemapperTypeWrapper typeWrapper = (RemapperTypeWrapper)DeclaringType;
Type[] paramTypes = typeWrapper.GetClassLoader().ArgTypeListFromSig(m.Sig);
ConstructorBuilder cbCore = null;
if(typeWrapper.shadowType.IsSealed)
{
mbHelper = typeWrapper.typeBuilder.DefineMethod("newhelper", attr | MethodAttributes.Static, CallingConventions.Standard, typeWrapper.shadowType, paramTypes);
if(m.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute custattr in m.Attributes)
{
AttributeHelper.SetCustomAttribute(DeclaringType.GetClassLoader(), mbHelper, custattr);
}
}
SetParameters(DeclaringType.GetClassLoader(), mbHelper, m.Params);
AttributeHelper.SetModifiers(mbHelper, (Modifiers)m.Modifiers, false);
AttributeHelper.SetNameSig(mbHelper, "<init>", m.Sig);
AddDeclaredExceptions(mbHelper, m.throws);
}
else
{
cbCore = typeWrapper.typeBuilder.DefineConstructor(attr, CallingConventions.Standard, paramTypes);
if(m.Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute custattr in m.Attributes)
{
AttributeHelper.SetCustomAttribute(DeclaringType.GetClassLoader(), cbCore, custattr);
}
}
SetParameters(DeclaringType.GetClassLoader(), cbCore, m.Params);
AddDeclaredExceptions(cbCore, m.throws);
}
return cbCore;
}
protected override TypeBuilder DefineGhostType(string mangledTypeName, TypeAttributes typeAttribs)
{
typeAttribs &= ~(TypeAttributes.Interface | TypeAttributes.Abstract);
typeAttribs |= TypeAttributes.Class | TypeAttributes.Sealed;
TypeBuilder typeBuilder = classLoader.GetTypeWrapperFactory().ModuleBuilder.DefineType(mangledTypeName, typeAttribs, Types.ValueType);
AttributeHelper.SetGhostInterface(typeBuilder);
AttributeHelper.SetModifiers(typeBuilder, Modifiers, IsInternal);
ghostRefField = typeBuilder.DefineField("__<ref>", Types.Object, FieldAttributes.Public | FieldAttributes.SpecialName);
typeBuilderGhostInterface = typeBuilder.DefineNestedType("__Interface", TypeAttributes.Interface | TypeAttributes.Abstract | TypeAttributes.NestedPublic);
AttributeHelper.HideFromJava(typeBuilderGhostInterface);
ghostIsInstanceMethod = typeBuilder.DefineMethod("IsInstance", MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static, Types.Boolean, new Type[] { Types.Object });
ghostIsInstanceMethod.DefineParameter(1, ParameterAttributes.None, "obj");
ghostIsInstanceArrayMethod = typeBuilder.DefineMethod("IsInstanceArray", MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static, Types.Boolean, new Type[] { Types.Object, Types.Int32 });
ghostIsInstanceArrayMethod.DefineParameter(1, ParameterAttributes.None, "obj");
ghostIsInstanceArrayMethod.DefineParameter(2, ParameterAttributes.None, "rank");
ghostCastMethod = typeBuilder.DefineMethod("Cast", MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static, typeBuilder, new Type[] { Types.Object });
ghostCastMethod.DefineParameter(1, ParameterAttributes.None, "obj");
ghostCastArrayMethod = typeBuilder.DefineMethod("CastArray", MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static, Types.Void, new Type[] { Types.Object, Types.Int32 });
ghostCastArrayMethod.DefineParameter(1, ParameterAttributes.None, "obj");
ghostCastArrayMethod.DefineParameter(2, ParameterAttributes.None, "rank");
return typeBuilder;
}
internal MethodBuilder GetSerializationConstructor()
{
if (baseSerializationCtor == null)
{
baseSerializationCtor = Serialization.AddAutomagicSerializationToWorkaroundBaseClass(typeBuilder, wrapper.BaseTypeWrapper.GetSerializationConstructor());
}
return baseSerializationCtor;
}
public void SetRemoveOnMethod(MethodBuilder mdBuilder)
{
removeOnMethod = mdBuilder;
}
private MethodBuilder CreateMethodBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention)
{
this.ModuleBuilder.MethodDef.AddVirtualRecord();
MethodBuilder mb = new MethodBuilder(this, name, attributes, callingConvention);
methods.Add(mb);
return mb;
}
internal ParameterInfoImpl(MethodBuilder method, int parameter)
{
this.method = method;
this.parameter = parameter;
}
internal static void AddDeclaredExceptions(MethodBuilder 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);
}
}
internal ParameterInfoImpl(MethodBuilder method, int parameter)
{
this.method = method;
this.parameter = parameter;
}
public void SetSetMethod(MethodBuilder mdBuilder)
{
PatchCallingConvention(mdBuilder);
setter = mdBuilder;
}
public IlProcessor(MethodBuilder builder)
{
this.builder = builder;
this.instructions = new Collection<Instruction>();
}
public void SetSetMethod(MethodBuilder mdBuilder)
{
PatchCallingConvention(mdBuilder);
setter = mdBuilder;
}
public void SetRaiseMethod(MethodBuilder mdBuilder)
{
fireMethod = mdBuilder;
}
private static void SetParameters(ClassLoaderWrapper loader, MethodBuilder mb, IKVM.Internal.MapXml.Param[] parameters)
{
if(parameters != null)
{
for(int i = 0; i < parameters.Length; i++)
{
ParameterBuilder pb = mb.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]);
}
}
}
}
}
private void AddParameterMetadata(MethodBuilder method, MethodWrapper mw)
{
ParameterBuilder[] pbs;
if((mw.DeclaringType.IsPublic && (mw.IsPublic || mw.IsProtected)) || classLoader.EmitDebugInfo)
{
string[] parameterNames = new string[mw.GetParameters().Length];
GetParameterNamesFromXml(mw.Name, mw.Signature, parameterNames);
GetParameterNamesFromSig(mw.Signature, parameterNames);
pbs = GetParameterBuilders(method, parameterNames.Length, parameterNames);
}
else
{
pbs = GetParameterBuilders(method, mw.GetParameters().Length, null);
}
if((mw.Modifiers & Modifiers.VarArgs) != 0 && pbs.Length > 0)
{
AttributeHelper.SetParamArrayAttribute(pbs[pbs.Length - 1]);
}
AddXmlMapParameterAttributes(method, Name, mw.Name, mw.Signature, ref pbs);
}
private static void CopyLinkDemands(MethodBuilder mb, MethodInfo mi)
{
foreach (CustomAttributeData cad in CustomAttributeData.__GetDeclarativeSecurity(mi))
{
if (cad.ConstructorArguments.Count == 0 || (int)cad.ConstructorArguments[0].Value == (int)SecurityAction.LinkDemand)
{
mb.__AddDeclarativeSecurity(cad.__ToBuilder());
}
}
}
protected override void DoLinkMethod()
{
ctor.Link();
DefineMethodHelper dmh = ctor.GetDefineMethodHelper();
constructorBuilder = dmh.DefineConstructor(context, typeBuilder, MethodAttributes.PrivateScope);
AttributeHelper.HideFromJava(constructorBuilder);
CodeEmitter ilgen = CodeEmitter.Create(constructorBuilder);
ilgen.Emit(OpCodes.Ldarg_0);
for (int i = 1; i <= dmh.ParameterCount; i++)
{
ilgen.EmitLdarg(i);
}
ctor.EmitCall(ilgen);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
internal ConstructorBuilder(MethodBuilder mb)
{
this.methodBuilder = mb;
}
internal void AddXmlMapParameterAttributes(MethodBuilder method, string className, string methodName, string methodSig, ref ParameterBuilder[] pbs)
{
IKVM.Internal.MapXml.Param[] parameters = classLoader.GetXmlMapParameters(className, methodName, methodSig);
if(parameters != null)
{
if(pbs == null)
{
// let's hope that the parameters array is the right length
pbs = GetParameterBuilders(method, parameters.Length, null);
}
for(int i = 0; i < pbs.Length; i++)
{
if(parameters[i].Attributes != null)
{
foreach(IKVM.Internal.MapXml.Attribute attr in parameters[i].Attributes)
{
AttributeHelper.SetCustomAttribute(classLoader, pbs[i], attr);
}
}
}
}
}
internal GenericTypeParameterBuilder(string name, MethodBuilder method, int position)
: this(name, null, method, position, Signature.ELEMENT_TYPE_MVAR)
{
}
public void SetAddOnMethod(MethodBuilder mdBuilder)
{
addOnMethod = mdBuilder;
}
