/// <summary>
/// Write a <see cref="CallingConventionSig"/> signature
/// </summary>
/// <param name="helper">Helper</param>
/// <param name="sig">The signature</param>
/// <returns>The signature as a byte array</returns>
public static byte[] Write(ISignatureWriterHelper helper, CallingConventionSig sig)
{
using (var writer = new SignatureWriter(helper)) {
writer.Write(sig);
return(writer.GetResult());
}
}
internal static byte[] Write(ISignatureWriterHelper helper, CallingConventionSig sig, DataWriterContext context)
{
using (var writer = new SignatureWriter(helper, context)) {
writer.Write(sig);
return(writer.GetResult());
}
}
public MemberRefOptions(MemberRef mr)
{
this.Class = mr.Class;
this.Name = mr.Name;
this.Signature = mr.Signature;
this.CustomAttributes.AddRange(mr.CustomAttributes);
}
private static IMemberDef FindArgumentMemberDef(UTF8String name, CallingConventionSig propertySig, TypeDef attrType)
{
while (attrType != null)
{
var property = attrType.FindProperty(name, propertySig);
if (property != null)
{
return(property);
}
attrType = attrType.BaseType.ResolveTypeDef();
}
return(null);
}
CallingConventionSig?ResolveGenericArgs(CallingConventionSig sig)
{
if (!recursionCounter.Increment())
{
return(null);
}
CallingConventionSig?result;
MethodSig? msig;
FieldSig? fsig;
LocalSig? lsig;
PropertySig? psig;
GenericInstMethodSig?gsig;
if (!((msig = sig as MethodSig) is null))
{
result = ResolveGenericArgs(msig);
}
CallingConventionSig ResolveGenericArgs(CallingConventionSig sig)
{
if (!recursionCounter.Increment())
{
return(null);
}
CallingConventionSig result;
MethodSig msig;
FieldSig fsig;
LocalSig lsig;
PropertySig psig;
GenericInstMethodSig gsig;
if ((msig = sig as MethodSig) != null)
{
result = ResolveGenericArgs(msig);
}
else if ((fsig = sig as FieldSig) != null)
{
result = ResolveGenericArgs(fsig);
}
else if ((lsig = sig as LocalSig) != null)
{
result = ResolveGenericArgs(lsig);
}
else if ((psig = sig as PropertySig) != null)
{
result = ResolveGenericArgs(psig);
}
else if ((gsig = sig as GenericInstMethodSig) != null)
{
result = ResolveGenericArgs(gsig);
}
else
{
result = null;
}
recursionCounter.Decrement();
return(result);
}
private void Write(CallingConventionSig sig)
{
if (sig == null)
{
helper.Error("sig is null");
return;
}
if (!recursionCounter.Increment())
{
helper.Error("Infinite recursion");
return;
}
MethodBaseSig mbs;
FieldSig fs;
LocalSig ls;
GenericInstMethodSig gim;
if ((mbs = sig as MethodBaseSig) != null)
{
Write(mbs);
}
else if ((fs = sig as FieldSig) != null)
{
Write(fs);
}
else if ((ls = sig as LocalSig) != null)
{
Write(ls);
}
else if ((gim = sig as GenericInstMethodSig) != null)
{
Write(gim);
}
else
{
helper.Error("Unknown calling convention sig");
writer.Write((byte)sig.GetCallingConvention());
}
recursionCounter.Decrement();
}
void Write(CallingConventionSig sig)
{
if (sig is null)
{
helper.Error("sig is null");
return;
}
if (!recursionCounter.Increment())
{
helper.Error("Infinite recursion");
return;
}
MethodBaseSig mbs;
FieldSig fs;
LocalSig ls;
GenericInstMethodSig gim;
if (!((mbs = sig as MethodBaseSig) is null))
{
Write(mbs);
}
void Add(CallingConventionSig sig)
{
if (sig == null)
{
return;
}
var fs = sig as FieldSig;
if (fs != null)
{
Add(fs);
return;
}
var mbs = sig as MethodBaseSig;
if (mbs != null)
{
Add(mbs);
return;
}
var ls = sig as LocalSig;
if (ls != null)
{
Add(ls);
return;
}
var gims = sig as GenericInstMethodSig;
if (gims != null)
{
Add(gims);
return;
}
}
public MethodSpecOptions(MethodSpec ms)
{
Method = ms.Method;
Instantiation = ms.Instantiation;
CustomAttributes.AddRange(ms.CustomAttributes);
}
/// <summary>
/// Write a <see cref="CallingConventionSig"/> signature
/// </summary>
/// <param name="helper">Helper</param>
/// <param name="sig">The signature</param>
/// <returns>The signature as a byte array</returns>
public static byte[] Write(ISignatureWriterHelper helper, CallingConventionSig sig) {
using (var writer = new SignatureWriter(helper)) {
writer.Write(sig);
return writer.GetResult();
}
}
void Write(CallingConventionSig sig) {
if (sig == null) {
helper.Error("sig is null");
return;
}
if (!recursionCounter.Increment()) {
helper.Error("Infinite recursion");
return;
}
MethodBaseSig mbs;
FieldSig fs;
LocalSig ls;
GenericInstMethodSig gim;
if ((mbs = sig as MethodBaseSig) != null)
Write(mbs);
else if ((fs = sig as FieldSig) != null)
Write(fs);
else if ((ls = sig as LocalSig) != null)
Write(ls);
else if ((gim = sig as GenericInstMethodSig) != null)
Write(gim);
else {
helper.Error("Unknown calling convention sig");
writer.Write((byte)sig.GetCallingConvention());
}
recursionCounter.Decrement();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name</param>
/// <param name="signature">Signature</param>
/// <param name="flags">Flags</param>
public FieldDefUser(UTF8String name, FieldSig signature, FieldAttributes flags) {
this.name = name;
this.signature = signature;
this.flags = flags;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name</param>
/// <param name="sig">Property signature</param>
/// <param name="flags">Flags</param>
public PropertyDefUser(UTF8String name, PropertySig sig, PropertyAttributes flags) {
this.name = name;
this.type = sig;
this.flags = flags;
}
