internal static FileReference Load(Module module, int rid) { var image = module.Image; var file = image.FileSignatures[rid - 1]; if (file != null) { return(file); } FileRow row; image.GetFile(rid, out row); file = new FileReference(); file._name = image.GetString(row.Name); file._hashValue = image.GetBlob(row.HashValue); file._containsMetadata = (row.Flags == FileFlags.ContainsMetaData); module.AddSignature(ref file); image.FileSignatures[rid - 1] = file; return(file); }
internal static AssemblyReference LoadDef(Module module) { var image = module.Image; var assemblyRef = image.AssemblyDefSignature; if (assemblyRef == null) { return(assemblyRef); } AssemblyRow row; image.GetAssembly(1, out row); assemblyRef = new AssemblyReference(); assemblyRef._name = image.GetString(row.Name); assemblyRef._culture = image.GetString(row.Locale); assemblyRef._processorArchitecture = (ProcessorArchitecture)((int)(row.Flags & AssemblyFlags.PA_Mask) >> (int)AssemblyFlags.PA_Shift); assemblyRef._version = new Version(row.MajorVersion, row.MinorVersion, row.BuildNumber, row.RevisionNumber); var publicKey = image.GetBlob(row.PublicKey); if (publicKey != null && publicKey.Length > 0) { assemblyRef._publicKeyToken = StrongNameUtils.CreateTokenFromPublicKey(publicKey); } module.AddSignature(ref assemblyRef); image.AssemblyDefSignature = assemblyRef; return(assemblyRef); }
internal static TypeReference LoadTypeRef(Module module, int rid, bool?isValueType = null) { var image = module.Image; var typeRef = image.TypeRefSignatures[rid - 1]; if (typeRef != null) { if (isValueType.HasValue) { typeRef._isValueType = isValueType; } return(typeRef); } TypeRefRow row; image.GetTypeRef(rid, out row); int resolutionScopeToken = MetadataToken.DecompressResolutionScope(row.ResolutionScope); typeRef = new TypeReference(); typeRef._name = image.GetString(row.Name); typeRef._namespace = image.GetString(row.Namespace); typeRef._owner = LoadResolutionScope(module, resolutionScopeToken); typeRef._isValueType = isValueType; module.AddSignature(ref typeRef); image.TypeRefSignatures[rid - 1] = typeRef; return(typeRef); }
internal static TypeReference LoadExportedType(Module module, int rid) { var image = module.Image; var typeRef = image.ExportedTypeSignatures[rid - 1]; if (typeRef != null) { return(typeRef); } ExportedTypeRow row; image.GetExportedType(rid, out row); typeRef = new TypeReference(); typeRef._name = image.GetString(row.TypeName); typeRef._namespace = image.GetString(row.TypeNamespace); typeRef._owner = LoadExportedTypeImplementation(module, MetadataToken.DecompressImplementation(row.Implementation)); typeRef._isValueType = false; module.AddSignature(ref typeRef); image.ExportedTypeSignatures[rid - 1] = typeRef; return(typeRef); }
internal static MethodReference LoadMethodDef(Module module, int rid) { var image = module.Image; var methodRef = image.MethodSignatures[rid - 1] as MethodReference; if (methodRef != null) { return(methodRef); } MethodRow row; image.GetMethod(rid, out row); methodRef = new MethodReference(); methodRef._name = image.GetString(row.Name); int typeRID = image.GetTypeByMethod(rid); methodRef._owner = TypeReference.LoadTypeDef(module, typeRID); using (var accessor = image.OpenBlob(row.Signature)) { methodRef._callSite = CallSite.LoadCallSite(accessor, module); } module.AddSignature(ref methodRef); image.MethodSignatures[rid - 1] = methodRef; return(methodRef); }
internal static TypeSignature LoadTypeSpec(Module module, int rid) { var image = module.Image; var typeSig = image.TypeSpecSignatures[rid - 1]; if (typeSig != null) { return(typeSig); } int blobID = image.GetTypeSpec(rid); using (var accessor = image.OpenBlob(blobID)) { // Note that a TypeSpecBlob does not begin with a callingconvention byte, // so it differs from the various other signatures that are stored into Metadata. typeSig = Load(accessor, module); } module.AddSignature(ref typeSig); image.TypeSpecSignatures[rid - 1] = typeSig; return(typeSig); }
internal static TypeReference LoadTypeDef(Module module, int rid, bool?isValueType = null) { var image = module.Image; var typeRef = image.TypeSignatures[rid - 1]; if (typeRef != null) { if (isValueType.HasValue) { typeRef._isValueType = isValueType; } return(typeRef); } TypeDefRow row; image.GetTypeDef(rid, out row); typeRef = new TypeReference(); typeRef._name = image.GetString(row.Name); typeRef._namespace = image.GetString(row.Namespace); // Owner int enclosingRID; if (image.GetEnclosingTypeByNested(rid, out enclosingRID)) { typeRef._owner = LoadTypeDef(module, enclosingRID); } else { typeRef._owner = ModuleReference.LoadDef(module); } module.AddSignature(ref typeRef); image.TypeSignatures[rid - 1] = typeRef; // Is value type. if (isValueType.HasValue) { typeRef._isValueType = isValueType.Value; } else { int extendsToken = MetadataToken.DecompressTypeDefOrRef(row.Extends); if (!MetadataToken.IsNull(extendsToken)) { var baseType = TypeSignature.Load(module, extendsToken); typeRef._isValueType = GetIsValueType(typeRef, baseType, module); } } return(typeRef); }
protected internal override void InternMembers(Module module) { module.AddSignature(ref _returnType); int count = _arguments.Count; if (count > 0) { var arguments = new TypeSignature[count]; for (int i = 0; i < count; i++) { var argument = _arguments[i]; module.AddSignature(ref argument); arguments[i] = argument; } _arguments = ReadOnlyList <TypeSignature> .Create(arguments); } }
protected internal override void InternMembers(Module module) { module.AddSignature(ref _declaringMethod); int count = _genericArguments.Count; if (count > 0) { var genericArguments = new TypeSignature[count]; for (int i = 0; i < count; i++) { var argument = _genericArguments[i]; module.AddSignature(ref argument); genericArguments[i] = argument; } _genericArguments = ReadOnlyList <TypeSignature> .Create(genericArguments); } }
private void BuildLocalVariables(Blob blob, ref int pos, Module module) { var list = LocalVariables; blob.Write7BitEncodedInt(ref pos, (int)list.Count); for (int i = 0; i < list.Count; i++) { var localVar = list[i]; int rid = module.AddSignature(ref localVar); blob.Write(ref pos, (int)rid); } }
internal static AssemblyReference LoadRef(Module module, int rid) { var image = module.Image; var assemblyRef = image.AssemblyRefSignatures[rid - 1]; if (assemblyRef != null) { return(assemblyRef); } AssemblyRefRow row; image.GetAssemblyRef(rid, out row); assemblyRef = new AssemblyReference(); assemblyRef._name = image.GetString(row.Name); assemblyRef._culture = image.GetString(row.Locale); assemblyRef._processorArchitecture = (ProcessorArchitecture)((int)(row.Flags & AssemblyFlags.PA_Mask) >> (int)AssemblyFlags.PA_Shift); assemblyRef._version = new Version(row.MajorVersion, row.MinorVersion, row.BuildNumber, row.RevisionNumber); byte[] publicKeyToken = image.GetBlob(row.PublicKeyOrToken).NullIfEmpty(); if ((row.Flags & AssemblyFlags.PublicKey) == AssemblyFlags.PublicKey && publicKeyToken != null && publicKeyToken.Length > 0) { try { publicKeyToken = StrongNameUtils.CreateTokenFromPublicKey(publicKeyToken); } catch (InvalidOperationException) { publicKeyToken = null; } } assemblyRef._publicKeyToken = publicKeyToken; module.AddSignature(ref assemblyRef); image.AssemblyRefSignatures[rid - 1] = assemblyRef; return(assemblyRef); }
private void BuildExceptionHandler(Blob blob, ref int pos, ExceptionHandler handler, Module module) { blob.Write(ref pos, (int)handler.Type); blob.Write(ref pos, (int)handler.TryOffset); blob.Write(ref pos, (int)handler.TryLength); blob.Write(ref pos, (int)handler.HandlerOffset); blob.Write(ref pos, (int)handler.HandlerLength); blob.Write(ref pos, (int)handler.FilterOffset); var catchType = handler.CatchType; if (catchType != null) { int rid = module.AddSignature(ref catchType); blob.Write(ref pos, (int)rid); } else { blob.Write(ref pos, (int)0); } }
internal static FieldReference LoadFieldDef(Module module, int rid) { var image = module.Image; var fieldRef = image.FieldSignatures[rid - 1] as FieldReference; if (fieldRef != null) { return(fieldRef); } FieldRow row; image.GetField(rid, out row); fieldRef = new FieldReference(); fieldRef._name = image.GetString(row.Name); int typeRID = image.GetTypeByField(rid); fieldRef._owner = TypeReference.LoadTypeDef(module, typeRID); using (var accessor = image.OpenBlob(row.Signature)) { byte sigType = accessor.ReadByte(); if (sigType != Metadata.SignatureType.Field) { throw new CodeModelException(string.Format(SR.AssemblyLoadError, module.Location)); } fieldRef._fieldType = TypeSignature.Load(accessor, module); } module.AddSignature(ref fieldRef); image.FieldSignatures[rid - 1] = fieldRef; return(fieldRef); }
internal static ModuleReference LoadDef(Module module) { var image = module.Image; var moduleRef = image.ModuleDefSignature; if (moduleRef == null) { return(moduleRef); } ModuleRow row; image.GetModule(1, out row); moduleRef = new ModuleReference(); moduleRef._name = image.GetString(row.Name); module.AddSignature(ref moduleRef); image.ModuleDefSignature = moduleRef; return(moduleRef); }
internal static CallSite LoadStandAloneSig(Module module, int rid) { var image = module.Image; var callSite = image.StandAloneSigSignatures[rid - 1] as CallSite; if (callSite != null) { return(callSite); } int blobID = image.GetStandAloneSig(rid); using (var accessor = image.OpenBlob(blobID)) { callSite = LoadCallSite(accessor, module); } module.AddSignature(ref callSite); image.StandAloneSigSignatures[rid - 1] = callSite; return(callSite); }
internal static ModuleReference LoadRef(Module module, int rid) { var image = module.Image; var moduleRef = image.ModuleRefSignatures[rid - 1]; if (moduleRef != null) { return(moduleRef); } ModuleRefRow row; image.GetModuleRef(rid, out row); moduleRef = new ModuleReference(); moduleRef._name = image.GetString(row.Name); module.AddSignature(ref moduleRef); image.ModuleRefSignatures[rid - 1] = moduleRef; return(moduleRef); }
internal static GenericMethodReference LoadMethodSpec(Module module, int rid) { var image = module.Image; var genericMethodRef = image.MethodSpecSignatures[rid - 1] as GenericMethodReference; if (genericMethodRef != null) { return(genericMethodRef); } MethodSpecRow row; image.GetMethodSpec(rid, out row); genericMethodRef = new GenericMethodReference(); genericMethodRef._declaringMethod = MethodReference.LoadMethodDefOrRef(module, MetadataToken.DecompressMethodDefOrRef(row.Method)); using (var accessor = image.OpenBlob(row.Instantiation)) { byte sigType = accessor.ReadByte(); // Should be equal to SignatureType.GenericInst if (sigType != Metadata.SignatureType.GenericInst) { throw new CodeModelException(string.Format(SR.AssemblyLoadError, module.Location)); } var genericArguments = TypeSignature.LoadGenericArguments(accessor, module); genericMethodRef._genericArguments = ReadOnlyList <TypeSignature> .Create(genericArguments); } module.AddSignature(ref genericMethodRef); image.MethodSpecSignatures[rid - 1] = genericMethodRef; return(genericMethodRef); }
internal static Signature LoadMemberRef(Module module, int rid) { var image = module.Image; var memberRef = image.MemberRefSignatures[rid - 1] as Signature; if (memberRef != null) { return(memberRef); } MemberRefRow row; image.GetMemberRef(rid, out row); string name = image.GetString(row.Name); // Owner TypeSignature owner; int classToken = MetadataToken.DecompressMemberRefParent(row.Class); switch (MetadataToken.GetType(classToken)) { case MetadataTokenType.ModuleRef: { // A ModuleRef token, if the member is defined, in another module of the same image, // as a global function or variable. var moduleRef = ModuleReference.LoadRef(module, MetadataToken.GetRID(classToken)); var typeRef = new TypeReference(CodeModelUtils.GlobalTypeName, null, moduleRef); module.AddSignature(ref typeRef); owner = typeRef; } break; case MetadataTokenType.Method: { // A MethodDef token, when used to supply a call-site signature for a vararg method that is // defined in this module. The Name shall match the Name in the corresponding MethodDef row. // The Signature shall match the Signature in the target method definition. int typeRID = image.GetTypeByMethod(MetadataToken.GetRID(classToken)); owner = TypeReference.LoadTypeDef(module, typeRID); } break; default: { owner = TypeReference.Load(module, classToken); } break; } // Signature using (var accessor = image.OpenBlob(row.Signature)) { byte sigType = accessor.ReadByte(); if (sigType == Metadata.SignatureType.Field) { var fieldType = TypeSignature.Load(accessor, module); memberRef = new FieldReference(name, fieldType, owner); } else { var callSite = CallSite.LoadCallSite(accessor, module, sigType); memberRef = new MethodReference(name, owner, callSite); } } module.AddSignature(ref memberRef); image.MemberRefSignatures[rid - 1] = memberRef; return(memberRef); }
protected internal override void InternMembers(Module module) { module.AddSignature(ref _elementType); }
protected internal override void InternMembers(Module module) { module.AddSignature(ref _callSite); }
private void BuildInstructions(Blob blob, ref int pos, Module module) { blob.Write7BitEncodedInt(ref pos, (int)Instructions.Count); foreach (var instruction in Instructions) { var opCode = instruction.OpCode; if (opCode.OpByte1 == 0xff) { // one byte opcode blob.Write(ref pos, (byte)opCode.OpByte2); } else { // two bytes opcode blob.Write(ref pos, (byte)opCode.OpByte1); blob.Write(ref pos, (byte)opCode.OpByte2); } object value = instruction.Value; switch (opCode.OperandType) { case OperandType.InlineBrTarget: { blob.Write(ref pos, (int)value); } break; case OperandType.InlineField: { var signature = (Signature)value; int rid = module.AddSignature(ref signature); blob.Write(ref pos, (int)rid); } break; case OperandType.InlineI: { blob.Write(ref pos, (int)value); } break; case OperandType.InlineI8: { blob.Write(ref pos, (long)value); } break; case OperandType.InlineMethod: { var signature = (Signature)value; int rid = module.AddSignature(ref signature); blob.Write(ref pos, (int)rid); } break; case OperandType.InlineR: { blob.Write(ref pos, (double)value); } break; case OperandType.InlineSig: { var signature = (Signature)value; int rid = module.AddSignature(ref signature); blob.Write(ref pos, (int)rid); } break; case OperandType.InlineString: { // Token of a userdefined string, whose RID portion is actually an offset in the #US blob stream. blob.WriteLengthPrefixedString(ref pos, (string)value, Encoding.Unicode); } break; case OperandType.InlineSwitch: { int[] branches = (int[])value; blob.Write(ref pos, (int)branches.Length); for (int i = 0; i < branches.Length; i++) { blob.Write(ref pos, (int)branches[i]); } } break; case OperandType.InlineTok: { var signature = (Signature)value; int rid = module.AddSignature(ref signature); blob.Write(ref pos, (int)rid); } break; case OperandType.InlineType: { var signature = (Signature)value; int rid = module.AddSignature(ref signature); blob.Write(ref pos, (int)rid); } break; case OperandType.InlineVar: { blob.Write(ref pos, (short)value); } break; case OperandType.ShortInlineBrTarget: { blob.Write(ref pos, (sbyte)value); } break; case OperandType.ShortInlineI: { blob.Write(ref pos, (byte)value); } break; case OperandType.ShortInlineR: { blob.Write(ref pos, (float)value); } break; case OperandType.ShortInlineVar: { blob.Write(ref pos, (byte)value); } break; } } }
protected internal override void InternMembers(Module module) { module.AddSignature(ref _fieldType); module.AddSignature(ref _owner); }