protected override void ParseSignature(SignatureReader reader) { this.ParseModifier(reader); this.customMods = CustomMod.ParseCustomMods(reader); this.type = SigType.ParseTypeSignature(reader); }
/// <summary> /// Loads the signature. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> public Signature(IMetadataProvider provider, TokenTypes token) { SignatureReader reader = new SignatureReader(provider.ReadBlob(token)); this.ParseSignature(reader); Debug.Assert(reader.Index == reader.Length, @"Signature parser didn't complete."); this.token = token; }
/// <summary> /// FieldSignature signature is indexed by the Field.Signature column /// </summary> /// <param name="reader">The reader.</param> protected override void ParseSignature(SignatureReader reader) { if (Field != reader.ReadByte()) { throw new InvalidOperationException(@"Invalid method definition signature."); } base.ParseSignature(reader); }
/// <summary> /// Parses the signature. /// </summary> /// <param name="reader">The reader.</param> protected override void ParseSignature(SignatureReader reader) { if (reader.ReadByte() != 0x0A) throw new InvalidOperationException(@"Invalid signature."); int genArgCount = reader.ReadCompressedInt32(); Types = new SigType[genArgCount]; for (int i = 0; i < genArgCount; i++) Types[i] = SigType.ParseTypeSignature(reader); }
public TypeSig ReadTypeSignature(IMetaDataImport mdi, byte[] data) { return(SignatureReader.ReadTypeSig(new SignatureReaderHelper(mdi), corLibTypes, data)); }
/// <summary> /// Initializes a new instance of the <see cref="MethodSignature"/> class. /// </summary> /// <param name="reader">The reader.</param> public MethodSignature(SignatureReader reader) : base(reader) { }
/// <summary> /// Initializes a new instance of the <see cref="TypeSpecSignature"/> class. /// </summary> /// <param name="reader">The reader.</param> public TypeSpecSignature(SignatureReader reader) : base(reader) { }
/// <summary> /// Parses the type signature. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public static SigType ParseTypeSignature(SignatureReader reader) { CilElementType type = (CilElementType)reader.ReadByte(); switch (type) { case CilElementType.Void: return(BuiltInSigType.Void); case CilElementType.Boolean: return(BuiltInSigType.Boolean); case CilElementType.Char: return(BuiltInSigType.Char); case CilElementType.I1: return(BuiltInSigType.SByte); case CilElementType.U1: return(BuiltInSigType.Byte); case CilElementType.I2: return(BuiltInSigType.Int16); case CilElementType.U2: return(BuiltInSigType.UInt16); case CilElementType.I4: return(BuiltInSigType.Int32); case CilElementType.U4: return(BuiltInSigType.UInt32); case CilElementType.I8: return(BuiltInSigType.Int64); case CilElementType.U8: return(BuiltInSigType.UInt64); case CilElementType.R4: return(BuiltInSigType.Single); case CilElementType.R8: return(BuiltInSigType.Double); case CilElementType.String: return(BuiltInSigType.String); case CilElementType.Object: return(BuiltInSigType.Object); case CilElementType.I: return(BuiltInSigType.IntPtr); case CilElementType.U: return(BuiltInSigType.UIntPtr); case CilElementType.TypedByRef: return(BuiltInSigType.TypedByRef); case CilElementType.Array: return(ParseArraySignature(reader)); case CilElementType.Class: return(ParseClassSignature(reader)); case CilElementType.FunctionPtr: return(ParseFunctionPointer(reader)); case CilElementType.GenericInst: return(ParseGenericInstance(reader)); case CilElementType.MVar: return(ParseMVar(reader)); case CilElementType.Ptr: return(ParsePointer(reader)); case CilElementType.SZArray: return(ParseSZArraySignature(reader)); case CilElementType.ValueType: return(ParseValueType(reader)); case CilElementType.Var: return(ParseVar(reader)); case CilElementType.ByRef: return(ParseReference(reader)); default: throw new NotSupportedException(@"Unsupported CIL element type: " + type); } }
/// <summary> /// Initializes a new instance of the <see cref="LocalVariableSignature"/> class. /// </summary> /// <param name="reader">The reader.</param> public LocalVariableSignature(SignatureReader reader) : base(reader) { }
public override void Read(SignatureReader rdr) { Element = rdr.ReadElementType(); }
/// <summary> /// Parses the reference. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseReference(SignatureReader reader) { SigType type = ParseTypeSignature(reader); return(new RefSigType(type)); }
/// <summary> /// Parses the var. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseVar(SignatureReader reader) { int typeVariableIndex = reader.ReadCompressedInt32(); return new VarSigType(typeVariableIndex); }
/// <summary> /// Parses the custom mods. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public static CustomMod[] ParseCustomMods(SignatureReader reader) { List<CustomMod> mods = new List<CustomMod>(); while (reader.Index != reader.Length) { CilElementType type = (CilElementType)reader.PeekByte(); if (type != CilElementType.Optional && type != CilElementType.Required) break; reader.SkipByte(); Token modType = reader.ReadEncodedTypeDefOrRef(); mods.Add(new CustomMod((CustomModType)(type - CilElementType.Required + 1), modType)); } return mods.ToArray(); }
/// <summary> /// Parses the SZ array signature. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseSZArraySignature(SignatureReader reader) { CustomMod[] customMods = CustomMod.ParseCustomMods(reader); SigType elementType = ParseTypeSignature(reader); return new SZArraySigType(customMods, elementType); }
/// <summary> /// Parses the type of the value. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static TypeSigType ParseValueType(SignatureReader reader) { Token token = reader.ReadEncodedTypeDefOrRef(); return new ValueTypeSigType(token); }
/// <summary> /// Parses the reference. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseReference(SignatureReader reader) { SigType type = ParseTypeSignature(reader); return new RefSigType(type); }
/// <summary> /// Parses the pointer. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParsePointer(SignatureReader reader) { CustomMod[] mods = CustomMod.ParseCustomMods(reader); SigType type = ParseTypeSignature(reader); return new PtrSigType(type, mods); }
/// <summary> /// Parses the MVar. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseMVar(SignatureReader reader) { int methodVariableIndex = reader.ReadCompressedInt32(); return new MVarSigType(methodVariableIndex); }
public override void Read(SignatureReader rdr) { Element = rdr.ReadElementType(); tkn = rdr.ReadTypeDefOrRefEncoded(); }
/// <summary> /// Parses the generic instance. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseGenericInstance(SignatureReader reader) { TypeSigType originalType; CilElementType type = (CilElementType)reader.ReadByte(); switch (type) { case CilElementType.Class: originalType = ParseClassSignature(reader); break; case CilElementType.ValueType: originalType = ParseValueType(reader); break; default: throw new InvalidOperationException(@"Invalid signature type."); } int genArgCount = reader.ReadCompressedInt32(); SigType[] genArgs = new SigType[genArgCount]; for (int i = 0; i < genArgCount; i++) { genArgs[i] = ParseTypeSignature(reader); } return new GenericInstSigType(originalType, genArgs); }
public SecurityDeclarationReader(MetadataRoot root, ReflectionReader reader) { sr = new SignatureReader(root, reader); }
/// <summary> /// Loads the signature. /// </summary> /// <param name="reader">The reader.</param> public FieldSignature(SignatureReader reader) : base(reader) { }
public override void Read(SignatureReader rdr) { Element = rdr.ReadElementType(); num = rdr.ReadCompressedInt(); }
/// <summary> /// Parses the function pointer. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseFunctionPointer(SignatureReader reader) { HeapIndexToken token = reader.ReadEncodedToken(); return(new FnptrSigType(token)); }
/// <summary> /// Parses the array signature. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseArraySignature(SignatureReader reader) { SigType elementType = ParseTypeSignature(reader); int rank, count; int[] sizes, lowerBounds; rank = reader.ReadCompressedInt32(); count = reader.ReadCompressedInt32(); sizes = new int[count]; for (int i = 0; i < count; i++) sizes[i] = reader.ReadCompressedInt32(); count = reader.ReadCompressedInt32(); lowerBounds = new int[count]; for (int i = 0; i < count; i++) lowerBounds[i] = reader.ReadCompressedInt32(); return new ArraySigType(elementType, rank, sizes, lowerBounds); }
public TypeSig ReadTypeSignature(byte[] data) { return(SignatureReader.ReadTypeSig(SignatureReaderHelper.Instance, corLibTypes, data)); }
private void ParseModifier(SignatureReader reader) { CilElementType value = (CilElementType)reader.PeekByte(); if (value == CilElementType.Pinned) { this.modifier = value; reader.SkipByte(); } }
/// <summary> /// PropertySignature signature is indexed by the Property.Type column /// </summary> /// <param name="reader">The reader.</param> protected override void ParseSignature(SignatureReader reader) { throw new Exception("The method or operation is not implemented."); }
public static Signature FromMemberRefSignatureToken(IMetadataProvider provider, HeapIndexToken token, SigType[] genericArguments) { SignatureReader reader = new SignatureReader(provider.ReadBlob(token)); if (reader[0] == 0x06) { return new FieldSignature(reader, genericArguments); } else { return new MethodSignature(reader, genericArguments); } }
/// <summary> /// Initializes a new instance of the <see cref="MethodReferenceSignature"/> class. /// </summary> /// <param name="reader">The reader.</param> public MethodReferenceSignature(SignatureReader reader) : base(reader) { }
/// <summary> /// Parses the signature. /// </summary> /// <param name="reader">The reader.</param> protected override void ParseSignature(SignatureReader reader) { type = SigType.ParseTypeSignature(reader); }
/// <summary> /// Parses the signature. /// </summary> /// <param name="reader">The reader.</param> protected abstract void ParseSignature(SignatureReader reader);
public CallingConventionSig ReadSignature(IMetaDataImport mdi, byte[] data) { return(SignatureReader.ReadSig(new SignatureReaderHelper(mdi), corLibTypes, data)); }
public override void Read(SignatureReader rdr) { Element = rdr.ReadElementType(); mtd = new MethodSig(); mtd.Read(rdr); }
/// <summary> /// Parses the function pointer. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseFunctionPointer(SignatureReader reader) { HeapIndexToken token = reader.ReadEncodedToken(); return new FnptrSigType(token); }
/// <summary> /// Loads the signature. /// </summary> /// <param name="reader">The reader.</param> /// <param name="genericArguments">The generic arguments.</param> public FieldSignature(SignatureReader reader, SigType[] genericArguments) : base(reader) { ApplyGenericArguments(genericArguments); }
/// <summary> /// Initializes a new instance of the <see cref="StandAloneMethodSignature"/> class. /// </summary> /// <param name="reader">The reader.</param> public StandAloneMethodSignature(SignatureReader reader) : base(reader) { }
/// <summary> /// Loads the signature. /// </summary> /// <param name="reader">The reader.</param> public Signature(SignatureReader reader) { ParseSignature(reader); }
/// <summary> /// Asynchronously generates bindings for the API described by the given <see cref="IGeneratorSettings"/> /// object. /// /// Broadly, this takes the following steps: /// 1) Load the base API. /// 2) Bake overrides into the API /// 3) Bake Documentation into the API /// 4) Create mappings between OpenGL types and C# types /// 5) Apply the mappings to the API /// 6) Bake convenience overloads into the API (adding unsafe, etc) /// 7) Write the bindings to the files. /// /// </summary> /// <param name="generatorSettings">The settings describing the API.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> private static async Task GenerateBindingsAsync([NotNull] IGeneratorSettings generatorSettings) { var signaturePath = Path.Combine(Arguments.InputPath, generatorSettings.SpecificationFile); if (!_cachedProfiles.TryGetValue(signaturePath, out var profiles)) { profiles = SignatureReader.GetAvailableProfiles(signaturePath).ToList(); _cachedProfiles.TryAdd(signaturePath, profiles); } var profileOverrides = OverrideReader .GetProfileOverrides(generatorSettings.OverrideFiles.ToArray()) .ToList(); var baker = new ProfileBaker(profiles, profileOverrides); var bakedProfile = baker.BakeProfile ( generatorSettings.ProfileName, generatorSettings.Versions, generatorSettings.BaseProfileName ); var documentationPath = Path.Combine ( Arguments.DocumentationPath, generatorSettings.SpecificationDocumentationPath ); var docs = DocumentationReader.ReadProfileDocumentation(documentationPath); var bakedDocs = new DocumentationBaker(bakedProfile).BakeDocumentation(docs); var languageTypemapPath = Path.Combine(Arguments.InputPath, generatorSettings.LanguageTypemap); if (!_cachedTypemaps.TryGetValue(languageTypemapPath, out var languageTypemap)) { using (var fs = File.OpenRead(languageTypemapPath)) { languageTypemap = new TypemapReader().ReadTypemap(fs); _cachedTypemaps.TryAdd(languageTypemapPath, languageTypemap); } } var apiTypemapPath = Path.Combine(Arguments.InputPath, generatorSettings.APITypemap); if (!_cachedTypemaps.TryGetValue(apiTypemapPath, out var apiTypemap)) { using (var fs = File.OpenRead(apiTypemapPath)) { apiTypemap = new TypemapReader().ReadTypemap(fs); _cachedTypemaps.TryAdd(apiTypemapPath, apiTypemap); } } var bakedMap = TypemapBaker.BakeTypemaps(apiTypemap, languageTypemap); var mapper = new ProfileMapper(bakedMap); var mappedProfile = mapper.Map(bakedProfile); var overloadedProfile = OverloadBaker.BakeOverloads(mappedProfile); var bindingsWriter = new BindingWriter(generatorSettings, overloadedProfile, bakedDocs); await bindingsWriter.WriteBindingsAsync(); }
/// <summary> /// Froms the member ref signature token. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> /// <returns></returns> public static Signature FromMemberRefSignatureToken(IMetadataProvider provider, TokenTypes token) { SignatureReader reader = new SignatureReader(provider.ReadBlob(token)); if (reader[0] == 0x06) { return new FieldSignature(reader); } else { return new MethodSignature(reader); } }
void ReadRvaData(MetadataTable tbl, MetadataReader mdRdr, List <Rva> rvas, MetadataRowCollection rows) { List <Rva> sorted = new List <Rva>(rvas); sorted.Sort(); for (int i = 0; i < rvas.Count; i++) { Rva rva = rvas[i]; MetadataRow r = rows[i + 1]; byte[] dat = null; VirtualReader rdr = new VirtualReader(mdRdr.BaseStream.File.SectionHeaders.GetVirtualStream()); if (tbl.Type == TableType.FieldRVA) { MetadataRoot root = tbl.Heap.Stream.Root; rdr.SetPosition(rva); MetadataRow fd = (r["Field"] as TableToken).ResolveRow(); FieldSig sig = new FieldSig(); SignatureReader sigRdr = new SignatureReader(new MetadataReader(root[MetadataStreamType.Blob])); sigRdr.BaseStream.Position = (fd["Signature"] as BlobToken).Token.Index; sig.Read(sigRdr); int c = 0; switch (sig.Type.Element) { case ElementType.Boolean: case ElementType.UInt8: case ElementType.Int8: c = 1; break; case ElementType.UInt16: case ElementType.Int16: case ElementType.Char: c = 2; break; case ElementType.UInt32: case ElementType.Int32: case ElementType.Single: c = 4; break; case ElementType.UInt64: case ElementType.Int64: case ElementType.Double: c = 8; break; case ElementType.ValueType: TableToken vt = (sig.Type as VALUETYPE).Type; foreach (MetadataRow cl in tbl.Heap[TableType.ClassLayout]) { if (cl["Parent"] == vt) { c = (int)cl["ClassSize"]; break; } } break; default: throw new InvalidOperationException("ReadRvaData"); } dat = rdr.ReadBytes(c); } else if (tbl.Type == TableType.MethodDef && rva != 0) { //MethodBody bdy; //if (((MethodImplAttributes)r["ImplFlags"] & MethodImplAttributes.Native) == MethodImplAttributes.Native) //{ // bdy = new NativeMethodBody(r); //} //else //{ // bdy = new ManagedMethodBody(r); //} //rdr.SetPosition(rva); //bdy.Load(rdr); //rdr.SetPosition(rva); //dat = rdr.ReadBytes((int)bdy.Size); int idx; Rva next; if ((idx = sorted.IndexOf(rva)) == sorted.Count - 1) { CLRDirectory root = tbl.Heap.Stream.Root.Directory; Rva now; next = uint.MaxValue; rdr.SetPosition(root.Location.Address); rdr.BaseStream.Seek(0x8, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0xC, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current); if ((now = rdr.ReadRva()) < next && now != 0 && now > rva) { next = now; } } else { next = sorted[idx + 1]; } rdr.SetPosition(rva); dat = rdr.ReadBytes((int)(next - rva)); } if (!tbl.Heap.Stream.Root.Directory.Datas.ContainsAddress(rva) && dat != null) { tbl.Heap.Stream.Root.Directory.Datas.Add(new CLRData() { Address = rva, Data = dat }); } } }
/// <summary> /// Parses the var. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseVar(SignatureReader reader) { int typeVariableIndex = reader.ReadCompressedInt32(); return(new VarSigType(typeVariableIndex)); }
/// <summary> /// Parses the MVar. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static SigType ParseMVar(SignatureReader reader) { int methodVariableIndex = reader.ReadCompressedInt32(); return(new MVarSigType(methodVariableIndex)); }
/// <summary> /// Parses the class signature. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> private static TypeSigType ParseClassSignature(SignatureReader reader) { Token token = reader.ReadEncodedTypeDefOrRef(); return(new ClassSigType(token)); }
/// <summary> /// Initializes a new instance of the <see cref="VariableSignature"/> class. /// </summary> /// <param name="reader">The reader.</param> public VariableSignature(SignatureReader reader) : base(reader) { }
protected override void ParseSignature(SignatureReader reader) { ParseModifier(reader); CustomMods = CustomMod.ParseCustomMods(reader); Type = SigType.ParseTypeSignature(reader); }
/// <summary> /// Parses the signature. /// </summary> /// <param name="reader">The reader.</param> protected override void ParseSignature(SignatureReader reader) { // Check signature identifier if (reader.ReadByte() != 0x07) throw new ArgumentException(@"Token doesn't represent a local variable signature.", @"token"); // Retrieve the number of locals int count = reader.ReadCompressedInt32(); if (count != 0) { this.locals = new VariableSignature[count]; for (int i = 0; i < count; i++) { locals[i] = new VariableSignature(reader); } } }
/// <summary> /// Parses the signature. /// </summary> /// <param name="reader">The reader.</param> protected override sealed void ParseSignature(SignatureReader reader) { byte value = reader.ReadByte(); // Check for instance signature if (HAS_THIS == (value & HAS_THIS)) { hasThis = true; } if (HAS_EXPLICIT_THIS == (value & HAS_EXPLICIT_THIS)) { hasExplicitThis = true; } if (GENERIC == (value & GENERIC)) { callingConvention = CallingConvention.Generic; genericParameterCount = reader.ReadCompressedInt32(); } else if (VARARG == (value & VARARG)) { callingConvention = CallingConvention.Vararg; } else if ((value & 0x1F) != 0x00) { throw new InvalidOperationException(@"Invalid method definition signature."); } // Number of parameters int paramCount = reader.ReadCompressedInt32(); parameters = new SigType[paramCount]; // Read the return type returnType = SigType.ParseTypeSignature(reader); // Read all parameters for (int i = 0; i < paramCount; i++) parameters[i] = SigType.ParseTypeSignature(reader); }
/// <summary> /// Initializes a new instance of the <see cref="StandaloneMethodSignature"/> class. /// </summary> /// <param name="reader">The reader.</param> public StandaloneMethodSignature(SignatureReader reader) : base(reader) { }