assemblies_dir=@prefix@/lib/mono
-Libraries=${assemblies_dir}/gac/Mono.Cecil/0.9.4.0__0738eb9f132ed756/Mono.Cecil.dll
+Libraries=${assemblies_dir}/gac/Mono.Cecil/0.9.5.0__0738eb9f132ed756/Mono.Cecil.dll
Name: Mono Internal -- Do not use.
Description: Mono Internal Libraries -- Do not use
[assembly: AssemblyTitle ("Mono.Cecil.Mdb")]
[assembly: AssemblyProduct ("Mono.Cecil")]
-[assembly: AssemblyCopyright ("Copyright © 2008 - 2010 Jb Evain")]
+[assembly: AssemblyCopyright ("Copyright © 2008 - 2011 Jb Evain")]
[assembly: CLSCompliant (false)]
[assembly: ComVisible (false)]
-[assembly: AssemblyVersion ("0.9.4.0")]
-[assembly: AssemblyFileVersion ("0.9.4.0")]
+[assembly: AssemblyVersion ("0.9.5.0")]
+[assembly: AssemblyFileVersion ("0.9.5.0")]
static bool IsFatRange (Instruction start, Instruction end)
{
+ if (start == null)
+ throw new ArgumentException ();
+
if (end == null)
return true;
public int ReadCompressedInt32 ()
{
- var value = (int) ReadCompressedUInt32 ();
-
- return (value & 1) != 0
- ? -(value >> 1)
- : value >> 1;
+ var value = (int) (ReadCompressedUInt32 () >> 1);
+ if ((value & 1) == 0)
+ return value;
+ if (value < 0x40)
+ return value - 0x40;
+ if (value < 0x2000)
+ return value - 0x2000;
+ if (value < 0x10000000)
+ return value - 0x10000000;
+ return value - 0x20000000;
}
public float ReadSingle ()
public void WriteCompressedInt32 (int value)
{
- WriteCompressedUInt32 ((uint) ((value < 0) ? ((-value) << 1) | 1 : value << 1));
+ if (value >= 0) {
+ WriteCompressedUInt32 ((uint) (value << 1));
+ return;
+ }
+
+ if (value > -0x40)
+ value = 0x40 + value;
+ else if (value >= -0x2000)
+ value = 0x2000 + value;
+ else if (value >= -0x20000000)
+ value = 0x20000000 + value;
+
+ WriteCompressedUInt32 ((uint) ((value << 1) | 1));
}
public void WriteBytes (byte [] bytes)
sections [i] = section;
- if (section.Name == ".reloc")
- continue;
-
ReadSectionData (section);
}
[assembly: AssemblyTitle ("Mono.Cecil")]
[assembly: AssemblyProduct ("Mono.Cecil")]
-[assembly: AssemblyCopyright ("Copyright © 2008 - 2010 Jb Evain")]
+[assembly: AssemblyCopyright ("Copyright © 2008 - 2011 Jb Evain")]
[assembly: ComVisible (false)]
[assembly: Guid ("fd225bb4-fa53-44b2-a6db-85f5e48dcb54")]
-[assembly: AssemblyVersion ("0.9.4.0")]
+[assembly: AssemblyVersion ("0.9.5.0")]
#if !CF
-[assembly: AssemblyFileVersion ("0.9.4.0")]
+[assembly: AssemblyFileVersion ("0.9.5.0")]
#endif
[assembly: InternalsVisibleTo ("Mono.Cecil.Pdb, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")]
if (parameters.AssemblyResolver != null)
module.assembly_resolver = parameters.AssemblyResolver;
+ if (parameters.MetadataResolver != null)
+ module.metadata_resolver = parameters.MetadataResolver;
+
return module;
}
Range range;
if (!metadata.TryGetGenericParameterRange (provider, out range)
|| !MoveTo (Table.GenericParam, range.Start))
- return new Collection<GenericParameter> ();
+ return new GenericParameterCollection (provider);
metadata.RemoveGenericParameterRange (provider);
- var generic_parameters = new Collection<GenericParameter> ((int) range.Length);
+ var generic_parameters = new GenericParameterCollection (provider, (int) range.Length);
for (uint i = 0; i < range.Length; i++) {
ReadUInt16 (); // index
GenericParameter GetGenericParameter (GenericParameterType type, uint var)
{
var context = reader.context;
+ int index = (int) var;
if (context == null)
- throw new NotSupportedException ();
+ return GetUnboundGenericParameter (type, index);
IGenericParameterProvider provider;
throw new NotSupportedException ();
}
- int index = (int) var;
-
if (!context.IsDefinition)
CheckGenericContext (provider, index);
+ if (index >= provider.GenericParameters.Count)
+ return GetUnboundGenericParameter (type, index);
+
return provider.GenericParameters [index];
}
+ static GenericParameter GetUnboundGenericParameter (GenericParameterType type, int index)
+ {
+ return new GenericParameter (index, type);
+ }
+
static void CheckGenericContext (IGenericParameterProvider owner, int index)
{
var owner_parameters = owner.GenericParameters;
? reference.PublicKeyToken
: reference.PublicKey;
+ var version = reference.Version;
+
var rid = table.AddRow (new AssemblyRefRow (
- (ushort) reference.Version.Major,
- (ushort) reference.Version.Minor,
- (ushort) reference.Version.Build,
- (ushort) reference.Version.Revision,
+ (ushort) version.Major,
+ (ushort) version.Minor,
+ (ushort) version.Build,
+ (ushort) version.Revision,
reference.Attributes,
GetBlobIndex (key_or_token),
GetStringIndex (reference.Name),
var count = GetNamedArgumentCount (attribute);
if (count == 0) {
- WriteCompressedUInt32 (0); // length
+ WriteCompressedUInt32 (1); // length
WriteCompressedUInt32 (0); // count
return;
}
- var buffer = new SignatureWriter (metadata);
+ var buffer = new SignatureWriter (metadata);
buffer.WriteCompressedUInt32 ((uint) count);
buffer.WriteICustomAttributeNamedArguments (attribute);
}
}
+#if !SILVERLIGHT && !CF
+ [Serializable]
+#endif
public class AssemblyResolutionException : FileNotFoundException {
readonly AssemblyNameReference reference;
{
this.reference = reference;
}
+
+#if !SILVERLIGHT && !CF
+ protected AssemblyResolutionException (
+ System.Runtime.Serialization.SerializationInfo info,
+ System.Runtime.Serialization.StreamingContext context)
+ : base (info, context)
+ {
+ }
+#endif
}
public abstract class BaseAssemblyResolver : IAssemblyResolver {
public sealed class GenericParameter : TypeReference, ICustomAttributeProvider {
- readonly IGenericParameterProvider owner;
+ internal int position;
+ internal GenericParameterType type;
+ internal IGenericParameterProvider owner;
ushort attributes;
Collection<TypeReference> constraints;
}
public int Position {
- get {
- if (owner == null)
- return -1;
+ get { return position; }
+ }
- return owner.GenericParameters.IndexOf (this);
- }
+ public GenericParameterType Type {
+ get { return type; }
}
public IGenericParameterProvider Owner {
public override IMetadataScope Scope {
get {
- if (owner.GenericParameterType == GenericParameterType.Method)
- return ((MethodReference) owner).DeclaringType.Scope;
+ if (owner == null)
+ return null;
- return ((TypeReference) owner).Scope;
+ return owner.GenericParameterType == GenericParameterType.Method
+ ? ((MethodReference) owner).DeclaringType.Scope
+ : ((TypeReference) owner).Scope;
}
}
public override ModuleDefinition Module {
- get { return ((MemberReference) owner).Module; }
+ get { return owner != null ? owner.Module : null; }
}
public override string Name {
if (!string.IsNullOrEmpty (base.Name))
return base.Name;
- return base.Name = (owner.GenericParameterType == GenericParameterType.Type ? "!" : "!!") + Position;
+ return base.Name = (type == GenericParameterType.Method ? "!!" : "!") + position;
}
}
if (owner == null)
throw new ArgumentNullException ();
+ this.position = -1;
this.owner = owner;
- this.etype = owner.GenericParameterType == GenericParameterType.Type ? ElementType.Var : ElementType.MVar;
+ this.type = owner.GenericParameterType;
+ this.etype = ConvertGenericParameterType (this.type);
+ }
+
+ public GenericParameter (int position, GenericParameterType type)
+ : base (string.Empty, string.Empty)
+ {
+ this.position = position;
+ this.type = type;
+ this.etype = ConvertGenericParameterType (type);
+ }
+
+ static ElementType ConvertGenericParameterType (GenericParameterType type)
+ {
+ switch (type) {
+ case GenericParameterType.Type:
+ return ElementType.Var;
+ case GenericParameterType.Method:
+ return ElementType.MVar;
+ }
+
+ throw new ArgumentOutOfRangeException ();
}
public override TypeDefinition Resolve ()
return null;
}
}
+
+ sealed class GenericParameterCollection : Collection<GenericParameter> {
+
+ readonly IGenericParameterProvider owner;
+
+ internal GenericParameterCollection (IGenericParameterProvider owner)
+ {
+ this.owner = owner;
+ }
+
+ internal GenericParameterCollection (IGenericParameterProvider owner, int capacity)
+ : base (capacity)
+ {
+ this.owner = owner;
+ }
+
+ protected override void OnAdd (GenericParameter item, int index)
+ {
+ UpdateGenericParameter (item, index);
+ }
+
+ protected override void OnInsert (GenericParameter item, int index)
+ {
+ UpdateGenericParameter (item, index);
+
+ for (int i = index; i < size; i++)
+ items[i].position = i + 1;
+ }
+
+ protected override void OnSet (GenericParameter item, int index)
+ {
+ UpdateGenericParameter (item, index);
+ }
+
+ void UpdateGenericParameter (GenericParameter item, int index)
+ {
+ item.owner = owner;
+ item.position = index;
+ item.type = owner.GenericParameterType;
+ }
+
+ protected override void OnRemove (GenericParameter item, int index)
+ {
+ item.owner = null;
+ item.position = -1;
+ item.type = GenericParameterType.Type;
+
+ for (int i = index + 1; i < size; i++)
+ items[i].position = i - 1;
+ }
+ }
}
this ICustomAttributeProvider self,
ModuleDefinition module)
{
- return module.HasImage ()
- ? module.Read (self, (provider, reader) => reader.HasCustomAttributes (provider))
- : false;
+ return module.HasImage () && module.Read (self, (provider, reader) => reader.HasCustomAttributes (provider));
}
public static Collection<CustomAttribute> GetCustomAttributes (
this IGenericParameterProvider self,
ModuleDefinition module)
{
- return module.HasImage ()
- ? module.Read (self, (provider, reader) => reader.HasGenericParameters (provider))
- : false;
+ return module.HasImage () && module.Read (self, (provider, reader) => reader.HasGenericParameters (provider));
}
public static Collection<GenericParameter> GetGenericParameters (
{
return module.HasImage ()
? module.Read (self, (provider, reader) => reader.ReadGenericParameters (provider))
- : new Collection<GenericParameter> ();
+ : new GenericParameterCollection (self);
}
}
}
this IMarshalInfoProvider self,
ModuleDefinition module)
{
- return module.HasImage ()
- ? module.Read (self, (provider, reader) => reader.HasMarshalInfo (provider))
- : false;
+ return module.HasImage () && module.Read (self, (provider, reader) => reader.HasMarshalInfo (provider));
}
public static MarshalInfo GetMarshalInfo (
//
using System;
-using System.Collections.Generic;
using Mono.Collections.Generic;
AssemblyDefinition Resolve (string fullName, ReaderParameters parameters);
}
+ public interface IMetadataResolver {
+ TypeDefinition Resolve (TypeReference type);
+ FieldDefinition Resolve (FieldReference field);
+ MethodDefinition Resolve (MethodReference method);
+ }
+
+#if !SILVERLIGHT && !CF
+ [Serializable]
+#endif
public class ResolutionException : Exception {
readonly MemberReference member;
{
this.member = member;
}
+
+#if !SILVERLIGHT && !CF
+ protected ResolutionException (
+ System.Runtime.Serialization.SerializationInfo info,
+ System.Runtime.Serialization.StreamingContext context)
+ : base (info, context)
+ {
+ }
+#endif
}
- static class MetadataResolver {
+ public class MetadataResolver : IMetadataResolver {
+
+ readonly IAssemblyResolver assembly_resolver;
+
+ public IAssemblyResolver AssemblyResolver {
+ get { return assembly_resolver; }
+ }
+
+ public MetadataResolver (IAssemblyResolver assemblyResolver)
+ {
+ if (assemblyResolver == null)
+ throw new ArgumentNullException ("assemblyResolver");
+
+ assembly_resolver = assemblyResolver;
+ }
- public static TypeDefinition Resolve (IAssemblyResolver resolver, TypeReference type)
+ public virtual TypeDefinition Resolve (TypeReference type)
{
+ if (type == null)
+ throw new ArgumentNullException ("type");
+
type = type.GetElementType ();
var scope = type.Scope;
switch (scope.MetadataScopeType) {
case MetadataScopeType.AssemblyNameReference:
- var assembly = resolver.Resolve ((AssemblyNameReference) scope);
+ var assembly = assembly_resolver.Resolve ((AssemblyNameReference) scope);
if (assembly == null)
return null;
- return GetType (resolver, assembly.MainModule, type);
+ return GetType (assembly.MainModule, type);
case MetadataScopeType.ModuleDefinition:
- return GetType (resolver, (ModuleDefinition) scope, type);
+ return GetType ((ModuleDefinition) scope, type);
case MetadataScopeType.ModuleReference:
var modules = type.Module.Assembly.Modules;
var module_ref = (ModuleReference) scope;
for (int i = 0; i < modules.Count; i++) {
var netmodule = modules [i];
if (netmodule.Name == module_ref.Name)
- return GetType (resolver, netmodule, type);
+ return GetType (netmodule, type);
}
break;
}
throw new NotSupportedException ();
}
- static TypeDefinition GetType (IAssemblyResolver resolver, ModuleDefinition module, TypeReference reference)
+ static TypeDefinition GetType (ModuleDefinition module, TypeReference reference)
{
- var type = GetType (module, reference);
+ var type = GetTypeDefinition (module, reference);
if (type != null)
return type;
return null;
}
- static TypeDefinition GetType (ModuleDefinition module, TypeReference type)
+ static TypeDefinition GetTypeDefinition (ModuleDefinition module, TypeReference type)
{
if (!type.IsNested)
return module.GetType (type.Namespace, type.Name);
return declaring_type.GetNestedType (type.Name);
}
- public static FieldDefinition Resolve (IAssemblyResolver resolver, FieldReference field)
+ public virtual FieldDefinition Resolve (FieldReference field)
{
- var type = Resolve (resolver, field.DeclaringType);
+ if (field == null)
+ throw new ArgumentNullException ("field");
+
+ var type = Resolve (field.DeclaringType);
if (type == null)
return null;
if (!type.HasFields)
return null;
- return GetField (resolver, type, field);
+ return GetField (type, field);
}
- static FieldDefinition GetField (IAssemblyResolver resolver, TypeDefinition type, FieldReference reference)
+ FieldDefinition GetField (TypeDefinition type, FieldReference reference)
{
while (type != null) {
var field = GetField (type.Fields, reference);
if (type.BaseType == null)
return null;
- type = Resolve (resolver, type.BaseType);
+ type = Resolve (type.BaseType);
}
return null;
}
- static FieldDefinition GetField (IList<FieldDefinition> fields, FieldReference reference)
+ static FieldDefinition GetField (Collection<FieldDefinition> fields, FieldReference reference)
{
for (int i = 0; i < fields.Count; i++) {
var field = fields [i];
return null;
}
- public static MethodDefinition Resolve (IAssemblyResolver resolver, MethodReference method)
+ public virtual MethodDefinition Resolve (MethodReference method)
{
- var type = Resolve (resolver, method.DeclaringType);
+ if (method == null)
+ throw new ArgumentNullException ("method");
+
+ var type = Resolve (method.DeclaringType);
if (type == null)
return null;
if (!type.HasMethods)
return null;
- return GetMethod (resolver, type, method);
+ return GetMethod (type, method);
}
- static MethodDefinition GetMethod (IAssemblyResolver resolver, TypeDefinition type, MethodReference reference)
+ MethodDefinition GetMethod (TypeDefinition type, MethodReference reference)
{
while (type != null) {
var method = GetMethod (type.Methods, reference);
if (type.BaseType == null)
return null;
- type = Resolve (resolver, type.BaseType);
+ type = Resolve (type.BaseType);
}
return null;
}
- public static MethodDefinition GetMethod (IList<MethodDefinition> methods, MethodReference reference)
+ public static MethodDefinition GetMethod (Collection<MethodDefinition> methods, MethodReference reference)
{
for (int i = 0; i < methods.Count; i++) {
var method = methods [i];
if (generic_parameters != null)
return generic_parameters;
- return generic_parameters = new Collection<GenericParameter> ();
+ return generic_parameters = new GenericParameterCollection (this);
}
}
set { Parameter.MetadataToken = value; }
}
+ public ParameterAttributes Attributes {
+ get { return Parameter.Attributes; }
+ set { Parameter.Attributes = value; }
+ }
+
public bool HasCustomAttributes {
get { return parameter != null && parameter.HasCustomAttributes; }
}
ReadingMode reading_mode;
IAssemblyResolver assembly_resolver;
+ IMetadataResolver metadata_resolver;
Stream symbol_stream;
ISymbolReaderProvider symbol_reader_provider;
bool read_symbols;
set { assembly_resolver = value; }
}
+ public IMetadataResolver MetadataResolver {
+ get { return metadata_resolver; }
+ set { metadata_resolver = value; }
+ }
+
public Stream SymbolStream {
get { return symbol_stream; }
set { symbol_stream = value; }
TargetRuntime runtime;
TargetArchitecture architecture;
IAssemblyResolver assembly_resolver;
+ IMetadataResolver metadata_resolver;
public ModuleKind Kind {
get { return kind; }
set { assembly_resolver = value; }
}
+ public IMetadataResolver MetadataResolver {
+ get { return metadata_resolver; }
+ set { metadata_resolver = value; }
+ }
+
public ModuleParameters ()
{
this.kind = ModuleKind.Dll;
internal ISymbolReader SymbolReader;
internal IAssemblyResolver assembly_resolver;
+ internal IMetadataResolver metadata_resolver;
internal TypeSystem type_system;
readonly MetadataReader reader;
get { return assembly_resolver; }
}
+ public IMetadataResolver MetadataResolver {
+ get { return metadata_resolver ?? (metadata_resolver = new MetadataResolver (assembly_resolver)); }
+ }
+
public TypeSystem TypeSystem {
get { return type_system ?? (type_system = TypeSystem.CreateTypeSystem (this)); }
}
return Read (this, (_, reader) => reader.GetMemberReferences ());
}
+ public TypeReference GetType (string fullName, bool runtimeName)
+ {
+ return runtimeName
+ ? TypeParser.ParseType (this, fullName)
+ : GetType (fullName);
+ }
+
public TypeDefinition GetType (string fullName)
{
CheckFullName (fullName);
internal FieldDefinition Resolve (FieldReference field)
{
- return MetadataResolver.Resolve (AssemblyResolver, field);
+ return MetadataResolver.Resolve (field);
}
internal MethodDefinition Resolve (MethodReference method)
{
- return MetadataResolver.Resolve (AssemblyResolver, method);
+ return MetadataResolver.Resolve (method);
}
internal TypeDefinition Resolve (TypeReference type)
{
- return MetadataResolver.Resolve (AssemblyResolver, type);
+ return MetadataResolver.Resolve (type);
}
#if !READ_ONLY
if (parameters.AssemblyResolver != null)
module.assembly_resolver = parameters.AssemblyResolver;
+ if (parameters.MetadataResolver != null)
+ module.metadata_resolver = parameters.MetadataResolver;
+
if (parameters.Kind != ModuleKind.NetModule) {
var assembly = new AssemblyDefinition ();
module.assembly = assembly;
- module.assembly.Name = new AssemblyNameDefinition (name, new Version (0, 0));
+ module.assembly.Name = CreateAssemblyName (name);
assembly.main_module = module;
}
return module;
}
+ static AssemblyNameDefinition CreateAssemblyName (string name)
+ {
+ if (name.EndsWith (".dll") || name.EndsWith (".exe"))
+ name = name.Substring (0, name.Length - 4);
+
+ return new AssemblyNameDefinition (name, new Version (0, 0, 0, 0));
+ }
+
#endif
public void ReadSymbols ()
throw new InvalidOperationException ();
var provider = SymbolProvider.GetPlatformReaderProvider ();
+ if (provider == null)
+ throw new InvalidOperationException ();
- SymbolReader = provider.GetSymbolReader (this, fq_name);
-
- ProcessDebugHeader ();
+ ReadSymbols (provider.GetSymbolReader (this, fq_name));
}
public void ReadSymbols (ISymbolReader reader)
public sealed class SecurityDeclaration {
readonly internal uint signature;
+ byte [] blob;
readonly ModuleDefinition module;
internal bool resolved;
this.resolved = true;
}
+ public SecurityDeclaration (SecurityAction action, byte [] blob)
+ {
+ this.action = action;
+ this.resolved = false;
+ this.blob = blob;
+ }
+
public byte [] GetBlob ()
{
+ if (blob != null)
+ return blob;
+
if (!HasImage || signature == 0)
throw new NotSupportedException ();
- return module.Read (this, (declaration, reader) => reader.ReadSecurityDeclarationBlob (declaration.signature));
+ return blob = module.Read (this, (declaration, reader) => reader.ReadSecurityDeclarationBlob (declaration.signature));
}
void Resolve ()
this ISecurityDeclarationProvider self,
ModuleDefinition module)
{
- return module.HasImage ()
- ? module.Read (self, (provider, reader) => reader.HasSecurityDeclarations (provider))
- : false;
+ return module.HasImage () && module.Read (self, (provider, reader) => reader.HasSecurityDeclarations (provider));
}
public static Collection<SecurityDeclaration> GetSecurityDeclarations (
if (generic_parameters != null)
return generic_parameters;
- return generic_parameters = new Collection<GenericParameter> ();
+ return generic_parameters = new GenericParameterCollection (this);
}
}
-90e481c594502333d400226b3d4198dfd26964b2
+53e6ba7207aa843fac13b80a295380c517f2af8d
projects / mono.git / commitdiff