1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
//
// Author:
// Jb Evain (jbevain@gmail.com)
//
// Copyright (c) 2008 - 2015 Jb Evain
// Copyright (c) 2008 - 2011 Novell, Inc.
//
// Licensed under the MIT/X11 license.
//
using System;
using System.IO;
using Mono.Collections.Generic;
namespace Mono.Cecil {
public sealed class AssemblyDefinition : ICustomAttributeProvider, ISecurityDeclarationProvider {
AssemblyNameDefinition name;
internal ModuleDefinition main_module;
Collection<ModuleDefinition> modules;
Collection<CustomAttribute> custom_attributes;
Collection<SecurityDeclaration> security_declarations;
public AssemblyNameDefinition Name {
get { return name; }
set { name = value; }
}
public string FullName {
get { return name != null ? name.FullName : string.Empty; }
}
public MetadataToken MetadataToken {
get { return new MetadataToken (TokenType.Assembly, 1); }
set { }
}
public Collection<ModuleDefinition> Modules {
get {
if (modules != null)
return modules;
if (main_module.HasImage)
return main_module.Read (ref modules, this, (_, reader) => reader.ReadModules ());
return modules = new Collection<ModuleDefinition> (1) { main_module };
}
}
public ModuleDefinition MainModule {
get { return main_module; }
}
public MethodDefinition EntryPoint {
get { return main_module.EntryPoint; }
set { main_module.EntryPoint = value; }
}
public bool HasCustomAttributes {
get {
if (custom_attributes != null)
return custom_attributes.Count > 0;
return this.GetHasCustomAttributes (main_module);
}
}
public Collection<CustomAttribute> CustomAttributes {
get { return custom_attributes ?? (this.GetCustomAttributes (ref custom_attributes, main_module)); }
}
public bool HasSecurityDeclarations {
get {
if (security_declarations != null)
return security_declarations.Count > 0;
return this.GetHasSecurityDeclarations (main_module);
}
}
public Collection<SecurityDeclaration> SecurityDeclarations {
get { return security_declarations ?? (this.GetSecurityDeclarations (ref security_declarations, main_module)); }
}
internal AssemblyDefinition ()
{
}
#if !READ_ONLY
public static AssemblyDefinition CreateAssembly (AssemblyNameDefinition assemblyName, string moduleName, ModuleKind kind)
{
return CreateAssembly (assemblyName, moduleName, new ModuleParameters { Kind = kind });
}
public static AssemblyDefinition CreateAssembly (AssemblyNameDefinition assemblyName, string moduleName, ModuleParameters parameters)
{
if (assemblyName == null)
throw new ArgumentNullException ("assemblyName");
if (moduleName == null)
throw new ArgumentNullException ("moduleName");
Mixin.CheckParameters (parameters);
if (parameters.Kind == ModuleKind.NetModule)
throw new ArgumentException ("kind");
var assembly = ModuleDefinition.CreateModule (moduleName, parameters).Assembly;
assembly.Name = assemblyName;
return assembly;
}
#endif
public static AssemblyDefinition ReadAssembly (string fileName)
{
return ReadAssembly (ModuleDefinition.ReadModule (fileName));
}
public static AssemblyDefinition ReadAssembly (string fileName, ReaderParameters parameters)
{
return ReadAssembly (ModuleDefinition.ReadModule (fileName, parameters));
}
public static AssemblyDefinition ReadAssembly (Stream stream)
{
return ReadAssembly (ModuleDefinition.ReadModule (stream));
}
public static AssemblyDefinition ReadAssembly (Stream stream, ReaderParameters parameters)
{
return ReadAssembly (ModuleDefinition.ReadModule (stream, parameters));
}
static AssemblyDefinition ReadAssembly (ModuleDefinition module)
{
var assembly = module.Assembly;
if (assembly == null)
throw new ArgumentException ();
return assembly;
}
#if !READ_ONLY
public void Write (string fileName)
{
Write (fileName, new WriterParameters ());
}
public void Write (Stream stream)
{
Write (stream, new WriterParameters ());
}
public void Write (string fileName, WriterParameters parameters)
{
main_module.Write (fileName, parameters);
}
public void Write (Stream stream, WriterParameters parameters)
{
main_module.Write (stream, parameters);
}
#endif
public override string ToString ()
{
return this.FullName;
}
}
}
|
