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; } }