public MethodRefSignature(byte[] signiture) : base(Signatures.MethodRef)
{
Offset offset = 0;
var calling = new CallingConventionSignatureToken(signiture, offset);
Tokens.Add(calling);
if ((calling.Convention & CallingConventions.Generic) != 0)
{
var genParamCount = new GenericParamaterCountSignatureToken(signiture, offset);
Tokens.Add(genParamCount);
}
var paramCount = new ParameterCountSignatureToken(signiture, offset);
Tokens.Add(paramCount);
var returnType = new ReturnTypeSignatureToken(signiture, offset);
Tokens.Add(returnType);
for (int i = 0; i < paramCount.Count; i++)
{
if (SentinalSignatureToken.IsToken(signiture, offset))
{
i--; // This is not a parameter
Tokens.Add(new SentinalSignatureToken(signiture, offset));
}
else
{
var param = new ParamSignatureToken(signiture, offset);
Tokens.Add(param);
}
}
}
/// <summary>
/// Initialises a new instance of the property signiture from the provided <paramref name="signiture"/>.
/// </summary>
/// <param name="signiture">The signiture blob.</param>
public PropertySignature(byte[] signiture)
: base(Signatures.Property)
{
Offset offset = 0;
ElementTypeSignatureToken property = new ElementTypeSignatureToken(signiture, offset);
Tokens.Add(property);
ParameterCountSignatureToken paramCount = new ParameterCountSignatureToken(signiture, offset);
Tokens.Add(paramCount);
while (CustomModifierToken.IsToken(signiture, offset))
{
CustomModifierToken modifier = new CustomModifierToken(signiture, offset);
Tokens.Add(modifier);
}
ElementTypeSignatureToken type = new ElementTypeSignatureToken(signiture, offset);
Tokens.Add(type);
for (int i = 0; i < paramCount.Count; i++)
{
ParamSignatureToken param = new ParamSignatureToken(signiture, offset);
Tokens.Add(param);
}
}
/// <summary>
/// Converts the method parameters to a cref path implementation, this in itself
/// is not enough. This is used by the cref parse methods.
/// </summary>
/// <param name="method">The method to convert the parameters for.</param>
/// <returns>The converted string.</returns>
protected string Convert(MethodDef method)
{
Signature loadedSigniture = method.Signiture;
StringBuilder convertedSigniture = new StringBuilder();
List <ParamSignatureToken> parametersToConvert = loadedSigniture.GetParameterTokens();
if (parametersToConvert != null && parametersToConvert.Count > 0)
{
bool hadReturnParameter = false;
bool isFirstParameter = true;
convertedSigniture.Append("(");
for (int i = 0; i < method.Parameters.Count; i++)
{
ParamDef currentParameter = method.Parameters[i];
if (currentParameter.Sequence == 0)
{
hadReturnParameter = true;
continue;
}
if (!IncludeFirstParameter && (i == 0 || hadReturnParameter && i == 1))
{
continue;
}
ParamSignatureToken currentToken = parametersToConvert[hadReturnParameter ? i - 1 : i];
TypeRef typeRef = currentToken.ResolveParameter(method.Assembly, currentParameter);
if (isFirstParameter)
{
isFirstParameter = false;
}
else
{
convertedSigniture.Append(ParameterSeperater);
}
if (ByRefAtFront)
{
if (currentToken.IsByRef)
{
convertedSigniture.Append(ByRef);
}
}
this.Convert(
convertedSigniture,
method.Assembly,
currentParameter,
currentToken,
currentToken.ElementType.ElementType,
typeRef);
if (!ByRefAtFront)
{
if (currentToken.IsByRef)
{
convertedSigniture.Append(ByRef);
}
}
}
convertedSigniture.Append(")");
}
return(convertedSigniture.ToString());
}
/// <summary>
/// Method which performs the actual conversion of a signiture to a cref string.
/// </summary>
/// <param name="sb">The string builder to hold the converted text</param>
/// <param name="assembly">The assembly the current parameter is defined in</param>
/// <param name="param">The parameter definition, required for token resolution</param>
/// <param name="currentToken">The current token to converty</param>
/// <param name="elementType">The type of element the token represents</param>
/// <param name="resolvedType">The resolved type for this token.</param>
private void Convert(StringBuilder sb, AssemblyDef assembly, ParamDef param, SignatureToken currentToken, ElementTypes elementType, TypeRef resolvedType)
{
StringBuilder convertedSigniture = sb;
if (currentToken.TokenType == SignatureTokens.Param)
{
ParamSignatureToken paramToken = currentToken as ParamSignatureToken;
SignatureToken childToken = paramToken.Tokens[paramToken.Tokens.Count - 1];
if (childToken.TokenType == SignatureTokens.Type)
{
currentToken = childToken;
elementType = ((TypeSignatureToken)childToken).ElementType.ElementType;
}
else
{
currentToken = childToken;
elementType = ((ElementTypeSignatureToken)childToken).ElementType;
}
}
TypeSignatureToken typeToken = currentToken as TypeSignatureToken;
ElementTypeSignatureToken elementToken = currentToken as ElementTypeSignatureToken;
switch (elementType)
{
case ElementTypes.Var: ConvertVar(convertedSigniture, typeToken.ElementType.Token, param); break;
case ElementTypes.MVar: ConvertMVar(convertedSigniture, typeToken.ElementType.Token, param); break;
case ElementTypes.SZArray:
// TODO: Fix the custom modifier section
if (typeToken.Tokens[0] is CustomModifierToken)
{
NotImplementedException ex = new NotImplementedException("Custom modifiers are not implemented on SZArray");
ex.Data["token"] = currentToken;
throw ex;
}
ElementTypes szArrayElementType;
if (typeToken.Tokens[1].TokenType == SignatureTokens.Type)
{
szArrayElementType = ((TypeSignatureToken)typeToken.Tokens[1]).ElementType.ElementType;
}
else
{
szArrayElementType = ((ElementTypeSignatureToken)typeToken.Tokens[1]).ElementType;
}
Convert(
sb,
assembly,
param,
typeToken.Tokens[1],
szArrayElementType,
resolvedType);
convertedSigniture.Append("[]");
break;
case ElementTypes.Array:
ArrayShapeSignatureToken shape = typeToken.Tokens.Last() as ArrayShapeSignatureToken;
ConvertArray(convertedSigniture, resolvedType, shape);
break;
case ElementTypes.GenericInstance:
TypeRef genericType = ((ElementTypeSignatureToken)typeToken.Tokens[1]).ResolveToken(assembly);
GetTypeName(convertedSigniture, genericType);
GenericArgumentCountSignatureToken argsCount = typeToken.GetGenericArgumentCount();
bool isFirstArgument = true;
if (argsCount.Count > 0)
{
sb.Append(GenericStart);
for (int j = 0; j < argsCount.Count; j++)
{
if (isFirstArgument)
{
isFirstArgument = false;
}
else
{
sb.Append(",");
}
TypeRef argResolvedType;
ElementTypes elType;
if (typeToken.Tokens[j + 3].TokenType == SignatureTokens.ElementType)
{
ElementTypeSignatureToken gESig = (ElementTypeSignatureToken)typeToken.Tokens[j + 3];
argResolvedType = gESig.ResolveToken(assembly);
elType = gESig.ElementType;
}
else
{
TypeSignatureToken gTSig = (TypeSignatureToken)typeToken.Tokens[j + 3];
argResolvedType = gTSig.ResolveType(assembly, param);
elType = gTSig.ElementType.ElementType;
}
Convert(
sb,
assembly,
param,
typeToken.Tokens[j + 3],
elType,
argResolvedType);
}
sb.Append(GenericEnd);
}
break;
case ElementTypes.Class:
case ElementTypes.ValueType:
case ElementTypes.Char:
case ElementTypes.I:
case ElementTypes.I1:
case ElementTypes.I2:
case ElementTypes.I4:
case ElementTypes.I8:
case ElementTypes.Object:
case ElementTypes.R4:
case ElementTypes.R4_HFA:
case ElementTypes.R8:
case ElementTypes.R8_HFA:
case ElementTypes.String:
case ElementTypes.U:
case ElementTypes.U1:
case ElementTypes.U2:
case ElementTypes.U4:
case ElementTypes.U8:
case ElementTypes.TypedByRef:
case ElementTypes.Boolean:
GetTypeName(convertedSigniture, resolvedType);
break;
case ElementTypes.Ptr:
GetTypeName(convertedSigniture, resolvedType);
convertedSigniture.Append("*");
break;
case ElementTypes.FunctionPointer:
NotImplementedException fnPtrEx = new NotImplementedException("Function Pointer is not implemented yet.");
fnPtrEx.Data["token"] = currentToken;
throw fnPtrEx;
}
}
