/// <summary> /// Factory method for creating new Signatures. /// </summary> /// <param name="source">The contents of the library the signiture is being read from</param> /// <param name="offset">The offset to the start of the signiture</param> /// <param name="tokenType">The type of signiture being read.</param> /// <returns></returns> public static Signature Create(byte[] source, Offset offset, Signatures tokenType) { int startingOffset = offset; uint lengthOfSigniture = SignatureToken.GetCompressedValue(source, offset); // The first byte is always the length // Read the full signiture byte[] signiture = new byte[lengthOfSigniture]; for (int i = 0; i < lengthOfSigniture; i++) { signiture[i] = source[offset.Shift(1)]; } // Instatiate the correct signiture reader and pass control Signature instantiatedSigniture = null; switch (tokenType) { case Signatures.CustomAttribute: // instantiatedSigniture = new CustomAttributeSigniture(signiture); break; case Signatures.MethodSpecification: // to do: implement break; case Signatures.LocalVariable: instantiatedSigniture = new LocalVariableSignature(signiture); break; case Signatures.MethodDef: instantiatedSigniture = new MethodDefSignature(signiture); break; case Signatures.MethodRef: instantiatedSigniture = new MethodRefSignature(signiture); break; case Signatures.Field: instantiatedSigniture = new FieldSignature(signiture); break; case Signatures.Property: instantiatedSigniture = new PropertySignature(signiture); break; case Signatures.TypeSpecification: instantiatedSigniture = new TypeSpecificationSignature(signiture); break; } return(instantiatedSigniture); }
/// <summary> /// Instantiates a new instance of the ElementTypeSignitureToken class. /// </summary> /// <include file='code-documentation\signatures.xml' path='docs/elementtypesignaturetoken/member[@name="ctor"]/*'/> public ElementTypeSignatureToken(byte[] signiture, Offset offset) : base(SignatureTokens.ElementType) { ElementType = (ElementTypes)GetCompressedValue(signiture, offset); switch (ElementType) { case ElementTypes.Class: case ElementTypes.ValueType: DecodeEncodedDefRefSpecToken(signiture, offset); break; case ElementTypes.MVar: case ElementTypes.Var: Token = SignatureToken.GetCompressedValue(signiture, offset); break; // Well known types case ElementTypes.Boolean: Definition = WellKnownTypeDef.Boolean; break; case ElementTypes.I: Definition = WellKnownTypeDef.I; break; case ElementTypes.I1: Definition = WellKnownTypeDef.I1; break; case ElementTypes.I2: Definition = WellKnownTypeDef.I2; break; case ElementTypes.I4: Definition = WellKnownTypeDef.I4; break; case ElementTypes.I8: Definition = WellKnownTypeDef.I8; break; case ElementTypes.U: Definition = WellKnownTypeDef.U; break; case ElementTypes.U1: Definition = WellKnownTypeDef.U1; break; case ElementTypes.U2: Definition = WellKnownTypeDef.U2; break; case ElementTypes.U4: Definition = WellKnownTypeDef.U4; break; case ElementTypes.U8: Definition = WellKnownTypeDef.U8; break; case ElementTypes.Char: Definition = WellKnownTypeDef.Char; break; case ElementTypes.R4: Definition = WellKnownTypeDef.R4; break; case ElementTypes.R8: Definition = WellKnownTypeDef.R8; break; case ElementTypes.TypedByRef: Definition = WellKnownTypeDef.TypedByRef; break; case ElementTypes.String: Definition = WellKnownTypeDef.String; break; case ElementTypes.Object: Definition = WellKnownTypeDef.Object; break; case ElementTypes.Void: Definition = WellKnownTypeDef.Void; break; } }
internal TypeRef ResolveType(AssemblyDef assembly, ReflectedMember member) { SignatureToken token = Tokens.Last(); if (token is TypeSignatureToken) { return(((TypeSignatureToken)token).ResolveType(assembly, member)); } else { return(((ElementTypeSignatureToken)token).ResolveToken(assembly)); } }
public TypeDetails GetTypeDetails(ReflectedMember member) { TypeDetails details = new TypeDetails(); SignatureToken token = Tokens.Last(); if (token is TypeSignatureToken) { details = ((TypeSignatureToken)token).GetTypeDetails(member); } else { details.Type = ((ElementTypeSignatureToken)token).ResolveToken(member.Assembly); } return(details); }
/// <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; } }
/// <summary> /// Instantiates a new instance of the ElementTypeSignitureToken class. /// </summary> /// <param name="signiture">The signiture where this token is defined.</param> /// <param name="offset">The current offset in the signiture to read the token.</param> /// <remarks> /// <para> /// An ElementTypeSignitureToken details the element of a Type signiture. These /// elements are defined in section 23.1.16 in ECMA 335. Where a type can contain /// multiple ElementTypeSignitureTokens each building up to reveal more information /// about the type. This class will only ever provide a single item of detail. /// </para> /// </remarks> public ElementTypeSignatureToken(byte[] signiture, Offset offset) : base(SignatureTokens.ElementType) { ElementType = (ElementTypes)GetCompressedValue(signiture, offset); int typeMask; uint token; switch (ElementType) { case ElementTypes.Class: // Read the typedef, typeref or typespec token typeMask = 0x00000003; token = GetCompressedValue(signiture, offset); switch (typeMask & token) { case 0: // TypeDef Token = token >> 2 | (int)ILMetadataToken.TypeDef; // (token & typeMask) | token >> 2; break; case 1: // TypeRef Token = token >> 2 | (int)ILMetadataToken.TypeRef; //(token & typeMask) | token >> 2; break; case 2: // TypeSpec Token = token >> 2 | (int)ILMetadataToken.TypeSpec; // (token & typeMask) | token >> 2; break; } break; case ElementTypes.ValueType: // Read the typedef, typeref or typespec token typeMask = 0x00000003; token = GetCompressedValue(signiture, offset); switch (typeMask & token) { case 0: // TypeDef Token = token >> 2 | (int)ILMetadataToken.TypeDef; // (token & typeMask) | token >> 2; break; case 1: // TypeRef Token = token >> 2 | (int)ILMetadataToken.TypeRef; //(token & typeMask) | token >> 2; break; } break; case ElementTypes.MVar: case ElementTypes.Var: Token = SignatureToken.GetCompressedValue(signiture, offset); break; // Well known types case ElementTypes.Boolean: Definition = WellKnownTypeDef.Boolean; break; case ElementTypes.I: Definition = WellKnownTypeDef.I; break; case ElementTypes.I1: Definition = WellKnownTypeDef.I1; break; case ElementTypes.I2: Definition = WellKnownTypeDef.I2; break; case ElementTypes.I4: Definition = WellKnownTypeDef.I4; break; case ElementTypes.I8: Definition = WellKnownTypeDef.I8; break; case ElementTypes.U: Definition = WellKnownTypeDef.U; break; case ElementTypes.U1: Definition = WellKnownTypeDef.U1; break; case ElementTypes.U2: Definition = WellKnownTypeDef.U2; break; case ElementTypes.U4: Definition = WellKnownTypeDef.U4; break; case ElementTypes.U8: Definition = WellKnownTypeDef.U8; break; case ElementTypes.Char: Definition = WellKnownTypeDef.Char; break; case ElementTypes.R4: Definition = WellKnownTypeDef.R4; break; case ElementTypes.R8: Definition = WellKnownTypeDef.R8; break; case ElementTypes.TypedByRef: Definition = WellKnownTypeDef.TypedByRef; break; case ElementTypes.String: Definition = WellKnownTypeDef.String; break; case ElementTypes.Object: Definition = WellKnownTypeDef.Object; break; case ElementTypes.Void: Definition = WellKnownTypeDef.Void; break; } }