internal static MethodSignature Decode(BufferedBinaryReader reader, SignatureFlags flags) { var type = (flags & SignatureFlags.TYPEMASK); if (!(type == SignatureFlags.PROPERTY || (type >= SignatureFlags.DEFAULT && type <= SignatureFlags.VARARG))) { throw new BadMetadataException("Incorrect signature for method."); } var sig = new MethodSignature(); if (type == SignatureFlags.PROPERTY) { sig.IsProperty = true; } if ((flags & SignatureFlags.HASTHIS) != 0) { sig.CallingConventions |= CallingConventions.HasThis; } if ((flags & SignatureFlags.EXPLICITTHIS) != 0) { sig.CallingConventions |= CallingConventions.ExplicitThis; } if (type == SignatureFlags.VARARG) { sig.CallingConventions &= CallingConventions.Standard; sig.CallingConventions |= CallingConventions.VarArgs; } if ((flags & SignatureFlags.GENERIC) != 0) { sig.GenericParamCount = reader.ReadPackedInt(); } int paramCount = reader.ReadPackedInt(); sig.Type = TypeSignature.Decode(reader); sig.Params = new TypeSignature[paramCount]; for (int i = 0; i < paramCount; ++i) { sig.Params[i] = TypeSignature.Decode(reader); } return(sig); }
public static string ReadCountedUtf8(this BufferedBinaryReader reader) { int b0 = reader.ReadUInt8(); if (b0 == 0xFF) { return(null); } if (b0 == 0) { return(string.Empty); } int len = reader.ReadPackedInt(b0); return(reader.ReadUtf8(len)); }
private IType[] ReadMethodSpecArgs(BufferedBinaryReader reader, Context context) { if (reader.ReadByte() != 0x0A) { throw new BadSignatureException("Invalid MethodSpec signature"); } int n = reader.ReadPackedInt(); var args = new IType[n]; for (int i = 0; i < n; ++i) { var sig = TypeSignature.Decode(reader); args[i] = _loader.ResolveType(sig, context); } return(args); }
public BufferedBinaryReader Fetch(uint offset) { if (offset >= _heap.Length) { throw new BadMetadataException("Invalid #Blob heap offset."); } _heap.Seek(offset, SeekOrigin.Begin); int length = _heap.ReadPackedInt(); if (length <= 0) { return(Zero); } //TODO: implement slice without need to know that _heap is another slice return(_heap.Slice(0, length)); }
public string Fetch(uint offset) { if (offset == 0) { throw new BadMetadataException("Invalid #US heap offset."); } _heap.Seek(offset, SeekOrigin.Begin); int length = _heap.ReadPackedInt(); var bytes = _heap.ReadBytes(length); if (bytes[length - 1] == 0 || bytes[length - 1] == 1) { length--; } return(Encoding.Unicode.GetString(bytes, 0, length)); }
public static TypeSignature Decode(BufferedBinaryReader reader) { var e = (ElementType)reader.ReadPackedInt(); switch (e) { case ElementType.End: case ElementType.Void: case ElementType.Boolean: case ElementType.Char: case ElementType.Int8: case ElementType.UInt8: case ElementType.Int16: case ElementType.UInt16: case ElementType.Int32: case ElementType.UInt32: case ElementType.Int64: case ElementType.UInt64: case ElementType.Single: case ElementType.Double: case ElementType.String: case ElementType.TypedReference: case ElementType.IntPtr: case ElementType.UIntPtr: case ElementType.Object: return(new TypeSignature(e)); case ElementType.Ptr: case ElementType.ByRef: { var type = Decode(reader); if (type == null) { throw new BadSignatureException(String.Format("Unable to decode type of {0} signature.", e)); } return(new TypeSignature(e, type)); } case ElementType.ValueType: case ElementType.Class: case ElementType.CustomArgsEnum: { var index = DecodeTypeDefOrRef(reader); return(new TypeSignature(e, index)); } case ElementType.Array: { var type = Decode(reader); if (type == null) { throw new BadSignatureException("Unable to decode type of array."); } int rank = reader.ReadPackedInt(); int numSizes = reader.ReadPackedInt(); var info = new ArrayShape { Rank = rank, Sizes = new int[numSizes] }; for (int i = 0; i < numSizes; i++) { info.Sizes[i] = reader.ReadPackedInt(); } int numLoBounds = reader.ReadPackedInt(); info.LoBounds = new int[numLoBounds]; for (int i = 0; i < numLoBounds; i++) { info.LoBounds[i] = reader.ReadPackedInt(); } return(new TypeSignature(e, type, info)); } case ElementType.ArraySz: { var type = Decode(reader); if (type == null) { throw new BadSignatureException("Unable to decode type of single-dimensional array signature."); } return(new TypeSignature(e, type, ArrayShape.Single)); } case ElementType.MethodPtr: { var msig = MethodSignature.Decode(reader); return(new TypeSignature(e, msig)); } case ElementType.RequiredModifier: case ElementType.OptionalModifier: { var i = DecodeTypeDefOrRef(reader); var type = Decode(reader); return(new TypeSignature(e, i, type)); } case ElementType.Sentinel: case ElementType.Pinned: { var type = Decode(reader); return(new TypeSignature(e, type)); } case ElementType.GenericInstantiation: { var type = Decode(reader); int n = reader.ReadPackedInt(); var genericParams = new TypeSignature[n]; for (int i = 0; i < n; i++) { genericParams[i] = Decode(reader); } return(new TypeSignature(e, type, genericParams)); } case ElementType.Var: case ElementType.MethodVar: { int num = reader.ReadPackedInt(); return(new TypeSignature(e, num)); } } throw new BadSignatureException("Unknown element type."); }
private static SimpleIndex DecodeTypeDefOrRef(BufferedBinaryReader reader) { var token = (uint)reader.ReadPackedInt(); return(CodedIndex.TypeDefOrRef.Decode(token)); }