/// <summary> /// Initializes a new instance of the <see cref="CilGenericType"/> class. /// </summary> /// <param name="typeModule">The type module.</param> /// <param name="token">The token.</param> /// <param name="baseGenericType">Type of the base generic.</param> /// <param name="genericTypeInstanceSignature">The generic type instance signature.</param> public CilGenericType(ITypeModule typeModule, Token token, RuntimeType baseGenericType, GenericInstSigType genericTypeInstanceSignature) : base(baseGenericType.Module, token, baseGenericType.BaseType) { Debug.Assert(baseGenericType is CilRuntimeType); this.signature = genericTypeInstanceSignature; this.baseGenericType = baseGenericType as CilRuntimeType; this.InstantiationModule = typeModule; base.Attributes = baseGenericType.Attributes; base.Namespace = baseGenericType.Namespace; if (this.baseGenericType.IsNested) { // TODO: find generic type ; } // TODO: if this is a nested types, add enclosing type(s) into genericArguments first this.genericArguments = signature.GenericArguments; base.Name = GetName(typeModule); ResolveMethods(); ResolveFields(); this.containsOpenGenericArguments = CheckContainsOpenGenericParameters(); }
/// <summary> /// Initializes a new instance of the <see cref="RuntimeAttribute"/> class. /// </summary> /// <param name="typeModule">The type module.</param> /// <param name="ctor">The ctor.</param> /// <param name="ctorMethod">The ctor method.</param> /// <param name="blobIndex">Index of the blob.</param> public RuntimeAttribute(ITypeModule typeModule, Token ctor, RuntimeMethod ctorMethod, HeapIndexToken blobIndex) { this.typeModule = typeModule; this.ctorMethod = ctorMethod; this.ctor = ctor; this.blobIndex = blobIndex; }
/// <summary> /// Initializes a new instance of the <see cref="CilRuntimeField"/> class. /// </summary> /// <param name="module">The module.</param> /// <param name="name">The name.</param> /// <param name="signature">The signature.</param> /// <param name="token">The token.</param> /// <param name="offset">The offset.</param> /// <param name="rva">The rva.</param> /// <param name="declaringType">Type of the declaring.</param> /// <param name="attributes">The attributes.</param> public CilRuntimeField(ITypeModule module, string name, FieldSignature signature, Token token, uint offset, uint rva, RuntimeType declaringType, FieldAttributes attributes) : base(module, token, declaringType) { this.Name = name; this.Signature = signature; base.Attributes = attributes; base.RVA = rva; }
public VerificationEntry(string assembly, VerificationType type, string section, string error, string description, Token token) { this.Assembly = assembly; this.Type = type; this.Section = section; this.Rule = error; this.Description = description; this.Location = token; }
/// <summary> /// Initializes a new instance of the <see cref="CilRuntimeMethod"/> class. /// </summary> /// <param name="module">The module.</param> /// <param name="name">The name.</param> /// <param name="signature">The signature.</param> /// <param name="token">The token.</param> /// <param name="declaringType">Type of the declaring.</param> /// <param name="methodAttributes">The method attributes.</param> /// <param name="methodImplAttributes">The method impl attributes.</param> /// <param name="rva">The rva.</param> public CilRuntimeMethod(ITypeModule module, string name, MethodSignature signature, Token token, RuntimeType declaringType, MethodAttributes methodAttributes, MethodImplAttributes methodImplAttributes, uint rva) : base(module, token, declaringType) { base.Attributes = methodAttributes; base.ImplAttributes = methodImplAttributes; base.Rva = rva; this.Name = name; this.Signature = signature; this.Parameters = new List<RuntimeParameter>(); }
protected override void Run() { int rows = metadata.GetRowCount(TableType.Assembly); if (rows == 0) return; // 1. The Assembly table shall contain zero or one row if (rows > 1) { AddSpecificationError("22.2-1", "The Assembly table shall contain zero or one row", "Multiple rows found"); } Token token = new Token(TableType.Assembly, 1); AssemblyRow row = metadata.ReadAssemblyRow(token); // 2. HashAlgId shall be one of the specified values // Note: Microsoft treats this as a WARNING rather than an error if (!IsValidHashAlgID((int)row.HashAlgId)) { AddSpecificationError("22.2-2", "HashAlgId shall be one of the specified values", "Invalid Hash Algorithm ID", token); } // 4. Flags shall have only those values set that are specified if (!IsAssemblyFlags((int)row.Flags)) { AddSpecificationError("22.2-4", "Flags shall have only those values set that are specified", "Invalid Hash Algorithm ID", token); } // 6. Name shall index a non-empty string in the String heap switch (CheckName(row.Name)) { case 0: break; case 1: AddSpecificationError("22.2-6", "Name shall index a non-empty string, in the String heap", "Empty name", token); break; case 2: AddSpecificationError("22.2-6", "Name shall index a non-empty string, in the String heap", "Invalid index", token); break; case 3: AddSpecificationError("22.2-6", "Name shall index a non-empty string, in the String heap", "Empty name", token); break; } // 9. If Culture is non-null, it shall index a single string from the list specified switch (CheckCulture(row.Culture)) { case 0: break; case 1: AddSpecificationError("22.2-9", "If Culture is non-null, it shall index a single string from the list specified", "Invalid or Missing Culture", token); break; } }
/// <summary> /// Initializes a new instance of the <see cref="CilRuntimeType"/> class. /// </summary> /// <param name="module">The module.</param> /// <param name="name">The name.</param> /// <param name="typeNamespace">The type namespace.</param> /// <param name="packing">The packing.</param> /// <param name="size">The size.</param> /// <param name="token">The token.</param> /// <param name="baseType">Type of the base.</param> /// <param name="enclosingType">Type of the enclosing.</param> /// <param name="attributes">The attributes.</param> /// <param name="baseToken">The base token.</param> public CilRuntimeType(ITypeModule module, string name, string typeNamespace, int packing, int size, Token token, RuntimeType baseType, RuntimeType enclosingType, TypeAttributes attributes, Token baseToken) : base(module, token, baseType) { this.baseTypeToken = baseToken; this.enclosingType = enclosingType; base.Attributes = attributes; base.Pack = packing; base.LayoutSize = size; base.Name = name; base.Namespace = typeNamespace; if (IsNested) { Debug.Assert(enclosingType != null); this.Namespace = enclosingType.Namespace + "." + enclosingType.Name; } }
protected void UpdateTree() { treeView.BeginUpdate(); treeView.Nodes.Clear(); //Cycle through all metadata tables foreach (TableType table in Enum.GetValues(typeof(TableType))) { if (table == TableType.Module) continue; int count = metadataModule.Metadata.GetRowCount(table); if (count == 0) continue; TreeNode tableNode = new TreeNode("[" + table.FormatToString() + "] " + table.ToString() + " (" + count.ToString() + ")"); treeView.Nodes.Add(tableNode); //Cycle through all metadata rows for (int rowid = 1; rowid <= count; rowid++) { Token token = new Token(table, rowid); TableRow row = Resolver.GetTableRow(metadataModule, token); if (row == null) continue; TreeNode rowNode = new TreeNode(token.FormatToString() + " - " + row.Name); tableNode.Nodes.Add(rowNode); foreach (KeyValuePair<string, string> data in row.GetValues()) { TreeNode rowValueNode = new TreeNode(data.Key + ": " + data.Value); rowNode.Nodes.Add(rowValueNode); } } } treeView.EndUpdate(); }
/// <summary> /// Runs the specified compiler. /// </summary> void IMethodCompilerStage.Run() { // Handler Code foreach (ExceptionHandlingClause clause in methodCompiler.ExceptionClauseHeader.Clauses) { if (clause.ExceptionHandler == ExceptionHandlerType.Exception) { var typeToken = new Token(clause.ClassToken); RuntimeType type = methodCompiler.Method.Module.GetType(typeToken); var block = FindBlock(clause.HandlerOffset); var context = new Context(instructionSet, block).InsertBefore(); SigType sigType = new ClassSigType(typeToken); Operand exceptionObject = methodCompiler.CreateTemporary(sigType); context.SetInstruction(IR.Instruction.ExceptionPrologueInstruction, exceptionObject); } } }
public static TableRow GetTableRow(IMetadataProvider metadata, Token token) { switch (token.Table) { case TableType.File: return new FileRowExt(metadata, metadata.ReadFileRow(token)); case TableType.TypeDef: return new TypeDefRowExt(metadata, metadata.ReadTypeDefRow(token)); case TableType.TypeSpec: return new TypeSpecRowExt(metadata, metadata.ReadTypeSpecRow(token)); case TableType.TypeRef: return new TypeRefRowExt(metadata, metadata.ReadTypeRefRow(token)); case TableType.Field: return new FieldRowExt(metadata, metadata.ReadFieldRow(token)); case TableType.MethodDef: return new MethodDefRowExt(metadata, metadata.ReadMethodDefRow(token)); case TableType.ImplMap: return new ImplMapRowExt(metadata, metadata.ReadImplMapRow(token)); case TableType.MemberRef: return new MemberRefRowExt(metadata, metadata.ReadMemberRefRow(token)); case TableType.InterfaceImpl: return new InterfaceImplRowExt(metadata, metadata.ReadInterfaceImplRow(token)); case TableType.CustomAttribute: return new CustomAttributeRowExt(metadata, metadata.ReadCustomAttributeRow(token)); case TableType.Assembly: return new AssemblyRowExt(metadata, metadata.ReadAssemblyRow(token)); case TableType.AssemblyRef: return new AssemblyRefRowExt(metadata, metadata.ReadAssemblyRefRow(token)); case TableType.GenericParam: return new GenericParamRowExt(metadata, metadata.ReadGenericParamRow(token)); case TableType.Param: return new ParamRowExt(metadata, metadata.ReadParamRow(token)); default: return null; } }
public static TableRow GetTableRow(IMetadataModule metadataModule, Token token) { switch (token.Table) { case TableType.File: return new FileRowExt(metadataModule, metadataModule.Metadata.ReadFileRow(token)); case TableType.TypeDef: return new TypeDefRowExt(metadataModule, metadataModule.Metadata.ReadTypeDefRow(token)); case TableType.TypeSpec: return new TypeSpecRowExt(metadataModule, metadataModule.Metadata.ReadTypeSpecRow(token)); case TableType.TypeRef: return new TypeRefRowExt(metadataModule, metadataModule.Metadata.ReadTypeRefRow(token)); case TableType.Field: return new FieldRowExt(metadataModule, metadataModule.Metadata.ReadFieldRow(token)); case TableType.MethodDef: return new MethodDefRowExt(metadataModule, metadataModule.Metadata.ReadMethodDefRow(token)); case TableType.ImplMap: return new ImplMapRowExt(metadataModule, metadataModule.Metadata.ReadImplMapRow(token)); case TableType.MemberRef: return new MemberRefRowExt(metadataModule, metadataModule.Metadata.ReadMemberRefRow(token)); case TableType.InterfaceImpl: return new InterfaceImplRowExt(metadataModule, metadataModule.Metadata.ReadInterfaceImplRow(token)); case TableType.CustomAttribute: return new CustomAttributeRowExt(metadataModule, metadataModule.Metadata.ReadCustomAttributeRow(token)); case TableType.Assembly: return new AssemblyRowExt(metadataModule, metadataModule.Metadata.ReadAssemblyRow(token)); case TableType.AssemblyRef: return new AssemblyRefRowExt(metadataModule, metadataModule.Metadata.ReadAssemblyRefRow(token)); case TableType.GenericParam: return new GenericParamRowExt(metadataModule, metadataModule.Metadata.ReadGenericParamRow(token)); case TableType.Param: return new ParamRowExt(metadataModule, metadataModule.Metadata.ReadParamRow(token)); case TableType.StandAloneSig: return new StandAloneSigExt(metadataModule, metadataModule.Metadata.ReadStandAloneSigRow(token)); case TableType.MethodSpec: return new MethodSpecExt(metadataModule, metadataModule.Metadata.ReadMethodSpecRow(token)); case TableType.NestedClass: return new NestedClassExt(metadataModule, metadataModule.Metadata.ReadNestedClassRow(token)); default: return null; } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public PropertyRow ReadPropertyRow(Token token) { if (token.Table != TableType.Property) throw new ArgumentException("Invalid token type for PropertyRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new PropertyRow( (PropertyAttributes)reader.ReadUInt16(), ReadHeapToken(reader, IndexType.StringHeap), ReadHeapToken(reader, IndexType.BlobHeap) ); } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public PropertyMapRow ReadPropertyMapRow(Token token) { if (token.Table != TableType.PropertyMap) throw new ArgumentException("Invalid token type for PropertyMapRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new PropertyMapRow( ReadIndexValue(reader, TableType.TypeDef), ReadIndexValue(reader, TableType.Property) ); } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public ParamRow ReadParamRow(Token token) { if (token.Table != TableType.Param) throw new ArgumentException("Invalid token type for ParamRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new ParamRow( (ParameterAttributes)reader.ReadUInt16(), reader.ReadInt16(), ReadHeapToken(reader, IndexType.StringHeap) ); } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public NestedClassRow ReadNestedClassRow(Token token) { if (token.Table != TableType.NestedClass) throw new ArgumentException("Invalid token type for NestedClassRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new NestedClassRow( ReadIndexValue(reader, TableType.TypeDef), ReadIndexValue(reader, TableType.TypeDef) ); } }
/// <summary> /// Retrieves the runtime type for a given metadata token. /// </summary> /// <param name="token">The token of the type to load. This can represent a typeref, typedef or typespec token.</param> /// <returns>The runtime type of the specified token.</returns> RuntimeType ITypeModule.GetType(Token token) { return null; }
/// <summary> /// Retrieves the method definition identified by the given token in the scope. /// </summary> /// <param name="token">The token of the method to retrieve.</param> /// <returns></returns> RuntimeMethod ITypeModule.GetMethod(Token token) { foreach (var method in methods) if (method.Token == token) return method; return null; }
/// <summary> /// Gets the name of the external. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> string ITypeModule.GetExternalName(Token token) { return null; }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public TypeRefRow ReadTypeRefRow(Token token) { if (token.Table != TableType.TypeRef) throw new ArgumentException("Invalid token type for TypeRefRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new TypeRefRow( ReadMetadataToken(reader, IndexType.ResolutionScope), ReadHeapToken(reader, IndexType.StringHeap), ReadHeapToken(reader, IndexType.StringHeap) ); } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public StandAloneSigRow ReadStandAloneSigRow(Token token) { if (token.Table != TableType.StandAloneSig) throw new ArgumentException("Invalid token type for StandAloneSigRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new StandAloneSigRow( ReadHeapToken(reader, IndexType.BlobHeap) ); } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public TypeDefRow ReadTypeDefRow(Token token) { if (token.Table != TableType.TypeDef) throw new ArgumentException("Invalid token type for TypeDefRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new TypeDefRow( (TypeAttributes)reader.ReadUInt32(), ReadHeapToken(reader, IndexType.StringHeap), ReadHeapToken(reader, IndexType.StringHeap), ReadMetadataToken(reader, IndexType.TypeDefOrRef), ReadIndexValue(reader, TableType.Field), ReadIndexValue(reader, TableType.MethodDef) ); } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public MethodDefRow ReadMethodDefRow(Token token) { if (token.Table != TableType.MethodDef) throw new ArgumentException("Invalid token type for MethodDefRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new MethodDefRow( reader.ReadUInt32(), (MethodImplAttributes)reader.ReadUInt16(), (MethodAttributes)reader.ReadUInt16(), ReadHeapToken(reader, IndexType.StringHeap), ReadHeapToken(reader, IndexType.BlobHeap), ReadIndexValue(reader, TableType.Param) ); } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public TypeSpecRow ReadTypeSpecRow(Token token) { if (token.Table != TableType.TypeSpec) throw new ArgumentException("Invalid token type for TypeSpecRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new TypeSpecRow( ReadHeapToken(reader, IndexType.BlobHeap) ); } }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public MethodImplRow ReadMethodImplRow(Token token) { if (token.Table != TableType.MethodImpl) throw new ArgumentException("Invalid token type for MethodImplRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new MethodImplRow( ReadIndexValue(reader, TableType.TypeDef), ReadMetadataToken(reader, IndexType.MethodDefOrRef), ReadMetadataToken(reader, IndexType.MethodDefOrRef) ); } }
/// <summary> /// Retrieves the field definition identified by the given token in the scope. /// </summary> /// <param name="token">The token of the field to retrieve.</param> /// <returns></returns> RuntimeField ITypeModule.GetField(Token token) { return null; }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public MethodSemanticsRow ReadMethodSemanticsRow(Token token) { using (var reader = CreateReaderForToken(token)) { if (token.Table != TableType.MethodSemantics) throw new ArgumentException("Invalid token type for MethodSemanticsRow.", @"token"); return new MethodSemanticsRow( (MethodSemanticsAttributes)reader.ReadInt16(), ReadIndexValue(reader, TableType.MethodDef), ReadMetadataToken(reader, IndexType.HasSemantics) ); } }
/// <summary> /// Gets the method. /// </summary> /// <param name="token">The token.</param> /// <param name="callingType">Type of the calling.</param> /// <returns></returns> RuntimeMethod ITypeModule.GetMethod(Token token, RuntimeType callingType) { return null; }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public MethodSpecRow ReadMethodSpecRow(Token token) { if (token.Table != TableType.MethodSpec) throw new ArgumentException("Invalid token type for MethodSpecRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new MethodSpecRow( ReadMetadataToken(reader, IndexType.MethodDefOrRef), ReadHeapToken(reader, IndexType.BlobHeap) ); } }
/// <summary> /// Initializes a new instance of the <see cref="RuntimeMethod"/> class. /// </summary> /// <param name="token">The token.</param> /// <param name="declaringType">The type, which declared this method.</param> public RuntimeMethod(ITypeModule module, Token token, RuntimeType declaringType) : base(module, token, declaringType) { this.genericParameters = new List<GenericParameter>(); }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <returns></returns> public ModuleRow ReadModuleRow(Token token) { if (token.Table != TableType.Module) throw new ArgumentException("Invalid token type for ModuleRow.", @"token"); using (var reader = CreateReaderForToken(token)) { return new ModuleRow( reader.ReadUInt16(), ReadHeapToken(reader, IndexType.StringHeap), ReadHeapToken(reader, IndexType.GuidHeap), ReadHeapToken(reader, IndexType.GuidHeap), ReadHeapToken(reader, IndexType.GuidHeap) ); } }