public MethodDefinitionProjection(MethodDefinition method, MethodDefinitionTreatment treatment)
{
Attributes = method.Attributes;
ImplAttributes = method.ImplAttributes;
Name = method.Name;
Treatment = treatment;
}
internal MethodImplAttribute(MethodImplAttributes methodImplAttributes)
{
MethodImplOptions all =
MethodImplOptions.Unmanaged | MethodImplOptions.ForwardRef | MethodImplOptions.PreserveSig |
MethodImplOptions.InternalCall | MethodImplOptions.Synchronized | MethodImplOptions.NoInlining;
_val = ((MethodImplOptions)methodImplAttributes) & all;
}
// used by MethodImplAttribute
public void SetMethodImplementation(int attributeIndex, MethodImplAttributes attributes)
{
VerifySealed(expected: false);
Debug.Assert(attributeIndex >= 0);
this.attributes = attributes;
this.methodImplIndex = attributeIndex;
SetDataStored();
}
public void SetImplementationFlags(MethodImplAttributes implementationFlags)
{
TypeBuilder type = Helpers.DynamicType(TypeAttributes.Abstract);
MethodBuilder method = type.DefineMethod("TestMethod", MethodAttributes.Public);
method.SetImplementationFlags(implementationFlags);
Assert.Equal(implementationFlags, method.MethodImplementationFlags);
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodDefRow"/> struct.
/// </summary>
/// <param name="rva">The rva.</param>
/// <param name="implFlags">The impl flags.</param>
/// <param name="flags">The flags.</param>
/// <param name="nameStringIdx">The name string idx.</param>
/// <param name="signatureBlobIdx">The signature BLOB idx.</param>
/// <param name="paramList">The param list.</param>
public MethodDefRow(uint rva, MethodImplAttributes implFlags, MethodAttributes flags, TokenTypes nameStringIdx,
TokenTypes signatureBlobIdx, TokenTypes paramList)
{
_rva = rva;
_implFlags = implFlags;
_flags = flags;
_nameStringIdx = nameStringIdx;
_signatureBlobIdx = signatureBlobIdx;
_paramList = paramList;
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodDefRow"/> struct.
/// </summary>
/// <param name="rva">The rva.</param>
/// <param name="implFlags">The impl flags.</param>
/// <param name="flags">The flags.</param>
/// <param name="nameStringIdx">The name string idx.</param>
/// <param name="signatureBlobIdx">The signature BLOB idx.</param>
/// <param name="paramList">The param list.</param>
public MethodDefRow(uint rva, MethodImplAttributes implFlags, MethodAttributes flags, HeapIndexToken nameStringIdx,
HeapIndexToken signatureBlobIdx, Token paramList)
{
this._rva = rva;
this._implFlags = implFlags;
this._flags = flags;
this._nameStringIdx = nameStringIdx;
this._signatureBlobIdx = signatureBlobIdx;
this._paramList = paramList;
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodDefRow"/> struct.
/// </summary>
/// <param name="rva">The rva.</param>
/// <param name="implFlags">The impl flags.</param>
/// <param name="flags">The flags.</param>
/// <param name="paramList">The param list.</param>
public MethodDefRow(uint rva, MethodImplAttributes implFlags, MethodAttributes flags, HeapIndexToken nameString,
HeapIndexToken signatureBlob, Token paramList)
{
Rva = rva;
ImplFlags = implFlags;
Flags = flags;
NameString = nameString;
SignatureBlob = signatureBlob;
ParamList = paramList;
}
/// <summary>
/// Initializes a new instance of the <see cref="CilRuntimeMethod"/> class.
/// </summary>
/// <param name="module">The module.</param>
/// <param name="name">The name.</param>
/// <param name="signature">The signature.</param>
/// <param name="token">The token.</param>
/// <param name="declaringType">Type of the declaring.</param>
/// <param name="methodAttributes">The method attributes.</param>
/// <param name="methodImplAttributes">The method impl attributes.</param>
/// <param name="rva">The rva.</param>
public CilRuntimeMethod(ITypeModule module, string name, MethodSignature signature, Token token, RuntimeType declaringType, MethodAttributes methodAttributes, MethodImplAttributes methodImplAttributes, uint rva)
: base(module, token, declaringType)
{
base.Attributes = methodAttributes;
base.ImplAttributes = methodImplAttributes;
base.Rva = rva;
this.Name = name;
this.Signature = signature;
this.Parameters = new List<RuntimeParameter>();
}
public MethodDefOptions(MethodDef method) {
this.ImplAttributes = method.ImplAttributes;
this.Attributes = method.Attributes;
this.Name = method.Name;
this.MethodSig = method.MethodSig;
this.ImplMap = method.ImplMap;
this.CustomAttributes.AddRange(method.CustomAttributes);
this.DeclSecurities.AddRange(method.DeclSecurities);
this.ParamDefs.AddRange(method.ParamDefs);
this.GenericParameters.AddRange(method.GenericParameters);
this.Overrides.AddRange(method.Overrides);
}
public MethodDefinition(string name, RVA rva,
MethodAttributes attrs, MethodImplAttributes implAttrs,
bool hasThis, bool explicitThis, MethodCallingConvention callConv)
: base(name, hasThis, explicitThis, callConv)
{
m_rva = rva;
m_attributes = attrs;
m_implAttrs = implAttrs;
if (!IsStatic)
m_this = new ParameterDefinition ("this", 0, (ParameterAttributes) 0, null);
}
public MethodDefOptions(MethodDef method) {
ImplAttributes = method.ImplAttributes;
Attributes = method.Attributes;
SemanticsAttributes = method.SemanticsAttributes;
RVA = method.RVA;
Name = method.Name;
MethodSig = method.MethodSig;
ImplMap = method.ImplMap;
CustomAttributes.AddRange(method.CustomAttributes);
DeclSecurities.AddRange(method.DeclSecurities);
ParamDefs.AddRange(method.ParamDefs);
GenericParameters.AddRange(method.GenericParameters);
Overrides.AddRange(method.Overrides);
}
private void LoadData(CLIFile pFile)
{
RVA = pFile.ReadUInt32();
ImplFlags = (MethodImplAttributes)pFile.ReadUInt16();
Flags = (MethodAttributes)pFile.ReadUInt16();
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.Strings32Bit));
Signature = pFile.ReadBlobHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.Blob32Bit));
if (pFile.ParamTable.Length >= 0xFFFF) ParamListIndex = pFile.ReadInt32() - 1;
else ParamListIndex = pFile.ReadUInt16() - 1;
if (RVA != 0)
{
Body = new MethodDefBodyData();
Body.LoadData(this);
}
}
public MethodBodyOptions(MethodDef method) {
this.CodeType = method.CodeType;
if (method.MethodBody is CilBody) {
var headerRva = method.RVA;
var headerFileOffset = (FileOffset)method.Module.ToFileOffset((uint)headerRva);
var rva = (RVA)((uint)headerRva + method.Body.HeaderSize);
var fileOffset = (FileOffset)((long)headerFileOffset + method.Body.HeaderSize);
this.CilBodyOptions = new CilBodyOptions((CilBody)method.MethodBody, headerRva, headerFileOffset, rva, fileOffset);
this.BodyType = MethodBodyType.Cil;
}
else if (method.MethodBody is NativeMethodBody) {
this.NativeMethodBodyOptions = new NativeMethodBodyOptions((NativeMethodBody)method.MethodBody);
this.BodyType = MethodBodyType.Native;
}
else
this.BodyType = MethodBodyType.None;
}
public MethodBodyOptions(MethodDef method)
{
this.CodeType = method.CodeType;
if (method.MethodBody is CilBody) {
FileOffset fileOffset = 0;
var mod = method.Module as ModuleDefMD;
if (mod != null)
fileOffset = mod.MetaData.PEImage.ToFileOffset(method.RVA);
this.CilBodyOptions = new CilBodyOptions((CilBody)method.MethodBody, method.RVA, fileOffset);
this.BodyType = MethodBodyType.Cil;
}
else if (method.MethodBody is NativeMethodBody) {
this.NativeMethodBodyOptions = new NativeMethodBodyOptions((NativeMethodBody)method.MethodBody);
this.BodyType = MethodBodyType.Native;
}
else
this.BodyType = MethodBodyType.None;
}
public MethodBodyOptions(MethodDef method)
{
CodeType = method.CodeType;
if (method.MethodBody is CilBody)
{
var headerRva = method.RVA;
var headerFileOffset = (FileOffset)(method.Module.ToFileOffset((uint)headerRva) ?? (uint)headerRva);
var rva = (RVA)((uint)headerRva + method.Body.HeaderSize);
var fileOffset = (FileOffset)((long)headerFileOffset + method.Body.HeaderSize);
CilBodyOptions = new CilBodyOptions((CilBody)method.MethodBody, headerRva, headerFileOffset, rva, fileOffset);
BodyType = MethodBodyType.Cil;
}
else if (method.MethodBody is NativeMethodBody)
{
NativeMethodBodyOptions = new NativeMethodBodyOptions((NativeMethodBody)method.MethodBody);
BodyType = MethodBodyType.Native;
}
else
{
BodyType = MethodBodyType.None;
}
}
private void SetMethodImplAttribute(CustomAttributeBuilder customBuilder)
{
MethodImplOptions opt;
switch (customBuilder.Constructor.ParameterCount)
{
case 0:
opt = 0;
break;
case 1:
{
object val = customBuilder.GetConstructorArgument(0);
if (val is short)
{
opt = (MethodImplOptions)(short)val;
}
else if (val is int)
{
opt = (MethodImplOptions)(int)val;
}
else
{
opt = (MethodImplOptions)val;
}
break;
}
default:
throw new NotSupportedException();
}
MethodCodeType?type = customBuilder.GetFieldValue <MethodCodeType>("MethodCodeType");
implFlags = (MethodImplAttributes)opt;
if (type.HasValue)
{
implFlags |= (MethodImplAttributes)type;
}
}
public void DisplayMethodTable(byte[] metadata, byte[] blob, byte[] strings, int[] rows)
{
int old = tableoffset;
bool b = tablepresent(rows, 6);
int offs = tableoffset;
tableoffset = old;
if (b)
{
for (int k = 1; k <= rows[6]; k++)
{
int rva = BitConverter.ToInt32(metadata, offs);
offs += 4;
MethodImplAttributes impflags = (MethodImplAttributes)BitConverter.ToInt16(metadata, offs);
offs += 2;
int flags = (int)BitConverter.ToInt16(metadata, offs);
offs += 2;
int name = ReadStringIndex(metadata, offs);
offs += offsetstring;
int signature = ReadBlobIndex(metadata, offs);
offs += offsetblob;
int param = BitConverter.ToInt16(metadata, offs);
offs += 2;
Console.WriteLine("Name : {0}", GetString(strings, name));
string s = DisplayMethodSignature(blob, signature, param, GetString(strings, name));
Console.WriteLine("Signature: #Blob[{0}] {1}", signature, s);
}
}
}
internal static string ToString(MethodImplAttributes flags) {
var sb = new StringBuilder();
switch ((flags & MethodImplAttributes.CodeTypeMask)) {
case MethodImplAttributes.IL: sb.Append("IL"); break;
case MethodImplAttributes.Native: sb.Append("Native"); break;
case MethodImplAttributes.OPTIL: sb.Append("OPTIL"); break;
case MethodImplAttributes.Runtime: sb.Append("Runtime"); break;
}
if ((flags & MethodImplAttributes.Unmanaged) != 0)
sb.Append(" | Unmanaged");
else
sb.Append(" | Managed");
if ((flags & MethodImplAttributes.ForwardRef) != 0)
sb.Append(" | ForwardRef");
if ((flags & MethodImplAttributes.PreserveSig) != 0)
sb.Append(" | PreserveSig");
if ((flags & MethodImplAttributes.InternalCall) != 0)
sb.Append(" | InternalCall");
if ((flags & MethodImplAttributes.Synchronized) != 0)
sb.Append(" | Synchronized");
if ((flags & MethodImplAttributes.NoInlining) != 0)
sb.Append(" | NoInlining");
if ((flags & MethodImplAttributes.AggressiveInlining) != 0)
sb.Append(" | AggressiveInlining");
if ((flags & MethodImplAttributes.NoOptimization) != 0)
sb.Append(" | NoOptimization");
return sb.ToString();
}
/// <summary>
/// Gets method parameters and method flags
/// </summary>
/// <param name="methodAttrs">Method attributes</param>
/// <param name="methodImplAttrs">Method implementation attributes</param>
/// <returns></returns>
public MDParameters GetMDParameters(out MethodAttributes methodAttrs, out MethodImplAttributes methodImplAttrs)
{
methodAttrs = 0;
methodImplAttrs = 0;
var mod = Module;
if (mod == null)
{
return(null);
}
var mdi = mod.GetMetaDataInterface <IMetaDataImport>();
if (mdi == null)
{
return(null);
}
var name = MetaDataUtils.GetMethodDefName(mdi, Token, out methodAttrs, out methodImplAttrs);
if (name == null)
{
return(null);
}
return(MetaDataUtils.GetParameters(mdi, Token));
}
public MethodBodyOptions(MethodDef method)
{
this.CodeType = method.CodeType;
if (method.MethodBody is CilBody)
{
FileOffset fileOffset = 0;
var mod = method.Module as ModuleDefMD;
if (mod != null)
{
fileOffset = mod.MetaData.PEImage.ToFileOffset(method.RVA);
}
this.CilBodyOptions = new CilBodyOptions((CilBody)method.MethodBody, method.RVA, fileOffset);
this.BodyType = MethodBodyType.Cil;
}
else if (method.MethodBody is NativeMethodBody)
{
this.NativeMethodBodyOptions = new NativeMethodBodyOptions((NativeMethodBody)method.MethodBody);
this.BodyType = MethodBodyType.Native;
}
else
{
this.BodyType = MethodBodyType.None;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="readerModule">The module which contains this <c>Method</c> row</param>
/// <param name="rid">Row ID</param>
/// <exception cref="ArgumentNullException">If <paramref name="readerModule"/> is <c>null</c></exception>
/// <exception cref="ArgumentException">If <paramref name="rid"/> is invalid</exception>
public MethodDefMD(ModuleDefMD readerModule, uint rid)
{
#if DEBUG
if (readerModule == null)
{
throw new ArgumentNullException("readerModule");
}
if (readerModule.TablesStream.MethodTable.IsInvalidRID(rid))
{
throw new BadImageFormatException(string.Format("Method rid {0} does not exist", rid));
}
#endif
this.origRid = rid;
this.rid = rid;
this.readerModule = readerModule;
uint name;
uint signature = readerModule.TablesStream.ReadMethodRow(origRid, out this.rva, out this.implAttributes, out this.attributes, out name);
this.name = readerModule.StringsStream.ReadNoNull(name);
this.origRva = rva;
this.origImplAttributes = (MethodImplAttributes)implAttributes;
this.declaringType2 = readerModule.GetOwnerType(this);
this.signature = readerModule.ReadSignature(signature, new GenericParamContext(declaringType2, this));
this.parameterList = new ParameterList(this, declaringType2);
}
public static int Main()
{
EventInfo ei = typeof(Test).GetEvent("MyEvent");
MethodImplAttributes methodImplAttributes = ei.GetAddMethod().GetMethodImplementationFlags();
if ((methodImplAttributes & MethodImplAttributes.Synchronized) == 0)
{
Console.WriteLine("FAILED");
return(1);
}
methodImplAttributes = ei.GetRemoveMethod().GetMethodImplementationFlags();
if ((methodImplAttributes & MethodImplAttributes.Synchronized) == 0)
{
Console.WriteLine("FAILED");
return(2);
}
ei = typeof(S).GetEvent("MyEvent");
methodImplAttributes = ei.GetAddMethod().GetMethodImplementationFlags();
if ((methodImplAttributes & MethodImplAttributes.Synchronized) != 0)
{
Console.WriteLine("FAILED");
return(3);
}
methodImplAttributes = ei.GetRemoveMethod().GetMethodImplementationFlags();
if ((methodImplAttributes & MethodImplAttributes.Synchronized) != 0)
{
Console.WriteLine("FAILED");
return(4);
}
return(0);
}
/// <summary>
/// Reads a method body
/// </summary>
/// <param name="method">Method</param>
/// <param name="rva">Method RVA</param>
/// <param name="implAttrs">Method impl attrs</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A <see cref="MethodBody"/> or <c>null</c> if none</returns>
internal MethodBody ReadMethodBody(MethodDefMD method, RVA rva, MethodImplAttributes implAttrs, GenericParamContext gpContext)
{
MethodBody mb;
var mDec = methodDecrypter;
if (mDec != null && mDec.GetMethodBody(method.OrigRid, rva, method.Parameters, gpContext, out mb)) {
var cilBody = mb as CilBody;
if (cilBody != null)
return InitializeBodyFromPdb(cilBody, method.OrigRid);
return mb;
}
if (rva == 0)
return null;
var codeType = implAttrs & MethodImplAttributes.CodeTypeMask;
if (codeType == MethodImplAttributes.IL)
return InitializeBodyFromPdb(ReadCilBody(method.Parameters, rva, gpContext), method.OrigRid);
if (codeType == MethodImplAttributes.Native)
return new NativeMethodBody(rva);
return null;
}
private void SetMethodCodeTypeAttribute(MethodImplAttributes attribute, bool value)
{
ImplAttributes = (MethodImplAttributes)((uint)ImplAttributes).SetMaskedAttribute((uint)MethodImplAttributes.CodeTypeMask,
(uint)attribute, value);
}
public void SetImplementationFlags(MethodImplAttributes attributes)
{
implFlags = attributes;
}
private void SetMethodImplAttribute(CustomAttributeBuilder customBuilder)
{
MethodImplOptions opt;
switch (customBuilder.Constructor.ParameterCount)
{
case 0:
opt = 0;
break;
case 1:
{
object val = customBuilder.GetConstructorArgument(0);
if (val is short)
{
opt = (MethodImplOptions)(short)val;
}
else if (val is int)
{
opt = (MethodImplOptions)(int)val;
}
else
{
opt = (MethodImplOptions)val;
}
break;
}
default:
throw new NotSupportedException();
}
MethodCodeType? type = customBuilder.GetFieldValue<MethodCodeType>("MethodCodeType");
implFlags = (MethodImplAttributes)opt;
if (type.HasValue)
{
implFlags |= (MethodImplAttributes)type;
}
}
public static StringBuilder AppendMethodImplAttributes(StringBuilder sb, MethodImplAttributes attributes)
{
string codeType;
switch (attributes & MethodImplAttributes.CodeTypeMask)
{
case MethodImplAttributes.IL: codeType = "cil"; break;
case MethodImplAttributes.OPTIL: codeType = "optil"; break;
case MethodImplAttributes.Runtime: codeType = "runtime"; break;
case MethodImplAttributes.Native: codeType = "native"; break;
default:
throw new InvalidOperationException();
}
sb.Append(codeType);
sb.Append(" ");
sb.Append((attributes & MethodImplAttributes.Unmanaged) == MethodImplAttributes.Unmanaged ? "unmanaged" : "managed");
if ((attributes & MethodImplAttributes.PreserveSig) != 0) sb.Append(" preservesig");
if ((attributes & MethodImplAttributes.ForwardRef) != 0) sb.Append(" forwardref");
if ((attributes & MethodImplAttributes.InternalCall) != 0) sb.Append(" internalcall");
if ((attributes & MethodImplAttributes.Synchronized) != 0) sb.Append(" synchronized");
if ((attributes & MethodImplAttributes.NoInlining) != 0) sb.Append(" noinlining");
if ((attributes & MethodImplAttributes.AggressiveInlining) != 0) sb.Append(" aggressiveinlining");
if ((attributes & MethodImplAttributes.NoOptimization) != 0) sb.Append(" nooptimization");
return sb;
}
public MethodDefinitionHandle AddMethodDefinition(
MethodAttributes attributes,
MethodImplAttributes implAttributes,
StringHandle name,
BlobHandle signature,
int bodyOffset,
ParameterHandle paramList)
{
_methodDefTable.Add(new MethodRow
{
Flags = (ushort)attributes,
ImplFlags = (ushort)implAttributes,
Name = name,
Signature = signature,
BodyOffset = bodyOffset,
ParamList = (uint)MetadataTokens.GetRowNumber(paramList)
});
return MetadataTokens.MethodDefinitionHandle(_methodDefTable.Count);
}
internal static string ToString(MethodImplAttributes flags)
{
var sb = new StringBuilder();
switch ((flags & MethodImplAttributes.CodeTypeMask))
{
case MethodImplAttributes.IL: sb.Append("IL"); break;
case MethodImplAttributes.Native: sb.Append("Native"); break;
case MethodImplAttributes.OPTIL: sb.Append("OPTIL"); break;
case MethodImplAttributes.Runtime: sb.Append("Runtime"); break;
}
if ((flags & MethodImplAttributes.Unmanaged) != 0)
{
sb.Append(" | Unmanaged");
}
else
{
sb.Append(" | Managed");
}
if ((flags & MethodImplAttributes.ForwardRef) != 0)
{
sb.Append(" | ForwardRef");
}
if ((flags & MethodImplAttributes.PreserveSig) != 0)
{
sb.Append(" | PreserveSig");
}
if ((flags & MethodImplAttributes.InternalCall) != 0)
{
sb.Append(" | InternalCall");
}
if ((flags & MethodImplAttributes.Synchronized) != 0)
{
sb.Append(" | Synchronized");
}
if ((flags & MethodImplAttributes.NoInlining) != 0)
{
sb.Append(" | NoInlining");
}
if ((flags & MethodImplAttributes.AggressiveInlining) != 0)
{
sb.Append(" | AggressiveInlining");
}
if ((flags & MethodImplAttributes.NoOptimization) != 0)
{
sb.Append(" | NoOptimization");
}
return(sb.ToString());
}
public BodyState(MethodDef method, bool isBodyModified)
{
this.body = method.MethodBody;
this.implAttributes = method.ImplAttributes;
this.isBodyModified = isBodyModified;
}
public void SetImplementationFlags (MethodImplAttributes attributes)
{
if (type.is_created)
throw not_after_created ();
iattrs = attributes;
}
} // Read
public static uint Read(this NativeReader reader, uint offset, out MethodImplAttributes value)
{
uint ivalue;
offset = reader.DecodeUnsigned(offset, out ivalue);
value = (MethodImplAttributes)ivalue;
return offset;
} // Read
public BodyState(Emit.MethodBody body, MethodImplAttributes implAttributes, bool isBodyModified)
{
this.body = body;
this.implAttributes = implAttributes;
this.isBodyModified = isBodyModified;
}
public static unsafe bool GetMethodAttributes(IMetaDataImport mdi, uint token, out MethodAttributes dwAttr, out MethodImplAttributes dwImplFlags) {
dwAttr = 0;
dwImplFlags = 0;
if (mdi == null)
return false;
uint dwAttr2, dwImplFlags2;
int hr = mdi.GetMethodProps(token, IntPtr.Zero, IntPtr.Zero, 0, IntPtr.Zero, new IntPtr(&dwAttr2), IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, new IntPtr(&dwImplFlags2));
if (hr < 0)
return false;
dwAttr = (MethodAttributes)dwAttr2;
dwImplFlags = (MethodImplAttributes)dwImplFlags2;
return true;
}
public IEnumerable <IAttribute> GetAttributes()
{
var b = new AttributeListBuilder(module);
var metadata = module.metadata;
var def = metadata.GetMethodDefinition(handle);
MethodImplAttributes implAttributes = def.ImplAttributes & ~MethodImplAttributes.CodeTypeMask;
#region DllImportAttribute
var info = def.GetImport();
if ((attributes & MethodAttributes.PinvokeImpl) == MethodAttributes.PinvokeImpl && !info.Module.IsNil)
{
var dllImport = new AttributeBuilder(module, KnownAttribute.DllImport);
dllImport.AddFixedArg(KnownTypeCode.String,
metadata.GetString(metadata.GetModuleReference(info.Module).Name));
var importAttrs = info.Attributes;
if ((importAttrs & MethodImportAttributes.BestFitMappingDisable) == MethodImportAttributes.BestFitMappingDisable)
{
dllImport.AddNamedArg("BestFitMapping", KnownTypeCode.Boolean, false);
}
if ((importAttrs & MethodImportAttributes.BestFitMappingEnable) == MethodImportAttributes.BestFitMappingEnable)
{
dllImport.AddNamedArg("BestFitMapping", KnownTypeCode.Boolean, true);
}
CallingConvention callingConvention;
switch (info.Attributes & MethodImportAttributes.CallingConventionMask)
{
case 0:
Debug.WriteLine($"P/Invoke calling convention not set on: {this}");
callingConvention = 0;
break;
case MethodImportAttributes.CallingConventionCDecl:
callingConvention = CallingConvention.Cdecl;
break;
case MethodImportAttributes.CallingConventionFastCall:
callingConvention = CallingConvention.FastCall;
break;
case MethodImportAttributes.CallingConventionStdCall:
callingConvention = CallingConvention.StdCall;
break;
case MethodImportAttributes.CallingConventionThisCall:
callingConvention = CallingConvention.ThisCall;
break;
case MethodImportAttributes.CallingConventionWinApi:
callingConvention = CallingConvention.Winapi;
break;
default:
throw new NotSupportedException("unknown calling convention");
}
if (callingConvention != CallingConvention.Winapi)
{
var callingConventionType = FindInteropType(nameof(CallingConvention));
dllImport.AddNamedArg("CallingConvention", callingConventionType, (int)callingConvention);
}
CharSet charSet = CharSet.None;
switch (info.Attributes & MethodImportAttributes.CharSetMask)
{
case MethodImportAttributes.CharSetAnsi:
charSet = CharSet.Ansi;
break;
case MethodImportAttributes.CharSetAuto:
charSet = CharSet.Auto;
break;
case MethodImportAttributes.CharSetUnicode:
charSet = CharSet.Unicode;
break;
}
if (charSet != CharSet.None)
{
var charSetType = FindInteropType(nameof(CharSet));
dllImport.AddNamedArg("CharSet", charSetType, (int)charSet);
}
if (!info.Name.IsNil && info.Name != def.Name)
{
dllImport.AddNamedArg("EntryPoint", KnownTypeCode.String, metadata.GetString(info.Name));
}
if ((info.Attributes & MethodImportAttributes.ExactSpelling) == MethodImportAttributes.ExactSpelling)
{
dllImport.AddNamedArg("ExactSpelling", KnownTypeCode.Boolean, true);
}
if ((implAttributes & MethodImplAttributes.PreserveSig) == MethodImplAttributes.PreserveSig)
{
implAttributes &= ~MethodImplAttributes.PreserveSig;
}
else
{
dllImport.AddNamedArg("PreserveSig", KnownTypeCode.Boolean, false);
}
if ((info.Attributes & MethodImportAttributes.SetLastError) == MethodImportAttributes.SetLastError)
{
dllImport.AddNamedArg("SetLastError", KnownTypeCode.Boolean, true);
}
if ((info.Attributes & MethodImportAttributes.ThrowOnUnmappableCharDisable) == MethodImportAttributes.ThrowOnUnmappableCharDisable)
{
dllImport.AddNamedArg("ThrowOnUnmappableChar", KnownTypeCode.Boolean, false);
}
if ((info.Attributes & MethodImportAttributes.ThrowOnUnmappableCharEnable) == MethodImportAttributes.ThrowOnUnmappableCharEnable)
{
dllImport.AddNamedArg("ThrowOnUnmappableChar", KnownTypeCode.Boolean, true);
}
b.Add(dllImport.Build());
}
#endregion
#region PreserveSigAttribute
if (implAttributes == MethodImplAttributes.PreserveSig)
{
b.Add(KnownAttribute.PreserveSig);
implAttributes = 0;
}
#endregion
#region MethodImplAttribute
if (implAttributes != 0)
{
b.Add(KnownAttribute.MethodImpl,
new TopLevelTypeName("System.Runtime.CompilerServices", nameof(MethodImplOptions)),
(int)implAttributes
);
}
#endregion
b.Add(def.GetCustomAttributes(), symbolKind);
b.AddSecurityAttributes(def.GetDeclarativeSecurityAttributes());
return(b.Build());
}
public void SetImplementationFlags(MethodImplAttributes attributes)
{
m_methodBuilder.SetImplementationFlags(attributes);
}
public EditedMethodBodyUpdater(Lazy <IMethodAnnotations> methodAnnotations, ModuleDocumentNode modNode, MethodDef originalMethod, Emit.MethodBody newBody, MethodImplAttributes newImplAttributes, CustomAttribute[] newCustomAttributes, DeclSecurity[] newDeclSecurities)
{
this.methodAnnotations = methodAnnotations;
this.ownerNode = modNode.Context.DocumentTreeView.FindNode(originalMethod);
if (ownerNode == null)
{
throw new InvalidOperationException();
}
this.method = originalMethod;
this.originalBodyState = new BodyState(originalMethod, methodAnnotations.Value.IsBodyModified(method));
this.newBodyState = new BodyState(newBody, newImplAttributes, newCustomAttributes, newDeclSecurities, true);
}
public void SetCustomAttribute (CustomAttributeBuilder customBuilder)
{
if (customBuilder == null)
throw new ArgumentNullException ("customBuilder");
switch (customBuilder.Ctor.ReflectedType.FullName) {
case "System.Runtime.CompilerServices.MethodImplAttribute":
byte[] data = customBuilder.Data;
int impla; // the (stupid) ctor takes a short or an int ...
impla = (int)data [2];
impla |= ((int)data [3]) << 8;
iattrs |= (MethodImplAttributes)impla;
return;
case "System.Runtime.InteropServices.DllImportAttribute":
CustomAttributeBuilder.CustomAttributeInfo attr = CustomAttributeBuilder.decode_cattr (customBuilder);
bool preserveSig = true;
/*
* It would be easier to construct a DllImportAttribute from
* the custom attribute builder, but the DllImportAttribute
* does not contain all the information required here, ie.
* - some parameters, like BestFitMapping has three values
* ("on", "off", "missing"), but DllImportAttribute only
* contains two (on/off).
* - PreserveSig is true by default, while it is false by
* default in DllImportAttribute.
*/
pi_dll = (string)attr.ctorArgs[0];
if (pi_dll == null || pi_dll.Length == 0)
throw new ArgumentException ("DllName cannot be empty");
native_cc = System.Runtime.InteropServices.CallingConvention.Winapi;
for (int i = 0; i < attr.namedParamNames.Length; ++i) {
string name = attr.namedParamNames [i];
object value = attr.namedParamValues [i];
if (name == "CallingConvention")
native_cc = (CallingConvention)value;
else if (name == "CharSet")
charset = (CharSet)value;
else if (name == "EntryPoint")
pi_entry = (string)value;
else if (name == "ExactSpelling")
ExactSpelling = (bool)value;
else if (name == "SetLastError")
SetLastError = (bool)value;
else if (name == "PreserveSig")
preserveSig = (bool)value;
else if (name == "BestFitMapping")
BestFitMapping = (bool)value;
else if (name == "ThrowOnUnmappableChar")
ThrowOnUnmappableChar = (bool)value;
}
attrs |= MethodAttributes.PinvokeImpl;
if (preserveSig)
iattrs |= MethodImplAttributes.PreserveSig;
return;
case "System.Runtime.InteropServices.PreserveSigAttribute":
iattrs |= MethodImplAttributes.PreserveSig;
return;
case "System.Runtime.CompilerServices.SpecialNameAttribute":
attrs |= MethodAttributes.SpecialName;
return;
case "System.Security.SuppressUnmanagedCodeSecurityAttribute":
attrs |= MethodAttributes.HasSecurity;
break;
}
if (cattrs != null) {
CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1];
cattrs.CopyTo (new_array, 0);
new_array [cattrs.Length] = customBuilder;
cattrs = new_array;
} else {
cattrs = new CustomAttributeBuilder [1];
cattrs [0] = customBuilder;
}
}
internal void SetDllImportPseudoCustomAttribute(string dllName, string entryName, CallingConvention? nativeCallConv, CharSet? nativeCharSet,
bool? bestFitMapping, bool? throwOnUnmappableChar, bool? setLastError, bool? preserveSig, bool? exactSpelling)
{
const short NoMangle = 0x0001;
const short CharSetMask = 0x0006;
const short CharSetNotSpec = 0x0000;
const short CharSetAnsi = 0x0002;
const short CharSetUnicode = 0x0004;
const short CharSetAuto = 0x0006;
const short SupportsLastError = 0x0040;
const short CallConvMask = 0x0700;
const short CallConvWinapi = 0x0100;
const short CallConvCdecl = 0x0200;
const short CallConvStdcall = 0x0300;
const short CallConvThiscall = 0x0400;
const short CallConvFastcall = 0x0500;
// non-standard flags
const short BestFitOn = 0x0010;
const short BestFitOff = 0x0020;
const short CharMapErrorOn = 0x1000;
const short CharMapErrorOff = 0x2000;
short flags = CharSetNotSpec | CallConvWinapi;
if (bestFitMapping.HasValue)
{
flags |= bestFitMapping.Value ? BestFitOn : BestFitOff;
}
if (throwOnUnmappableChar.HasValue)
{
flags |= throwOnUnmappableChar.Value ? CharMapErrorOn : CharMapErrorOff;
}
if (nativeCallConv.HasValue)
{
flags &= ~CallConvMask;
switch (nativeCallConv.Value)
{
case System.Runtime.InteropServices.CallingConvention.Cdecl:
flags |= CallConvCdecl;
break;
case System.Runtime.InteropServices.CallingConvention.FastCall:
flags |= CallConvFastcall;
break;
case System.Runtime.InteropServices.CallingConvention.StdCall:
flags |= CallConvStdcall;
break;
case System.Runtime.InteropServices.CallingConvention.ThisCall:
flags |= CallConvThiscall;
break;
case System.Runtime.InteropServices.CallingConvention.Winapi:
flags |= CallConvWinapi;
break;
}
}
if (nativeCharSet.HasValue)
{
flags &= ~CharSetMask;
switch (nativeCharSet.Value)
{
case CharSet.Ansi:
case CharSet.None:
flags |= CharSetAnsi;
break;
case CharSet.Auto:
flags |= CharSetAuto;
break;
case CharSet.Unicode:
flags |= CharSetUnicode;
break;
}
}
if (exactSpelling.HasValue && exactSpelling.Value)
{
flags |= NoMangle;
}
if (!preserveSig.HasValue || preserveSig.Value)
{
implFlags |= MethodImplAttributes.PreserveSig;
}
if (setLastError.HasValue && setLastError.Value)
{
flags |= SupportsLastError;
}
ImplMapTable.Record rec = new ImplMapTable.Record();
rec.MappingFlags = flags;
rec.MemberForwarded = pseudoToken;
rec.ImportName = this.ModuleBuilder.Strings.Add(entryName ?? name);
rec.ImportScope = this.ModuleBuilder.ModuleRef.FindOrAddRecord(dllName == null ? 0 : this.ModuleBuilder.Strings.Add(dllName));
this.ModuleBuilder.ImplMap.AddRecord(rec);
}
public void SetImplementationFlags(MethodImplAttributes attributes)
{
throw new NotSupportedException();
}
public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
{
Universe u = this.ModuleBuilder.universe;
Type type = customBuilder.Constructor.DeclaringType;
if (type == u.System_Runtime_InteropServices_DllImportAttribute)
{
attributes |= MethodAttributes.PinvokeImpl;
SetDllImportPseudoCustomAttribute(customBuilder.DecodeBlob(this.Module.Assembly));
}
else if (type == u.System_Runtime_CompilerServices_MethodImplAttribute)
{
SetMethodImplAttribute(customBuilder.DecodeBlob(this.Module.Assembly));
}
else if (type == u.System_Runtime_InteropServices_PreserveSigAttribute)
{
implFlags |= MethodImplAttributes.PreserveSig;
}
else if (type == u.System_Runtime_CompilerServices_SpecialNameAttribute)
{
attributes |= MethodAttributes.SpecialName;
}
else
{
if (type == u.System_Security_SuppressUnmanagedCodeSecurityAttribute)
{
attributes |= MethodAttributes.HasSecurity;
}
this.ModuleBuilder.SetCustomAttribute(pseudoToken, customBuilder);
}
}
internal static extern void SetMethodImpl(RuntimeModule module, int tkMethod, MethodImplAttributes MethodImplAttributes);
private bool GetMethodCodeTypeAttribute(MethodImplAttributes attribute)
{
return(((uint)ImplAttributes).GetMaskedAttribute((uint)MethodImplAttributes.CodeTypeMask,
(uint)attribute));
}
private static void AddString(StringBuilder buffer, MethodImplAttributes source, MethodImplAttributes flag, string stringified)
{
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
if ((source & flag) != 0)
{
buffer.Append(' ').Append(stringified);
}
}
public MethodRow CreateMethodRow(RVA _rVA, MethodImplAttributes _implFlags, MethodAttributes _flags, uint _name, uint _signature, uint _paramList)
{
MethodRow row = new MethodRow ();
row.RVA = _rVA;
row.ImplFlags = _implFlags;
row.Flags = _flags;
row.Name = _name;
row.Signature = _signature;
row.ParamList = _paramList;
return row;
}
bool GetFlagValue(MethodImplAttributes flag) => (ImplAttributes & flag) != 0;
public CorMethodInfo(CorType ownerType, uint token, string name, MethodSig methodSig, MethodAttributes attrs, MethodImplAttributes implAttrs, bool compilerGeneratedAttribute)
{
OwnerType = ownerType;
Token = token;
Name = name;
MethodSig = methodSig;
MethodAttributes = attrs;
MethodImplAttributes = implAttrs;
CompilerGeneratedAttribute = compilerGeneratedAttribute;
}
public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
{
if (customBuilder == null)
{
throw new ArgumentNullException("customBuilder");
}
switch (customBuilder.Ctor.ReflectedType.FullName)
{
case "System.Runtime.CompilerServices.MethodImplAttribute":
byte[] data = customBuilder.Data;
int impla; // the (stupid) ctor takes a short or an int ...
impla = (int)data [2];
impla |= ((int)data [3]) << 8;
iattrs |= (MethodImplAttributes)impla;
return;
case "System.Runtime.InteropServices.DllImportAttribute":
CustomAttributeBuilder.CustomAttributeInfo attr = CustomAttributeBuilder.decode_cattr(customBuilder);
bool preserveSig = true;
/*
* It would be easier to construct a DllImportAttribute from
* the custom attribute builder, but the DllImportAttribute
* does not contain all the information required here, ie.
* - some parameters, like BestFitMapping has three values
* ("on", "off", "missing"), but DllImportAttribute only
* contains two (on/off).
* - PreserveSig is true by default, while it is false by
* default in DllImportAttribute.
*/
pi_dll = (string)attr.ctorArgs[0];
if (pi_dll == null || pi_dll.Length == 0)
{
throw new ArgumentException("DllName cannot be empty");
}
native_cc = System.Runtime.InteropServices.CallingConvention.Winapi;
for (int i = 0; i < attr.namedParamNames.Length; ++i)
{
string name = attr.namedParamNames [i];
object value = attr.namedParamValues [i];
if (name == "CallingConvention")
{
native_cc = (CallingConvention)value;
}
else if (name == "CharSet")
{
charset = (CharSet)value;
}
else if (name == "EntryPoint")
{
pi_entry = (string)value;
}
else if (name == "ExactSpelling")
{
ExactSpelling = (bool)value;
}
else if (name == "SetLastError")
{
SetLastError = (bool)value;
}
else if (name == "PreserveSig")
{
preserveSig = (bool)value;
}
else if (name == "BestFitMapping")
{
BestFitMapping = (bool)value;
}
else if (name == "ThrowOnUnmappableChar")
{
ThrowOnUnmappableChar = (bool)value;
}
}
attrs |= MethodAttributes.PinvokeImpl;
if (preserveSig)
{
iattrs |= MethodImplAttributes.PreserveSig;
}
return;
case "System.Runtime.InteropServices.PreserveSigAttribute":
iattrs |= MethodImplAttributes.PreserveSig;
return;
case "System.Runtime.CompilerServices.SpecialNameAttribute":
attrs |= MethodAttributes.SpecialName;
return;
case "System.Security.SuppressUnmanagedCodeSecurityAttribute":
attrs |= MethodAttributes.HasSecurity;
break;
}
if (cattrs != null)
{
CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1];
cattrs.CopyTo(new_array, 0);
new_array [cattrs.Length] = customBuilder;
cattrs = new_array;
}
else
{
cattrs = new CustomAttributeBuilder [1];
cattrs [0] = customBuilder;
}
}
public void SetImplementationFlags (MethodImplAttributes attributes)
{
RejectIfCreated ();
iattrs = attributes;
}
internal void SetDllImportPseudoCustomAttribute(string dllName, string entryName, CallingConvention?nativeCallConv, CharSet?nativeCharSet,
bool?bestFitMapping, bool?throwOnUnmappableChar, bool?setLastError, bool?preserveSig, bool?exactSpelling)
{
const short NoMangle = 0x0001;
const short CharSetMask = 0x0006;
const short CharSetNotSpec = 0x0000;
const short CharSetAnsi = 0x0002;
const short CharSetUnicode = 0x0004;
const short CharSetAuto = 0x0006;
const short SupportsLastError = 0x0040;
const short CallConvMask = 0x0700;
const short CallConvWinapi = 0x0100;
const short CallConvCdecl = 0x0200;
const short CallConvStdcall = 0x0300;
const short CallConvThiscall = 0x0400;
const short CallConvFastcall = 0x0500;
// non-standard flags
const short BestFitOn = 0x0010;
const short BestFitOff = 0x0020;
const short CharMapErrorOn = 0x1000;
const short CharMapErrorOff = 0x2000;
short flags = CharSetNotSpec | CallConvWinapi;
if (bestFitMapping.HasValue)
{
flags |= bestFitMapping.Value ? BestFitOn : BestFitOff;
}
if (throwOnUnmappableChar.HasValue)
{
flags |= throwOnUnmappableChar.Value ? CharMapErrorOn : CharMapErrorOff;
}
if (nativeCallConv.HasValue)
{
flags &= ~CallConvMask;
switch (nativeCallConv.Value)
{
case System.Runtime.InteropServices.CallingConvention.Cdecl:
flags |= CallConvCdecl;
break;
case System.Runtime.InteropServices.CallingConvention.FastCall:
flags |= CallConvFastcall;
break;
case System.Runtime.InteropServices.CallingConvention.StdCall:
flags |= CallConvStdcall;
break;
case System.Runtime.InteropServices.CallingConvention.ThisCall:
flags |= CallConvThiscall;
break;
case System.Runtime.InteropServices.CallingConvention.Winapi:
flags |= CallConvWinapi;
break;
}
}
if (nativeCharSet.HasValue)
{
flags &= ~CharSetMask;
switch (nativeCharSet.Value)
{
case CharSet.Ansi:
case CharSet.None:
flags |= CharSetAnsi;
break;
case CharSet.Auto:
flags |= CharSetAuto;
break;
case CharSet.Unicode:
flags |= CharSetUnicode;
break;
}
}
if (exactSpelling.HasValue && exactSpelling.Value)
{
flags |= NoMangle;
}
if (!preserveSig.HasValue || preserveSig.Value)
{
implFlags |= MethodImplAttributes.PreserveSig;
}
if (setLastError.HasValue && setLastError.Value)
{
flags |= SupportsLastError;
}
ImplMapTable.Record rec = new ImplMapTable.Record();
rec.MappingFlags = flags;
rec.MemberForwarded = pseudoToken;
rec.ImportName = this.ModuleBuilder.Strings.Add(entryName ?? name);
rec.ImportScope = this.ModuleBuilder.ModuleRef.FindOrAddRecord(dllName == null ? 0 : this.ModuleBuilder.Strings.Add(dllName));
this.ModuleBuilder.ImplMap.AddRecord(rec);
}
public void SetImplementationFlags(MethodImplAttributes attributes)
{
methodBuilder.SetImplementationFlags(attributes);
}
public void SetImplementationFlags(MethodImplAttributes attributes)
{
implFlags = attributes;
}
public void SetImplementationFlags(MethodImplAttributes attributes)
{
ConstructorBuilder.SetImplementationFlags(attributes);
}
bool GetFlagValue(MethodImplAttributes flag)
{
return((ImplAttributes & flag) != 0);
}
(string methodName, DkmClrCompilationResultFlags flags) AddMethod(TypeSig type, int index, bool isLocal)
{
var methodName = methodNamePrefix + methodNameIndex++.ToString();
var callConv = CallingConvention.Default;
if (sourceMethod.MethodSig.Generic)
{
callConv |= CallingConvention.Generic;
}
var methodSig = new MethodSig(callConv, sourceMethod.MethodSig.GenParamCount);
methodSig.RetType = generatedModule.Import(type.RemovePinnedAndModifiers());
if (methodSig.RetType.IsByRef)
{
methodSig.RetType = methodSig.RetType.Next.RemovePinnedAndModifiers();
}
if (lastMethodSig != null)
{
foreach (var p in lastMethodSig.Params)
{
methodSig.Params.Add(p);
}
}
else
{
if (sourceMethod.MethodSig.HasThis)
{
methodSig.Params.Add(generatedModule.Import(sourceMethod.DeclaringType).ToTypeSig());
}
foreach (var p in sourceMethod.MethodSig.Params)
{
methodSig.Params.Add(generatedModule.Import(p));
}
}
const MethodImplAttributes methodImplFlags = MethodImplAttributes.IL | MethodImplAttributes.Managed;
const MethodAttributes methodFlags = MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.ReuseSlot;
var method = new MethodDefUser(methodName, methodSig, methodImplFlags, methodFlags);
getLocalsType.Methods.Add(method);
foreach (var gp in sourceMethod.GenericParameters)
{
method.GenericParameters.Add(Clone(gp));
}
var body = new CilBody();
method.Body = body;
body.InitLocals = true;
if (sourceMethod.Body != null)
{
foreach (var l in sourceMethod.Body.Variables)
{
body.Variables.Add(new Local(generatedModule.Import(l.Type), l.Name));
}
}
body.Instructions.Add(CreateLoadVariable(method, body.Variables, index, isLocal));
if (type.RemovePinnedAndModifiers().GetElementType() == ElementType.ByRef)
{
body.Instructions.Add(LoadIndirect(type.RemovePinnedAndModifiers().Next.RemovePinnedAndModifiers()));
}
body.Instructions.Add(Instruction.Create(OpCodes.Ret));
lastMethodSig = methodSig;
var flags = DkmClrCompilationResultFlags.None;
if (methodSig.RetType.RemovePinnedAndModifiers().GetElementType() == ElementType.Boolean)
{
flags |= DkmClrCompilationResultFlags.BoolResult;
}
return(methodName, flags);
}
public static void Dump(Assembly asm)
{
const MethodImplAttributes BadFlags = MethodImplAttributes.InternalCall | MethodImplAttributes.Native | MethodImplAttributes.Unmanaged;
bool TypeNeedsPlugs = false;
bool firstParam = true;
string str = "";
string genParams = "";
string curDir = Application.StartupPath + "\\PlugTemplates\\" + asm.GetName().Name + "\\";
if (!Directory.Exists(Application.StartupPath + "\\PlugTemplates\\"))
{
Directory.CreateDirectory(Application.StartupPath + "\\PlugTemplates\\");
}
StreamWriter strm = null; // Only set to null to appease the compiler.
foreach (Type t in asm.GetTypes())
{
if (t.BaseType != null && t.BaseType.FullName != "System.MulticastDelegate")
{
foreach (MethodInfo m in t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly))
{
if ((m.GetMethodImplementationFlags() & BadFlags) != 0 || (m.Attributes & MethodAttributes.PinvokeImpl) != 0)
{
if (!TypeNeedsPlugs)
{
if (!Directory.Exists(curDir))
{
Directory.CreateDirectory(curDir);
}
if (t.Namespace != null)
{
if (!Directory.Exists(curDir + t.Namespace.Replace('.', '\\') + "\\"))
{
Directory.CreateDirectory(curDir + t.Namespace.Replace('.', '\\') + "\\");
}
}
genParams = "";
str = "";
if (t.IsGenericTypeDefinition)
{
genParams = "<";
str = "<"; // This will be used for the typeof target.
firstParam = true;
foreach (Type T in t.GetGenericArguments())
{
if (!firstParam)
{
genParams += ", ";
str += ", ";
}
genParams += T.Name;
str += "object";
}
genParams += ">";
str += ">";
}
if (t.Namespace != null)
{
strm = new StreamWriter(curDir + t.Namespace.Replace('.', '\\') + "\\" + t.Name + "Impl.cs");
}
else
{
strm = new StreamWriter(curDir + "\\" + t.Name + "Impl.cs");
}
strm.WriteLine("namespace Cosmos.Plugs");
strm.WriteLine("{");
strm.WriteLine("\t[Cosmos.IL2CPU.Plugs.Plug(Target = typeof(" + t.Namespace + "." + t.Name + str + "), TargetFramework = Cosmos.IL2CPU.Plugs.FrameworkVersion.v4_0)]");
strm.WriteLine("\tpublic static class " + t.FullName.Replace('.', '_') + "Impl" + genParams);
strm.WriteLine("\t{");
TypeNeedsPlugs = true;
}
strm.WriteLine();
str = "";
firstParam = true;
if (!m.IsStatic)
{
if (t.IsValueType && !t.IsEnum) // aka, a struct, instance members are references.
{
str += "ref " + t.FullName.Replace('&', '*') + " aThis";
}
else // Something else, instance members aren't references.
{
str += t.FullName.Replace('&', '*') + " aThis";
}
firstParam = false;
}
if (m.ContainsGenericParameters)
{
foreach (ParameterInfo p in m.GetParameters())
{
if (!firstParam)
{
str += ", ";
}
if (p.ParameterType.IsGenericType || p.ParameterType.IsGenericParameter || p.ParameterType.IsGenericTypeDefinition)
{
str += p.ParameterType.Name + " " + p.Name;
}
else
{
if (p.ParameterType.FullName != null)
{
str += p.ParameterType.FullName.Replace('&', '*') + " " + p.Name;
}
else
{
str += p.ParameterType.Name.Replace('&', '*') + " " + p.Name;
}
}
firstParam = false;
}
}
else
{
foreach (ParameterInfo p in m.GetParameters())
{
if (!firstParam)
{
str += ", ";
}
str += p.ParameterType.FullName.Replace('&', '*') + " " + p.Name;
firstParam = false;
}
}
if (m.ReturnType.IsGenericParameter || m.ReturnType.IsGenericType)
{
strm.WriteLine("\t\tpublic static " + m.ReturnType.Name + " " + m.Name + "(" + str + ")");
}
else
{
strm.WriteLine("\t\tpublic static " + m.ReturnType.FullName.Replace('&', '*') + " " + m.Name + "(" + str + ")");
}
strm.WriteLine("\t\t{");
strm.WriteLine("\t\t\tthrow new System.NotImplementedException(\"Method '" + t.FullName + "." + m.Name + "' has not been implemented!\");");
strm.WriteLine("\t\t}");
}
}
if (TypeNeedsPlugs)
{
strm.WriteLine("\t}");
strm.WriteLine("}");
strm.Flush();
strm.Close();
}
TypeNeedsPlugs = false;
}
}
}
internal MyConstructorBuilder()
{
try
{
// <Snippet1>
MethodBuilder myMethodBuilder = null;
AppDomain myCurrentDomain = AppDomain.CurrentDomain;
// Create assembly in current CurrentDomain.
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "TempAssembly";
// Create a dynamic assembly.
myAssemblyBuilder = myCurrentDomain.DefineDynamicAssembly
(myAssemblyName, AssemblyBuilderAccess.Run);
// Create a dynamic module in the assembly.
myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("TempModule", true);
FieldInfo myFieldInfo2 =
myModuleBuilder.DefineUninitializedData("myField", 2, FieldAttributes.Public);
// Create a type in the module.
TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("TempClass", TypeAttributes.Public);
FieldBuilder myGreetingField = myTypeBuilder.DefineField("Greeting",
typeof(String), FieldAttributes.Public);
Type[] myConstructorArgs = { typeof(String) };
// Define a constructor of the dynamic class.
ConstructorBuilder myConstructor = myTypeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard, myConstructorArgs);
// Set the method implementation flags for the constructor.
myConstructor.SetImplementationFlags(MethodImplAttributes.PreserveSig | MethodImplAttributes.Runtime);
// Get the method implementation flags for the constructor.
MethodImplAttributes myMethodAttributes = myConstructor.GetMethodImplementationFlags();
Type myAttributeType = typeof(MethodImplAttributes);
int myAttribValue = (int)myMethodAttributes;
if (!myAttributeType.IsEnum)
{
Console.WriteLine("This is not an Enum");
}
// Display the field info names of the retrieved method implementation flags.
FieldInfo[] myFieldInfo = myAttributeType.GetFields(BindingFlags.Public | BindingFlags.Static);
Console.WriteLine("The Field info names of the MethodImplAttributes for the constructor are:");
for (int i = 0; i < myFieldInfo.Length; i++)
{
int myFieldValue = (Int32)myFieldInfo[i].GetValue(null);
if ((myFieldValue & myAttribValue) == myFieldValue)
{
Console.WriteLine(" " + myFieldInfo[i].Name);
}
}
// </Snippet1>
// Add a method to the type.
myMethodBuilder = myTypeBuilder.DefineMethod
("HelloWorld", MethodAttributes.Public, null, null);
// Generate IL for the method.
ILGenerator myILGenerator2 = myMethodBuilder.GetILGenerator();
myILGenerator2.EmitWriteLine("Hello World from global");
myILGenerator2.Emit(OpCodes.Ret);
myModuleBuilder.CreateGlobalFunctions();
myType1 = myTypeBuilder.CreateType();
}
catch (InvalidOperationException ex)
{
Console.WriteLine("The following exception has occurred : " + ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("The following exception has occurred : " + ex.Message);
}
}
private static MethodBuilder AddPropertyChangedEvent(TypeBuilder tb)
{
var eventHandlerType = typeof(PropertyChangedEventHandler);
var eventArgsConstrInfo = typeof(PropertyChangedEventArgs).GetConstructor(new[] { typeof(string) });
var invokeDelegate = typeof(PropertyChangedEventHandler).GetMethod("Invoke");
const string eventName = "PropertyChanged";
const MethodAttributes eventMethodAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final | MethodAttributes.SpecialName;
const MethodImplAttributes eventMethodImpAtr = MethodImplAttributes.Managed | MethodImplAttributes.Synchronized;
var fieldBuilder = tb.DefineField(eventName, eventHandlerType, FieldAttributes.Private);
var eventBuilder = tb.DefineEvent(eventName, EventAttributes.None, eventHandlerType);
var addMethodBuilder = tb.DefineMethod("add_" + eventName, eventMethodAttr, null, new[] { eventHandlerType });
addMethodBuilder.SetImplementationFlags(eventMethodImpAtr);
addMethodBuilder.DefineParameter(1, ParameterAttributes.None, "value");
var combineInfo = typeof(Delegate).GetMethod("Combine", new[] { typeof(Delegate), typeof(Delegate) });
var addIL = addMethodBuilder.GetILGenerator();
addIL.Emit(OpCodes.Ldarg_0);
addIL.Emit(OpCodes.Ldarg_0);
addIL.Emit(OpCodes.Ldfld, fieldBuilder);
addIL.Emit(OpCodes.Ldarg_1);
addIL.Emit(OpCodes.Call, combineInfo);
addIL.Emit(OpCodes.Castclass, eventHandlerType);
addIL.Emit(OpCodes.Stfld, fieldBuilder);
addIL.Emit(OpCodes.Ret);
var removeMethodBuilder = tb.DefineMethod("remove_" + eventName,
eventMethodAttr, null, new[] { eventHandlerType });
removeMethodBuilder.SetImplementationFlags(eventMethodImpAtr);
removeMethodBuilder.DefineParameter(1, ParameterAttributes.None, "value");
var removeInfo = typeof(Delegate).GetMethod("Remove", new[] { typeof(Delegate), typeof(Delegate) });
var remIL = removeMethodBuilder.GetILGenerator();
remIL.Emit(OpCodes.Ldarg_0);
remIL.Emit(OpCodes.Ldarg_0);
remIL.Emit(OpCodes.Ldfld, fieldBuilder);
remIL.Emit(OpCodes.Ldarg_1);
remIL.Emit(OpCodes.Call, removeInfo);
remIL.Emit(OpCodes.Castclass, eventHandlerType);
remIL.Emit(OpCodes.Stfld, fieldBuilder);
remIL.Emit(OpCodes.Ret);
eventBuilder.SetAddOnMethod(addMethodBuilder);
eventBuilder.SetRemoveOnMethod(removeMethodBuilder);
var onExecute = tb.DefineMethod("On" + eventName,
MethodAttributes.Private | MethodAttributes.HideBySig,
null, new[] { typeof(string) });
onExecute.DefineParameter(1, ParameterAttributes.None, "propName");
var exeIL = onExecute.GetILGenerator();
var lblDelegateOk = exeIL.DefineLabel();
exeIL.DeclareLocal(typeof(PropertyChangedEventHandler));
exeIL.Emit(OpCodes.Nop);
exeIL.Emit(OpCodes.Ldarg_0);
exeIL.Emit(OpCodes.Ldfld, fieldBuilder);
exeIL.Emit(OpCodes.Stloc_0);
exeIL.Emit(OpCodes.Ldloc_0);
exeIL.Emit(OpCodes.Ldnull);
exeIL.Emit(OpCodes.Ceq);
exeIL.Emit(OpCodes.Brtrue, lblDelegateOk);
exeIL.Emit(OpCodes.Ldloc_0);
exeIL.Emit(OpCodes.Ldarg_0);
exeIL.Emit(OpCodes.Ldarg_1);
exeIL.Emit(OpCodes.Newobj, eventArgsConstrInfo);
exeIL.Emit(OpCodes.Callvirt, invokeDelegate);
exeIL.MarkLabel(lblDelegateOk);
exeIL.Emit(OpCodes.Ret);
return(onExecute);
}
public void SetImplementationFlags(MethodImplAttributes attributes)
{
RejectIfCreated();
iattrs = attributes;
}
public EditedMethodBody(MethodDef originalMethod, Emit.MethodBody newBody, MethodImplAttributes implAttributes)
{
OriginalMethod = originalMethod;
NewBody = newBody;
ImplAttributes = implAttributes;
}
