pax_global_header 0000666 0000000 0000000 00000000064 13250336635 0014520 g ustar 00root root 0000000 0000000 52 comment=d57237e61feca7cc6a525abd74b31aab07bb96c7
dnlib-2.1_VS2010/ 0000775 0000000 0000000 00000000000 13250336635 0013365 5 ustar 00root root 0000000 0000000 dnlib-2.1_VS2010/.editorconfig 0000664 0000000 0000000 00000010367 13250336635 0016051 0 ustar 00root root 0000000 0000000 root = true
[*]
indent_size = 4
indent_style = tab
insert_final_newline = true
tab_width = 4
#end_of_line =
[*.json]
[App.config]
[*.yml]
indent_size = 2
indent_style = space
[*.{proj,csproj,vbproj,props,targets,resx,vsixmanifest}]
indent_size = 2
indent_style = space
[app.manifest]
indent_size = 2
indent_style = space
[*.xml]
[*.xaml]
indent_style = space
[*.{cs,vb}]
dotnet_sort_system_directives_first = true
dotnet_style_qualification_for_field = false:suggestion
dotnet_style_qualification_for_property = false:suggestion
dotnet_style_qualification_for_method = false:suggestion
dotnet_style_qualification_for_event = false:suggestion
dotnet_style_predefined_type_for_locals_parameters_members = true:none
dotnet_style_predefined_type_for_member_access = true:none
dotnet_style_object_initializer = true:suggestion
dotnet_style_collection_initializer = true:suggestion
dotnet_style_coalesce_expression = true:suggestion
dotnet_style_null_propagation = true:suggestion
dotnet_style_explicit_tuple_names = true:suggestion
dotnet_separate_import_directive_groups = false
dotnet_style_prefer_is_null_check_over_reference_equality_method = false:suggestion
dotnet_style_require_accessibility_modifiers = never:info
[*.cs]
csharp_style_throw_expression = true:suggestion
csharp_style_inlined_variable_declaration = true:suggestion
csharp_style_var_for_built_in_types = false:none
csharp_style_var_when_type_is_apparent = true:suggestion
csharp_style_var_elsewhere = true:suggestion
csharp_style_conditional_delegate_call = true:suggestion
csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
csharp_style_expression_bodied_constructors = true:suggestion
csharp_style_expression_bodied_methods = true:suggestion
csharp_style_expression_bodied_operators = true:suggestion
csharp_style_expression_bodied_properties = true:suggestion
csharp_style_expression_bodied_indexers = true:suggestion
csharp_style_expression_bodied_accessors = true:suggestion
csharp_prefer_braces = false
csharp_space_between_method_declaration_name_and_open_parenthesis = false
csharp_space_between_method_declaration_parameter_list_parentheses = false
csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
csharp_space_between_method_call_name_and_opening_parenthesis = false
csharp_space_between_method_call_parameter_list_parentheses = false
csharp_space_between_method_call_empty_parameter_list_parentheses = false
csharp_space_after_keywords_in_control_flow_statements = true
csharp_space_between_parentheses =
csharp_space_after_cast = false
csharp_space_around_declaration_statements = false
csharp_space_before_open_square_brackets = false
csharp_space_between_empty_square_brackets = false
csharp_space_between_square_brackets = false
csharp_space_after_colon_in_inheritance_clause = true
csharp_space_after_comma = true
csharp_space_after_dot = false
csharp_space_after_semicolon_in_for_statement = true
csharp_space_before_colon_in_inheritance_clause = true
csharp_space_before_comma = false
csharp_space_before_dot = false
csharp_space_before_semicolon_in_for_statement = false
csharp_space_around_binary_operators = before_and_after
csharp_indent_braces = false
csharp_indent_block_contents = true
csharp_indent_switch_labels = false
csharp_indent_case_contents = true
csharp_indent_labels = flush_left
csharp_preserve_single_line_blocks = true
csharp_preserve_single_line_statements = true
csharp_new_line_before_open_brace = none
csharp_new_line_before_else = true
csharp_new_line_before_catch = true
csharp_new_line_before_finally = true
csharp_new_line_before_members_in_object_initializers = true
csharp_new_line_before_members_in_anonymous_types = true
csharp_new_line_between_query_expression_clauses = true
csharp_indent_case_contents_when_block = false
csharp_prefer_inferred_anonymous_type_member_names = true:suggestion
csharp_prefer_inferred_tuple_names = true:suggestion
csharp_prefer_simple_default_expression = true:suggestion
#csharp_preferred_modifier_order =
csharp_style_pattern_local_over_anonymous_function = true:suggestion
[*.vb]
visual_basic_prefer_inferred_anonymous_type_member_names = true:suggestion
visual_basic_prefer_inferred_tuple_names = true:suggestion
#visual_basic_preferred_modifier_order =
dnlib-2.1_VS2010/.gitattributes 0000664 0000000 0000000 00000000115 13250336635 0016255 0 ustar 00root root 0000000 0000000 * text=auto
*.cs text diff=csharp
*.sln text eol=crlf
*.csproj text eol=crlf
dnlib-2.1_VS2010/.gitignore 0000664 0000000 0000000 00000000140 13250336635 0015350 0 ustar 00root root 0000000 0000000 *~
*/obj/
*.csproj.user
*.sdf
*.opensdf
*.suo
/.vs/
/Debug/
/Release/
/Examples/bin/
*.tmp_proj
dnlib-2.1_VS2010/Examples/ 0000775 0000000 0000000 00000000000 13250336635 0015143 5 ustar 00root root 0000000 0000000 dnlib-2.1_VS2010/Examples/Example1.cs 0000664 0000000 0000000 00000002624 13250336635 0017152 0 ustar 00root root 0000000 0000000 using System;
using dnlib.DotNet;
namespace dnlib.Examples {
// This example will open mscorlib.dll and then print out all types
// in the assembly, including the number of methods, fields, properties
// and events each type has.
public class Example1 {
public static void Run() {
// Load mscorlib.dll
string filename = typeof(void).Module.FullyQualifiedName;
ModuleDefMD mod = ModuleDefMD.Load(filename);
int totalNumTypes = 0;
// mod.Types only returns non-nested types.
// mod.GetTypes() returns all types, including nested types.
foreach (TypeDef type in mod.GetTypes()) {
totalNumTypes++;
Console.WriteLine();
Console.WriteLine("Type: {0}", type.FullName);
if (type.BaseType != null)
Console.WriteLine(" Base type: {0}", type.BaseType.FullName);
Console.WriteLine(" Methods: {0}", type.Methods.Count);
Console.WriteLine(" Fields: {0}", type.Fields.Count);
Console.WriteLine(" Properties: {0}", type.Properties.Count);
Console.WriteLine(" Events: {0}", type.Events.Count);
Console.WriteLine(" Nested types: {0}", type.NestedTypes.Count);
if (type.Interfaces.Count > 0) {
Console.WriteLine(" Interfaces:");
foreach (InterfaceImpl iface in type.Interfaces)
Console.WriteLine(" {0}", iface.Interface.FullName);
}
}
Console.WriteLine();
Console.WriteLine("Total number of types: {0}", totalNumTypes);
}
}
}
dnlib-2.1_VS2010/Examples/Example2.cs 0000664 0000000 0000000 00000005134 13250336635 0017152 0 ustar 00root root 0000000 0000000 using dnlib.DotNet;
using dnlib.DotNet.Emit;
namespace dnlib.Examples {
public class Example2 {
// This will open the current assembly, add a new class and method to it,
// and then save the assembly to disk.
public static void Run() {
// Open the current module
ModuleDefMD mod = ModuleDefMD.Load(typeof(Example2).Module);
// Create a new public class that derives from System.Object
TypeDef type1 = new TypeDefUser("My.Namespace", "MyType",
mod.CorLibTypes.Object.TypeDefOrRef);
type1.Attributes = TypeAttributes.Public | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass;
// Make sure to add it to the module or any other type in the module. This is
// not a nested type, so add it to mod.Types.
mod.Types.Add(type1);
// Create a public static System.Int32 field called MyField
FieldDef field1 = new FieldDefUser("MyField",
new FieldSig(mod.CorLibTypes.Int32),
FieldAttributes.Public | FieldAttributes.Static);
// Add it to the type we created earlier
type1.Fields.Add(field1);
// Add a static method that adds both inputs and the static field
// and returns the result
MethodImplAttributes methImplFlags = MethodImplAttributes.IL | MethodImplAttributes.Managed;
MethodAttributes methFlags = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.ReuseSlot;
MethodDef meth1 = new MethodDefUser("MyMethod",
MethodSig.CreateStatic(mod.CorLibTypes.Int32, mod.CorLibTypes.Int32, mod.CorLibTypes.Int32),
methImplFlags, methFlags);
type1.Methods.Add(meth1);
// Create the CIL method body
CilBody body = new CilBody();
meth1.Body = body;
// Name the 1st and 2nd args a and b, respectively
meth1.ParamDefs.Add(new ParamDefUser("a", 1));
meth1.ParamDefs.Add(new ParamDefUser("b", 2));
// Create a local. We don't really need it but let's add one anyway
Local local1 = new Local(mod.CorLibTypes.Int32);
body.Variables.Add(local1);
// Add the instructions, and use the useless local
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldarg_1.ToInstruction());
body.Instructions.Add(OpCodes.Add.ToInstruction());
body.Instructions.Add(OpCodes.Ldsfld.ToInstruction(field1));
body.Instructions.Add(OpCodes.Add.ToInstruction());
body.Instructions.Add(OpCodes.Stloc.ToInstruction(local1));
body.Instructions.Add(OpCodes.Ldloc.ToInstruction(local1));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Save the assembly to a file on disk
mod.Write(@"C:\saved-assembly.dll");
}
}
}
dnlib-2.1_VS2010/Examples/Example3.cs 0000664 0000000 0000000 00000005731 13250336635 0017156 0 ustar 00root root 0000000 0000000 using System;
using System.Text;
using dnlib.DotNet;
using dnlib.DotNet.Emit;
namespace dnlib.Examples {
// This example creates a new assembly and saves it to disk.
// This is what it will look like if you decompile it:
//
// using System;
// namespace My.Namespace
// {
// internal class Startup
// {
// private static int Main(string[] args)
// {
// Console.WriteLine("Hello World!");
// return 0;
// }
// }
// }
public class Example3 {
public static void Run() {
// Create a new module. The string passed in is the name of the module,
// not the file name.
ModuleDef mod = new ModuleDefUser("MyModule.exe");
// It's a console application
mod.Kind = ModuleKind.Console;
// Add the module to an assembly
AssemblyDef asm = new AssemblyDefUser("MyAssembly", new Version(1, 2, 3, 4), null, null);
asm.Modules.Add(mod);
// Add a .NET resource
byte[] resourceData = Encoding.UTF8.GetBytes("Hello, world!");
mod.Resources.Add(new EmbeddedResource("My.Resource", resourceData,
ManifestResourceAttributes.Private));
// Add the startup type. It derives from System.Object.
TypeDef startUpType = new TypeDefUser("My.Namespace", "Startup", mod.CorLibTypes.Object.TypeDefOrRef);
startUpType.Attributes = TypeAttributes.NotPublic | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass;
// Add the type to the module
mod.Types.Add(startUpType);
// Create the entry point method
MethodDef entryPoint = new MethodDefUser("Main",
MethodSig.CreateStatic(mod.CorLibTypes.Int32, new SZArraySig(mod.CorLibTypes.String)));
entryPoint.Attributes = MethodAttributes.Private | MethodAttributes.Static |
MethodAttributes.HideBySig | MethodAttributes.ReuseSlot;
entryPoint.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
// Name the 1st argument (argument 0 is the return type)
entryPoint.ParamDefs.Add(new ParamDefUser("args", 1));
// Add the method to the startup type
startUpType.Methods.Add(entryPoint);
// Set module entry point
mod.EntryPoint = entryPoint;
// Create a TypeRef to System.Console
TypeRef consoleRef = new TypeRefUser(mod, "System", "Console", mod.CorLibTypes.AssemblyRef);
// Create a method ref to 'System.Void System.Console::WriteLine(System.String)'
MemberRef consoleWrite1 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String),
consoleRef);
// Add a CIL method body to the entry point method
CilBody epBody = new CilBody();
entryPoint.Body = epBody;
epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction("Hello World!"));
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
epBody.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
epBody.Instructions.Add(OpCodes.Ret.ToInstruction());
// Save the assembly to a file on disk
mod.Write(@"C:\saved-assembly.exe");
}
}
}
dnlib-2.1_VS2010/Examples/Example4.cs 0000664 0000000 0000000 00000015631 13250336635 0017157 0 ustar 00root root 0000000 0000000 using System;
using dnlib.DotNet;
using dnlib.DotNet.Emit;
/*
This example shows how to create an assembly from scratch and create two
instances by calling their constructors. One default constructor and another
one taking two arguments.
ILSpy output of created file:
using System;
namespace Ctor.Test
{
internal class BaseClass
{
public BaseClass()
{
Console.WriteLine("BaseClass: Default .ctor called", null);
}
}
internal class Main : BaseClass
{
public static void Main()
{
new Main();
new Main(12345, null);
}
public Main()
{
Console.WriteLine("Default .ctor called", null);
}
public Main(int count, string name)
{
Console.WriteLine(".ctor(Int32) called with arg {0}", count);
}
}
}
peverify output:
C:\>peverify ctor-test.exe /IL /MD
Microsoft (R) .NET Framework PE Verifier. Version 4.0.30319.1
Copyright (c) Microsoft Corporation. All rights reserved.
All Classes and Methods in ctor-test.exe Verified.
Output of program:
C:\>ctor-test.exe
BaseClass: Default .ctor called
Default .ctor called
BaseClass: Default .ctor called
.ctor(Int32) called with arg 12345
*/
namespace dnlib.Examples {
public class Example4 {
public static void Run() {
// This is the file that will be created
string newFileName = @"C:\ctor-test.exe";
// Create the module
var mod = new ModuleDefUser("ctor-test", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("ctor-test", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Create System.Console type reference
var systemConsole = mod.CorLibTypes.GetTypeRef("System", "Console");
// Create 'void System.Console.WriteLine(string,object)' method reference
var writeLine2 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String,
mod.CorLibTypes.Object),
systemConsole);
// Create System.Object::.ctor method reference. This is the default constructor
var objectCtor = new MemberRefUser(mod, ".ctor",
MethodSig.CreateInstance(mod.CorLibTypes.Void),
mod.CorLibTypes.Object.TypeDefOrRef);
CilBody body;
// Create the base class
var bclass = new TypeDefUser("Ctor.Test", "BaseClass", mod.CorLibTypes.Object.TypeDefOrRef);
// Add it to the module
mod.Types.Add(bclass);
// Create Ctor.Test.BaseClass constructor: BaseClass()
var bctor = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to BaseClass
bclass.Methods.Add(bctor);
// Create method body and add a few instructions
bctor.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(objectCtor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("BaseClass: Default .ctor called"));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create the Ctor.Test.Main type which derives from Ctor.Test.BaseClass
var main = new TypeDefUser("Ctor.Test", "Main", bclass);
// Add it to the module
mod.Types.Add(main);
// Create the static 'void Main()' method
var entryPoint = new MethodDefUser("Main", MethodSig.CreateStatic(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public | MethodAttributes.Static);
// Set entry point to entryPoint and add it as a Ctor.Test.Main method
mod.EntryPoint = entryPoint;
main.Methods.Add(entryPoint);
// Create first Ctor.Test.Main constructor: Main()
var ctor0 = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to Main
main.Methods.Add(ctor0);
// Create method body and add a few instructions
ctor0.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(bctor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Default .ctor called"));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create second Ctor.Test.Main constructor: Main(int,string)
var ctor1 = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void, mod.CorLibTypes.Int32, mod.CorLibTypes.String),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to Main
main.Methods.Add(ctor1);
// Create names for the arguments. This is optional. Since this is an instance method
// (it's a constructor), the first arg is the 'this' pointer. The normal arguments
// begin at index 1.
ctor1.Parameters[1].CreateParamDef();
ctor1.Parameters[1].ParamDef.Name = "count";
ctor1.Parameters[2].CreateParamDef();
ctor1.Parameters[2].ParamDef.Name = "name";
// Create method body and add a few instructions
ctor1.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(bctor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction(".ctor(Int32) called with arg {0}"));
body.Instructions.Add(OpCodes.Ldarg_1.ToInstruction());
body.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create the entry point method body and add instructions to allocate a new Main()
// object and call the two created ctors.
entryPoint.Body = body = new CilBody();
body.Instructions.Add(OpCodes.Newobj.ToInstruction(ctor0));
body.Instructions.Add(OpCodes.Pop.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(12345));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Newobj.ToInstruction(ctor1));
body.Instructions.Add(OpCodes.Pop.ToInstruction());
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Save the assembly
mod.Write(newFileName);
}
}
}
dnlib-2.1_VS2010/Examples/Example5.cs 0000664 0000000 0000000 00000002231 13250336635 0017150 0 ustar 00root root 0000000 0000000 using System;
using System.IO;
using dnlib.DotNet;
using dnlib.PE;
using dnlib.IO;
namespace dnlib.Examples {
///
/// Dumps all PE sections to disk
///
public class Example5 {
public static void Run() {
string sectionFileName = @"c:\section{0}.bin";
// Open the current mscorlib
var mod = ModuleDefMD.Load(typeof(int).Module);
// Get PE image interface
var peImage = mod.MetaData.PEImage;
// Print some info
Console.WriteLine("Machine: {0}", peImage.ImageNTHeaders.FileHeader.Machine);
Console.WriteLine("Characteristics: {0}", peImage.ImageNTHeaders.FileHeader.Characteristics);
Console.WriteLine("Dumping all sections");
for (int i = 0; i < peImage.ImageSectionHeaders.Count; i++) {
var section = peImage.ImageSectionHeaders[i];
// Create a stream for the whole section
var stream = peImage.CreateStream(section.VirtualAddress, section.SizeOfRawData);
// Write the data to disk
var fileName = string.Format(sectionFileName, i);
Console.WriteLine("Dumping section {0} to file {1}", section.DisplayName, fileName);
File.WriteAllBytes(fileName, stream.ReadAllBytes());
}
}
}
}
dnlib-2.1_VS2010/Examples/Example6.cs 0000664 0000000 0000000 00000007625 13250336635 0017165 0 ustar 00root root 0000000 0000000 using System;
using System.IO;
using dnlib.DotNet;
using dnlib.DotNet.MD;
using dnlib.DotNet.Writer;
using dnlib.IO;
using dnlib.PE;
namespace dnlib.Examples {
///
/// This example shows how to create a module writer listener that gets notified of various
/// events. This listener just adds a new PE section to the image and prints the new RIDs.
/// It also shows how to add some dummy .NET heaps, and simple obfuscation that will break
/// most libraries that open .NET assemblies.
///
public class Example6 : IModuleWriterListener {
public static void Run() {
new Example6().DoIt();
}
void DoIt() {
string destFileName = @"c:\output.dll";
// Open the current module
var mod = ModuleDefMD.Load(typeof(Example6).Module);
// Create the writer options
var opts = new ModuleWriterOptions(mod);
// Add a listener that gets notified during the writing process
opts.Listener = this;
// This is normally 16 but setting it to a value less than 14 will fool some
// apps into thinking that there's no .NET metadata available
opts.PEHeadersOptions.NumberOfRvaAndSizes = 13;
// Add extra data. This will break most libraries that open .NET assemblies.
// Any value can be written here.
opts.MetaDataOptions.TablesHeapOptions.ExtraData = 0x12345678;
// Add a few dummy heaps
opts.MetaDataOptions.OtherHeaps.Add(new MyHeap("#US "));
opts.MetaDataOptions.OtherHeaps.Add(new MyHeap("#Strings "));
opts.MetaDataOptions.OtherHeaps.Add(new MyHeap("#Strimgs"));
opts.MetaDataOptions.OtherHeaps.Add(new MyHeap("#GU1D"));
opts.MetaDataOptions.OtherHeapsEnd.Add(new MyHeap("#US "));
opts.MetaDataOptions.OtherHeapsEnd.Add(new MyHeap("#Strings "));
// Write the module. The listener will get notified, see OnWriterEvent() below
mod.Write(destFileName, opts);
}
// A simple heap (must implement the IHeap interface). It just writes 10 bytes to the file.
class MyHeap : IHeap {
string name;
FileOffset offset;
RVA rva;
// This is the data. I chose 10 bytes, but any non-zero value can be used
byte[] heapData = new byte[10];
public MyHeap(string name) {
this.name = name;
}
// The rest of the code is just for implementing the required interface
public string Name {
get { return name; }
}
public bool IsEmpty {
get { return false; }
}
public void SetReadOnly() {
}
public FileOffset FileOffset {
get { return offset; }
}
public RVA RVA {
get { return rva; }
}
public void SetOffset(FileOffset offset, RVA rva) {
this.offset = offset;
this.rva = rva;
}
public uint GetFileLength() {
return (uint)heapData.Length;
}
public uint GetVirtualSize() {
return GetFileLength();
}
public void WriteTo(BinaryWriter writer) {
writer.Write(heapData);
}
}
// Gets notified during module writing
public void OnWriterEvent(ModuleWriterBase writer, ModuleWriterEvent evt) {
switch (evt) {
case ModuleWriterEvent.PESectionsCreated:
// Add a PE section
var sect1 = new PESection(".dummy", 0x40000040);
writer.Sections.Add(sect1);
// Let's add data
sect1.Add(new ByteArrayChunk(new byte[123]), 4);
sect1.Add(new ByteArrayChunk(new byte[10]), 4);
break;
case ModuleWriterEvent.MDEndCreateTables:
// All types, methods etc have gotten their new RIDs. Let's print the new values
Console.WriteLine("Old -> new type and method tokens");
foreach (var type in writer.Module.GetTypes()) {
Console.WriteLine("TYPE: {0:X8} -> {1:X8} {2}",
type.MDToken.Raw,
new MDToken(Table.TypeDef, writer.MetaData.GetRid(type)).Raw,
type.FullName);
foreach (var method in type.Methods)
Console.WriteLine(" METH: {0:X8} -> {1:X8} {2}",
method.MDToken.Raw,
new MDToken(Table.Method, writer.MetaData.GetRid(method)).Raw,
method.FullName);
}
break;
default:
break;
}
}
}
}
dnlib-2.1_VS2010/Examples/Examples.csproj 0000664 0000000 0000000 00000004664 13250336635 0020155 0 ustar 00root root 0000000 0000000
Debugx868.0.307032.0{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}ExePropertiesdnlib.Examplesdnlib.Examplesv2.0512x86truefullfalsebin\Debug\DEBUG;TRACEprompt4x86pdbonlytruebin\Release\TRACEprompt4{FDFC1237-143F-4919-8318-4926901F4639}dnlib dnlib-2.1_VS2010/Examples/Program.cs 0000664 0000000 0000000 00000000415 13250336635 0017101 0 ustar 00root root 0000000 0000000 namespace dnlib.Examples {
class Program {
static void Main(string[] args) {
// Just uncomment whatever you want to debug
// Example1.Run();
// Example2.Run();
// Example3.Run();
// Example4.Run();
// Example5.Run();
Example6.Run();
}
}
}
dnlib-2.1_VS2010/Examples/Properties/ 0000775 0000000 0000000 00000000000 13250336635 0017277 5 ustar 00root root 0000000 0000000 dnlib-2.1_VS2010/Examples/Properties/AssemblyInfo.cs 0000664 0000000 0000000 00000001021 13250336635 0022213 0 ustar 00root root 0000000 0000000 using System.Reflection;
using System.Runtime.InteropServices;
[assembly: AssemblyTitle("dnlib.Examples")]
[assembly: AssemblyDescription("dnlib examples")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("dnlib.Examples")]
[assembly: AssemblyCopyright("Copyright (C) 2012-2014 de4dot@gmail.com")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
[assembly: ComVisible(false)]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
dnlib-2.1_VS2010/LICENSE.txt 0000664 0000000 0000000 00000002517 13250336635 0015215 0 ustar 00root root 0000000 0000000 dnlib: .NET assembly library
https://github.com/0xd4d/dnlib
Copyright (C) 2012-2018 de4dot@gmail.com
Contributors
------------
Ki, "yck1509 ", https://github.com/yck1509
kiootic, "kiootic ", https://github.com/kiootic
SlowLogicBoy, https://github.com/SlowLogicBoy
MIT LICENSE
-----------
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
dnlib-2.1_VS2010/README.md 0000664 0000000 0000000 00000046743 13250336635 0014662 0 ustar 00root root 0000000 0000000 .NET module/assembly reader/writer library written for [de4dot](https://github.com/0xd4d/de4dot/).
dnlib was created because de4dot needed a robust .NET assembly library that
could handle all types of obfuscated assemblies. de4dot used to use Mono.Cecil
but since Mono.Cecil can't handle obfuscated assemblies, doesn't fully support
mixed mode assemblies, doesn't read .NET assemblies the same way the [CLR](http://en.wikipedia.org/wiki/Common_Language_Runtime) does
and many other missing features de4dot needed, dnlib was a necessity. The API
is similar because it made porting de4dot to dnlib a lot easier.
For other applications using dnlib, see [dnSpy](https://github.com/0xd4d/dnSpy) and
[ConfuserEx](https://github.com/yck1509/ConfuserEx/) (a .NET obfuscator). They use
many of the more advanced features of dnlib. Have a look at ConfuserEx' writer code
which gets executed during the assembly writing process.
Want to say thanks? Click the star at the top of the page.
Compiling
---------
You must have Visual Studio 2008 or later. The solution file was created by
Visual Studio 2010, so if you use VS2008, open the solution file and change the
version number so VS2008 can read it.
Examples
--------
All examples use C#, but since it's a .NET library, you can use any .NET
language (eg. VB.NET).
See the Examples project for several examples.
Opening a .NET assembly/module
------------------------------
First of all, the important namespaces are `dnlib.DotNet` and
`dnlib.DotNet.Emit`. `dnlib.DotNet.Emit` is only needed if you intend to
read/write method bodies. All the examples below assume you have the
appropriate using statements at the top of each source file:
```csharp
using dnlib.DotNet;
using dnlib.DotNet.Emit;
```
ModuleDefMD is the class that is created when you open a .NET module. It has
several `Load()` methods that will create a ModuleDefMD instance. If it's not a
.NET module/assembly, a `BadImageFormatException` will be thrown.
Read a .NET module from a file:
```csharp
ModuleDefMD module = ModuleDefMD.Load(@"C:\path\to\file.exe");
```
Read a .NET module from a byte array:
```csharp
byte[] data = System.IO.File.ReadAllBytes(@"C:\path\of\file.dll");
ModuleDefMD module = ModuleDefMD.Load(data);
```
You can also pass in a Stream instance, an address in memory (HINSTANCE) or
even a System.Reflection.Module instance:
```csharp
System.Reflection.Module reflectionModule = typeof(void).Module; // Get mscorlib.dll's module
ModuleDefMD module = ModuleDefMD.Load(reflectionModule);
```
To get the assembly, use its Assembly property:
```csharp
AssemblyDef asm = module.Assembly;
Console.WriteLine("Assembly: {0}", asm);
```
Saving a .NET assembly/module
-----------------------------
Use `module.Write()`. It can save the assembly to a file or a Stream.
```csharp
module.Write(@"C:\saved-assembly.dll");
```
If it's a C++/CLI assembly, you should use `NativeWrite()`
```csharp
module.NativeWrite(@"C:\saved-assembly.dll");
```
To detect it at runtime, use this code:
```csharp
if (module.IsILOnly) {
// This assembly has only IL code, and no native code (eg. it's a C# or VB assembly)
module.Write(@"C:\saved-assembly.dll");
}
else {
// This assembly has native code (eg. C++/CLI)
module.NativeWrite(@"C:\saved-assembly.dll");
}
```
PDB files
---------
PDB files are read from disk by default. You can change this behaviour by
creating a `ModuleCreationOptions` and passing it in to the code that creates
a module.
To save a PDB file, create a `ModuleWriterOptions` /
`NativeModuleWriterOptions` and set its `WritePdb` property to `true`. By
default, it will create a PDB file with the same name as the output assembly
but with a `.pdb` extension. You can override this by writing the PDB file
name to `PdbFileName` or writing your own stream to `PdbStream`. If
`PdbStream` is initialized, `PdbFileName` should also be initialized because
the name of the PDB file will be written to the PE file.
```csharp
var mod = ModuleDefMD.Load(@"C:\myfile.dll");
// ...
var wopts = new dnlib.DotNet.Writer.ModuleWriterOptions(mod);
wopts.WritePdb = true;
// wopts.PdbFileName = @"C:\out2.pdb"; // Set other file name
mod.Write(@"C:\out.dll", wopts);
```
dnlib supports Windows PDBs, portable PDBs and embedded portable PDBs.
Strong name sign an assembly
----------------------------
Use the following code to strong name sign the assembly when saving it:
```csharp
using dnlib.DotNet.Writer;
...
// Open or create an assembly
ModuleDef mod = ModuleDefMD.Load(.....);
// Create writer options
var opts = new ModuleWriterOptions(mod);
// Open or create the strong name key
var signatureKey = new StrongNameKey(@"c:\my\file.snk");
// This method will initialize the required properties
opts.InitializeStrongNameSigning(mod, signatureKey);
// Write and strong name sign the assembly
mod.Write(@"C:\out\file.dll", opts);
```
Enhanced strong name signing an assembly
----------------------------------------
See this [MSDN article](http://msdn.microsoft.com/en-us/library/hh415055.aspx)
for info on enhanced strong naming.
Enhanced strong name signing without key migration:
```csharp
using dnlib.DotNet.Writer;
...
// Open or create an assembly
ModuleDef mod = ModuleDefMD.Load(....);
// Open or create the signature keys
var signatureKey = new StrongNameKey(....);
var signaturePubKey = new StrongNamePublicKey(....);
// Create module writer options
var opts = new ModuleWriterOptions(mod);
// This method will initialize the required properties
opts.InitializeEnhancedStrongNameSigning(mod, signatureKey, signaturePubKey);
// Write and strong name sign the assembly
mod.Write(@"C:\out\file.dll", opts);
```
Enhanced strong name signing with key migration:
```csharp
using dnlib.DotNet.Writer;
...
// Open or create an assembly
ModuleDef mod = ModuleDefMD.Load(....);
// Open or create the identity and signature keys
var signatureKey = new StrongNameKey(....);
var signaturePubKey = new StrongNamePublicKey(....);
var identityKey = new StrongNameKey(....);
var identityPubKey = new StrongNamePublicKey(....);
// Create module writer options
var opts = new ModuleWriterOptions(mod);
// This method will initialize the required properties and add
// the required attribute to the assembly.
opts.InitializeEnhancedStrongNameSigning(mod, signatureKey, signaturePubKey, identityKey, identityPubKey);
// Write and strong name sign the assembly
mod.Write(@"C:\out\file.dll", opts);
```
Exporting managed methods (DllExport)
-------------------------------------
dnlib supports exporting managed methods so the managed DLL file can be loaded by native code and then executed. .NET Framework supports this feature, but there's no guarantee that other CLRs (eg. .NET Core or Mono/Unity) support this feature.
The `MethodDef` class has an `ExportInfo` property. If it gets initialized, the method gets exported when saving the module. At most 65536 (2^16) methods can be exported. This is a PE file limitation, not a dnlib limitation.
Exported methods should not be generic.
The method's calling convention should be changed to eg. stdcall, or cdecl, by adding an optional modifier to `MethodDef.MethodSig.RetType`. It must be a `System.Runtime.CompilerServices.CallConvCdecl`, `System.Runtime.CompilerServices.CallConvStdcall`, `System.Runtime.CompilerServices.CallConvThiscall`, or a `System.Runtime.CompilerServices.CallConvFastcall`, eg.:
```C#
var type = method.MethodSig.RetType;
type = new CModOptSig(module.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "CallConvCdecl"), type);
method.MethodSig.RetType = type;
```
Requirements:
- The assembly platform must be x86, x64, IA-64 or ARM (ARM64 isn't supported at the moment). AnyCPU assemblies are not supported. This is as simple as changing (if needed) `ModuleWriterOptions.PEHeadersOptions.Machine` when saving the file. x86 files should set `32-bit required` flag and clear `32-bit preferred` flag in the COR20 header.
- It must be a DLL file (see `ModuleWriterOptions.PEHeadersOptions.Characteristics`). The file will fail to load at runtime if it's an EXE file.
Type classes
------------
The metadata has three type tables: `TypeRef`, `TypeDef`, and `TypeSpec`. The
classes dnlib use are called the same. These three classes all implement
`ITypeDefOrRef`.
There's also type signature classes. The base class is `TypeSig`. You'll find
`TypeSig`s in method signatures (return type and parameter types) and locals.
The `TypeSpec` class also has a `TypeSig` property.
All of these types implement `IType`.
`TypeRef` is a reference to a type in (usually) another assembly.
`TypeDef` is a type definition and it's a type defined in some module. This
class does *not* derive from `TypeRef`. :)
`TypeSpec` can be a generic type, an array type, etc.
`TypeSig` is the base class of all type signatures (found in method sigs and
locals). It has a `Next` property that points to the next `TypeSig`. Eg. a
Byte[] would first contain a `SZArraySig`, and its `Next` property would point
to Byte signature.
`CorLibTypeSig` is a simple corlib type. You don't create these directly. Use
eg. `module.CorLibTypes.Int32` to get a System.Int32 type signature.
`ValueTypeSig` is used when the next class is a value type.
`ClassSig` is used when the next class is a reference type.
`GenericInstSig` is a generic instance type. It has a reference to the generic
type (a `TypeDef` or a `TypeRef`) and the generic arguments.
`PtrSig` is a pointer sig.
`ByRefSig` is a by reference type.
`ArraySig` is a multi-dimensional array type. Most likely when you create an
array, you should use `SZArraySig`, and *not* `ArraySig`.
`SZArraySig` is a single dimension, zero lower bound array. In C#, a `byte[]`
is a `SZArraySig`, and *not* an `ArraySig`.
`GenericVar` is a generic type variable.
`GenericMVar` is a generic method variable.
Some examples if you're not used to the way type signatures are represented
in metadata:
```csharp
ModuleDef mod = ....;
// Create a byte[]
SZArraySig array1 = new SZArraySig(mod.CorLibTypes.Byte);
// Create an int[][]
SZArraySig array2 = new SZArraySig(new SZArraySig(mod.CorLibTypes.Int32));
// Create an int[,]
ArraySig array3 = new ArraySig(mod.CorLibTypes.Int32, 2);
// Create an int[*] (one-dimensional array)
ArraySig array4 = new ArraySig(mod.CorLibTypes.Int32, 1);
// Create a Stream[]. Stream is a reference class so it must be enclosed in a ClassSig.
// If it were a value type, you would use ValueTypeSig instead.
TypeRef stream = new TypeRefUser(mod, "System.IO", "Stream", mod.CorLibTypes.AssemblyRef);
SZArraySig array5 = new SZArraySig(new ClassSig(stream));
```
Sometimes you must convert an `ITypeDefOrRef` (`TypeRef`, `TypeDef`, or
`TypeSpec`) to/from a `TypeSig`. There's extension methods you can use:
```csharp
// array5 is defined above
ITypeDefOrRef type1 = array5.ToTypeDefOrRef();
TypeSig type2 = type1.ToTypeSig();
```
Naming conventions of metadata table classes
--------------------------------------------
For most tables in the metadata, there's a corresponding dnlib class with the
exact same or a similar name. Eg. the metadata has a `TypeDef` table, and dnlib
has a `TypeDef` class. Some tables don't have a class because they're
referenced by other classes, and that information is part of some other class.
Eg. the `TypeDef` class contains all its properties and events, even though the
`TypeDef` table has no property or event column.
For each of these table classes, there's an abstract base class, and two sub
classes. These sub classes are named the same as the base class but ends in
either `MD` (for classes created from the metadata) or `User` (for classes
created by the user). Eg. `TypeDef` is the base class, and it has two sub
classes `TypeDefMD` which is auto-created from metadata, and `TypeRefUser`
which is created by the user when adding user types. Most of the XyzMD classes
are internal and can't be referenced directly by the user. They're created by
`ModuleDefMD` (which is the only public `MD` class). All XyzUser classes are
public.
Metadata table classes
----------------------
Here's a list of the most common metadata table classes
`AssemblyDef` is the assembly class.
`AssemblyRef` is an assembly reference.
`EventDef` is an event definition. Owned by a `TypeDef`.
`FieldDef` is a field definition. Owned by a `TypeDef`.
`GenericParam` is a generic parameter (owned by a `MethodDef` or a `TypeDef`)
`MemberRef` is what you create if you need a field reference or a method
reference.
`MethodDef` is a method definition. It usually has a `CilBody` with CIL
instructions. Owned by a `TypeDef`.
`MethodSpec` is a instantiated generic method.
`ModuleDef` is the base module class. When you read an existing module, a
`ModuleDefMD` is created.
`ModuleRef` is a module reference.
`PropertyDef` is a property definition. Owned by a `TypeDef`.
`TypeDef` is a type definition. It contains a lot of interesting stuff,
including methods, fields, properties, etc.
`TypeRef` is a type reference. Usually to a type in another assembly.
`TypeSpec` is a type specification, eg. an array, generic type, etc.
Method classes
--------------
The following are the method classes: `MethodDef`, `MemberRef` (method ref) and
`MethodSpec`. They all implement `IMethod`.
Field classes
-------------
The following are the field classes: `FieldDef` and `MemberRef` (field ref).
They both implement `IField`.
Comparing types, methods, fields, etc
-------------------------------------
dnlib has a `SigComparer` class that can compare any type with any other type.
Any method with any other method, etc. It also has several pre-created
`IEqualityComparer` classes (eg. `TypeEqualityComparer`,
`FieldEqualityComparer`, etc) which you can use if you intend to eg. use a type
as a key in a `Dictionary`.
The `SigComparer` class can also compare types with `System.Type`, methods with
`System.Reflection.MethodBase`, etc.
It has many options you can set, see `SigComparerOptions`. The default options
is usually good enough, though.
```csharp
// Compare two types
TypeRef type1 = ...;
TypeDef type2 = ...;
if (new SigComparer().Equals(type1, type2))
Console.WriteLine("They're equal");
// Use the type equality comparer
Dictionary dict = new Dictionary(TypeEqualityComparer.Instance);
TypeDef type1 = ...;
dict.Add(type1, 10);
// Compare a `TypeRef` with a `System.Type`
TypeRef type1 = ...;
if (new SigComparer().Equals(type1, typeof(int)))
Console.WriteLine("They're equal");
```
It has many `Equals()` and `GetHashCode()` overloads.
.NET Resources
--------------
There's three types of .NET resource, and they all derive from the common base
class `Resource`. `ModuleDef.Resources` is a list of all resources the module
owns.
`EmbeddedResource` is a resource that has data embedded in the owner module.
This is the most common type of resource and it's probably what you want.
`AssemblyLinkedResource` is a reference to a resource in another assembly.
`LinkedResource` is a reference to a resource on disk.
Win32 resources
---------------
`ModuleDef.Win32Resources` can be null or a `Win32Resources` instance. You can
add/remove any Win32 resource blob. dnlib doesn't try to parse these blobs.
Parsing method bodies
---------------------
This is usually only needed if you have decrypted a method body. If it's a
standard method body, you can use `MethodBodyReader.Create()`. If it's similar
to a standard method body, you can derive a class from `MethodBodyReaderBase`
and override the necessary methods.
Resolving references
--------------------
`TypeRef.Resolve()` and `MemberRef.Resolve()` both use
`module.Context.Resolver` to resolve the type, field or method. The custom
attribute parser code may also resolve type references.
If you call Resolve() or read custom attributes, you should initialize
module.Context to a `ModuleContext`. It should normally be shared between all
modules you open.
```csharp
AssemblyResolver asmResolver = new AssemblyResolver();
ModuleContext modCtx = new ModuleContext(asmResolver);
// All resolved assemblies will also get this same modCtx
asmResolver.DefaultModuleContext = modCtx;
// Enable the TypeDef cache for all assemblies that are loaded
// by the assembly resolver. Only enable it if all auto-loaded
// assemblies are read-only.
asmResolver.EnableTypeDefCache = true;
```
All assemblies that you yourself open should be added to the assembly resolver
cache.
```csharp
ModuleDefMD mod = ModuleDefMD.Load(...);
mod.Context = modCtx; // Use the previously created (and shared) context
mod.Context.AssemblyResolver.AddToCache(mod);
```
Resolving types, methods, etc from metadata tokens
--------------------------------------------------
`ModuleDefMD` has several `ResolveXXX()` methods, eg. `ResolveTypeDef()`,
`ResolveMethod()`, etc.
Creating mscorlib type references
---------------------------------
Every module has a `CorLibTypes` property. It has references to a few of the
simplest types such as all integer types, floating point types, Object, String,
etc. If you need a type that's not there, you must create it yourself, eg.:
```csharp
TypeRef consoleRef = new TypeRefUser(mod, "System", "Console", mod.CorLibTypes.AssemblyRef);
```
Importing runtime types, methods, fields
----------------------------------------
To import a `System.Type`, `System.Reflection.MethodInfo`,
`System.Reflection.FieldInfo`, etc into a module, use the `Importer` class.
```csharp
Importer importer = new Importer(mod);
ITypeDefOrRef consoleRef = importer.Import(typeof(System.Console));
IMethod writeLine = importer.Import(typeof(System.Console).GetMethod("WriteLine"));
```
You can also use it to import types, methods etc from another `ModuleDef`.
All imported types, methods etc will be references to the original assembly.
I.e., it won't add the imported `TypeDef` to the target module. It will just
create a `TypeRef` to it.
Using decrypted methods
-----------------------
If `ModuleDefMD.MethodDecrypter` is initialized, `ModuleDefMD` will call it and
check whether the method has been decrypted. If it has, it calls
`IMethodDecrypter.GetMethodBody()` which you should implement. Return the new
`MethodBody`. `GetMethodBody()` should usually call `MethodBodyReader.Create()`
which does the actual parsing of the CIL code.
It's also possible to override `ModuleDefMD.ReadUserString()`. This method is
called by the CIL parser when it finds a `Ldstr` instruction. If
`ModuleDefMD.StringDecrypter` is not null, its `ReadUserString()` method is
called with the string token. Return the decrypted string or null if it should
be read from the `#US` heap.
Low level access to the metadata
--------------------------------
The low level classes are in the `dnlib.DotNet.MD` namespace.
Open an existing .NET module/assembly and you get a ModuleDefMD. It has several
properties, eg. `StringsStream` is the #Strings stream.
The `MetaData` property gives you full access to the metadata.
To get a list of all valid TypeDef rids (row IDs), use this code:
```csharp
using dnlib.DotNet.MD;
// ...
ModuleDefMD mod = ModuleDefMD.Load(...);
RidList typeDefRids = mod.MetaData.GetTypeDefRidList();
for (int i = 0; i < typeDefRids.Count; i++)
Console.WriteLine("rid: {0}", typeDefRids[i]);
```
You don't need to create a `ModuleDefMD`, though. See `DotNetFile`.
dnlib-2.1_VS2010/dnlib.netstandard.sln 0000664 0000000 0000000 00000002160 13250336635 0017500 0 ustar 00root root 0000000 0000000
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.27130.2010
MinimumVisualStudioVersion = 10.0.40219.1
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "dnlib.netstandard", "src\dnlib.netstandard.csproj", "{80695BC3-65CA-403E-B161-57D4F6EC5CC3}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{80695BC3-65CA-403E-B161-57D4F6EC5CC3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{80695BC3-65CA-403E-B161-57D4F6EC5CC3}.Debug|Any CPU.Build.0 = Debug|Any CPU
{80695BC3-65CA-403E-B161-57D4F6EC5CC3}.Release|Any CPU.ActiveCfg = Release|Any CPU
{80695BC3-65CA-403E-B161-57D4F6EC5CC3}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {DA3B4267-5AB5-4A1D-A0D5-CF49A2882567}
EndGlobalSection
EndGlobal
dnlib-2.1_VS2010/dnlib.sln 0000664 0000000 0000000 00000004751 13250336635 0015202 0 ustar 00root root 0000000 0000000
Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "dnlib", "src\dnlib.csproj", "{FDFC1237-143F-4919-8318-4926901F4639}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Examples", "Examples\Examples.csproj", "{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|Mixed Platforms = Debug|Mixed Platforms
Debug|x86 = Debug|x86
Release|Any CPU = Release|Any CPU
Release|Mixed Platforms = Release|Mixed Platforms
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Any CPU.Build.0 = Debug|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Debug|x86.ActiveCfg = Debug|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Release|Any CPU.ActiveCfg = Release|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Release|Any CPU.Build.0 = Release|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{FDFC1237-143F-4919-8318-4926901F4639}.Release|x86.ActiveCfg = Release|Any CPU
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Debug|Any CPU.ActiveCfg = Debug|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Debug|Mixed Platforms.Build.0 = Debug|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Debug|x86.ActiveCfg = Debug|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Debug|x86.Build.0 = Debug|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Release|Any CPU.ActiveCfg = Release|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Release|Mixed Platforms.ActiveCfg = Release|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Release|Mixed Platforms.Build.0 = Release|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Release|x86.ActiveCfg = Release|x86
{F27E72B5-C4BD-40BF-AD19-4C8A99B55872}.Release|x86.Build.0 = Release|x86
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
dnlib-2.1_VS2010/dnlib.snk 0000664 0000000 0000000 00000001124 13250336635 0015170 0 ustar 00root root 0000000 0000000 $ RSA2 ++Lb*<7wL9z#`B?t'bu>Hs '{,ltmNYkKY(|NUؑڨ GRbh |2393D*{#W⧤v} *kUnFpCgYE uVx5Z&6J8N@g(DO d3k
˛(8&5S\
G4 ~8ݕݺbz>P~$ޝ! 5fg"M<ߩj3- ^`y8H243pֆl]y1F6 C;9UѬh
4uޱ!ھ"X*\XdX*ѓCjBYb!Vd/ceBrj(;9f Y?꛴ފ.H=EՒM9'_SԷL&Q-QHב{*ؑPT;< 4}e 丒!(w+~oΎQBc%3SP.Nto@| @iQl+꾡4b 3YE dnlib-2.1_VS2010/src/ 0000775 0000000 0000000 00000000000 13250336635 0014154 5 ustar 00root root 0000000 0000000 dnlib-2.1_VS2010/src/DotNet/ 0000775 0000000 0000000 00000000000 13250336635 0015351 5 ustar 00root root 0000000 0000000 dnlib-2.1_VS2010/src/DotNet/AllTypesHelper.cs 0000664 0000000 0000000 00000002023 13250336635 0020572 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System.Collections.Generic;
using dnlib.Threading;
namespace dnlib.DotNet {
///
/// Returns types without getting stuck in an infinite loop
///
public struct AllTypesHelper {
///
/// Gets a list of all types and nested types
///
/// A list of types
public static IEnumerable Types(IEnumerable types) {
var visited = new Dictionary();
var stack = new Stack>();
if (types != null)
stack.Push(types.GetSafeEnumerable().GetEnumerator());
while (stack.Count > 0) {
var enumerator = stack.Pop();
while (enumerator.MoveNext()) {
var type = enumerator.Current;
if (visited.ContainsKey(type))
continue;
visited[type] = true;
yield return type;
if (type.NestedTypes.Count > 0) {
stack.Push(enumerator);
enumerator = type.NestedTypes.GetSafeEnumerable().GetEnumerator();
}
}
}
}
}
}
dnlib-2.1_VS2010/src/DotNet/AssemblyAttributes.cs 0000664 0000000 0000000 00000003741 13250336635 0021533 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
namespace dnlib.DotNet {
///
/// Assembly flags from Assembly.Flags column.
///
/// See CorHdr.h/CorAssemblyFlags
[Flags]
public enum AssemblyAttributes : uint {
/// No flags set
None = 0,
/// The assembly ref holds the full (unhashed) public key.
PublicKey = 1,
/// Processor Architecture unspecified
PA_None = 0x0000,
/// Processor Architecture: neutral (PE32)
PA_MSIL = 0x0010,
/// Processor Architecture: x86 (PE32)
PA_x86 = 0x0020,
/// Processor Architecture: Itanium (PE32+)
PA_IA64 = 0x0030,
/// Processor Architecture: AMD X64 (PE32+)
PA_AMD64 = 0x0040,
/// Processor Architecture: ARM (PE32)
PA_ARM = 0x0050,
/// applies to any platform but cannot run on any (e.g. reference assembly), should not have "specified" set
PA_NoPlatform = 0x0070,
/// Propagate PA flags to AssemblyRef record
PA_Specified = 0x0080,
/// Bits describing the processor architecture
PA_Mask = 0x0070,
/// Bits describing the PA incl. Specified
PA_FullMask = 0x00F0,
/// NOT A FLAG, shift count in PA flags <--> index conversion
PA_Shift = 0x0004,
/// From "DebuggableAttribute".
EnableJITcompileTracking = 0x8000,
/// From "DebuggableAttribute".
DisableJITcompileOptimizer = 0x4000,
/// The assembly can be retargeted (at runtime) to an assembly from a different publisher.
Retargetable = 0x0100,
///
ContentType_Default = 0x0000,
///
ContentType_WindowsRuntime = 0x0200,
/// Bits describing ContentType
ContentType_Mask = 0x0E00,
}
}
dnlib-2.1_VS2010/src/DotNet/AssemblyDef.cs 0000664 0000000 0000000 00000116722 13250336635 0020107 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.IO;
using System.Reflection;
using System.Threading;
using dnlib.Utils;
using dnlib.DotNet.MD;
using dnlib.DotNet.Writer;
using dnlib.Threading;
using System.Text.RegularExpressions;
using dnlib.DotNet.Pdb;
#if THREAD_SAFE
using ThreadSafe = dnlib.Threading.Collections;
#else
using ThreadSafe = System.Collections.Generic;
#endif
namespace dnlib.DotNet {
///
/// A high-level representation of a row in the Assembly table
///
public abstract class AssemblyDef : IHasCustomAttribute, IHasDeclSecurity, IHasCustomDebugInformation, IAssembly, IListListener, ITypeDefFinder, IDnlibDef {
///
/// The row id in its table
///
protected uint rid;
///
public MDToken MDToken {
get { return new MDToken(Table.Assembly, rid); }
}
///
public uint Rid {
get { return rid; }
set { rid = value; }
}
///
public int HasCustomAttributeTag {
get { return 14; }
}
///
public int HasDeclSecurityTag {
get { return 2; }
}
///
/// From column Assembly.HashAlgId
///
public AssemblyHashAlgorithm HashAlgorithm {
get { return hashAlgorithm; }
set { hashAlgorithm = value; }
}
///
protected AssemblyHashAlgorithm hashAlgorithm;
///
/// From columns Assembly.MajorVersion, Assembly.MinorVersion, Assembly.BuildNumber,
/// Assembly.RevisionNumber.
///
/// If is null
public Version Version {
get { return version; }
set {
if (value == null)
throw new ArgumentNullException("value");
version = value;
}
}
///
protected Version version;
///
/// From column Assembly.Flags
///
public AssemblyAttributes Attributes {
get { return (AssemblyAttributes)attributes; }
set { attributes = (int)value; }
}
/// Attributes
protected int attributes;
///
/// From column Assembly.PublicKey
///
/// An empty is created if the caller writes null
public PublicKey PublicKey {
get { return publicKey; }
set { publicKey = value ?? new PublicKey(); }
}
///
protected PublicKey publicKey;
///
/// Gets the public key token which is calculated from
///
public PublicKeyToken PublicKeyToken {
get { return publicKey.Token; }
}
///
/// From column Assembly.Name
///
public UTF8String Name {
get { return name; }
set { name = value; }
}
/// Name
protected UTF8String name;
///
/// From column Assembly.Locale
///
public UTF8String Culture {
get { return culture; }
set { culture = value; }
}
/// Name
protected UTF8String culture;
///
public ThreadSafe.IList DeclSecurities {
get {
if (declSecurities == null)
InitializeDeclSecurities();
return declSecurities;
}
}
///
protected ThreadSafe.IList declSecurities;
/// Initializes
protected virtual void InitializeDeclSecurities() {
Interlocked.CompareExchange(ref declSecurities, ThreadSafeListCreator.Create(), null);
}
///
public PublicKeyBase PublicKeyOrToken {
get { return publicKey; }
}
///
public string FullName {
get { return GetFullNameWithPublicKeyToken(); }
}
///
public string FullNameToken {
get { return GetFullNameWithPublicKeyToken(); }
}
///
/// Gets all modules. The first module is always the .
///
public ThreadSafe.IList Modules {
get {
if (modules == null)
InitializeModules();
return modules;
}
}
///
protected LazyList modules;
/// Initializes
protected virtual void InitializeModules() {
Interlocked.CompareExchange(ref modules, new LazyList(this), null);
}
///
/// Gets all custom attributes
///
public CustomAttributeCollection CustomAttributes {
get {
if (customAttributes == null)
InitializeCustomAttributes();
return customAttributes;
}
}
///
protected CustomAttributeCollection customAttributes;
/// Initializes
protected virtual void InitializeCustomAttributes() {
Interlocked.CompareExchange(ref customAttributes, new CustomAttributeCollection(), null);
}
///
public bool HasCustomAttributes {
get { return CustomAttributes.Count > 0; }
}
///
public int HasCustomDebugInformationTag {
get { return 14; }
}
///
public bool HasCustomDebugInfos {
get { return CustomDebugInfos.Count > 0; }
}
///
/// Gets all custom debug infos
///
public ThreadSafe.IList CustomDebugInfos {
get {
if (customDebugInfos == null)
InitializeCustomDebugInfos();
return customDebugInfos;
}
}
///
protected ThreadSafe.IList customDebugInfos;
/// Initializes
protected virtual void InitializeCustomDebugInfos() {
Interlocked.CompareExchange(ref customDebugInfos, ThreadSafeListCreator.Create(), null);
}
///
public bool HasDeclSecurities {
get { return DeclSecurities.Count > 0; }
}
///
/// true if is not empty
///
public bool HasModules {
get { return Modules.Count > 0; }
}
///
/// Gets the manifest (main) module. This is always the first module in .
/// null is returned if is empty.
///
public ModuleDef ManifestModule {
get { return Modules.Get(0, null); }
}
///
/// Modify property: =
/// ( & ) | .
///
/// Value to AND
/// Value to OR
void ModifyAttributes(AssemblyAttributes andMask, AssemblyAttributes orMask) {
#if THREAD_SAFE
int origVal, newVal;
do {
origVal = attributes;
newVal = (origVal & (int)andMask) | (int)orMask;
} while (Interlocked.CompareExchange(ref attributes, newVal, origVal) != origVal);
#else
attributes = (attributes & (int)andMask) | (int)orMask;
#endif
}
///
/// Set or clear flags in
///
/// true if flags should be set, false if flags should
/// be cleared
/// Flags to set or clear
void ModifyAttributes(bool set, AssemblyAttributes flags) {
#if THREAD_SAFE
int origVal, newVal;
do {
origVal = attributes;
if (set)
newVal = origVal | (int)flags;
else
newVal = origVal & ~(int)flags;
} while (Interlocked.CompareExchange(ref attributes, newVal, origVal) != origVal);
#else
if (set)
attributes |= (int)flags;
else
attributes &= ~(int)flags;
#endif
}
///
/// Gets/sets the bit
///
public bool HasPublicKey {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PublicKey) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.PublicKey); }
}
///
/// Gets/sets the processor architecture
///
public AssemblyAttributes ProcessorArchitecture {
get { return (AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask; }
set { ModifyAttributes(~AssemblyAttributes.PA_Mask, value & AssemblyAttributes.PA_Mask); }
}
///
/// Gets/sets the processor architecture
///
public AssemblyAttributes ProcessorArchitectureFull {
get { return (AssemblyAttributes)attributes & AssemblyAttributes.PA_FullMask; }
set { ModifyAttributes(~AssemblyAttributes.PA_FullMask, value & AssemblyAttributes.PA_FullMask); }
}
///
/// true if unspecified processor architecture
///
public bool IsProcessorArchitectureNone {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_None; }
}
///
/// true if neutral (PE32) architecture
///
public bool IsProcessorArchitectureMSIL {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_MSIL; }
}
///
/// true if x86 (PE32) architecture
///
public bool IsProcessorArchitectureX86 {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_x86; }
}
///
/// true if IA-64 (PE32+) architecture
///
public bool IsProcessorArchitectureIA64 {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_IA64; }
}
///
/// true if x64 (PE32+) architecture
///
public bool IsProcessorArchitectureX64 {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_AMD64; }
}
///
/// true if ARM (PE32) architecture
///
public bool IsProcessorArchitectureARM {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_ARM; }
}
///
/// true if eg. reference assembly (not runnable)
///
public bool IsProcessorArchitectureNoPlatform {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_NoPlatform; }
}
///
/// Gets/sets the bit
///
public bool IsProcessorArchitectureSpecified {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Specified) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.PA_Specified); }
}
///
/// Gets/sets the bit
///
public bool EnableJITcompileTracking {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.EnableJITcompileTracking) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.EnableJITcompileTracking); }
}
///
/// Gets/sets the bit
///
public bool DisableJITcompileOptimizer {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.DisableJITcompileOptimizer) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.DisableJITcompileOptimizer); }
}
///
/// Gets/sets the bit
///
public bool IsRetargetable {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.Retargetable) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.Retargetable); }
}
///
/// Gets/sets the content type
///
public AssemblyAttributes ContentType {
get { return (AssemblyAttributes)attributes & AssemblyAttributes.ContentType_Mask; }
set { ModifyAttributes(~AssemblyAttributes.ContentType_Mask, value & AssemblyAttributes.ContentType_Mask); }
}
///
/// true if content type is Default
///
public bool IsContentTypeDefault {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_Default; }
}
///
/// true if content type is WindowsRuntime
///
public bool IsContentTypeWindowsRuntime {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_WindowsRuntime; }
}
///
/// Finds a module in this assembly
///
/// Name of module
/// A instance or null if it wasn't found.
public ModuleDef FindModule(UTF8String name) {
foreach (var module in Modules.GetSafeEnumerable()) {
if (module == null)
continue;
if (UTF8String.CaseInsensitiveEquals(module.Name, name))
return module;
}
return null;
}
///
/// Creates an instance from a file
///
/// File name of an existing .NET assembly
/// Module context or null
/// A new instance
/// If is null
/// If it's not a .NET assembly (eg. not a .NET file or only a .NET module)
public static AssemblyDef Load(string fileName, ModuleContext context) {
return Load(fileName, new ModuleCreationOptions(context));
}
///
/// Creates an instance from a file
///
/// File name of an existing .NET assembly
/// Module creation options or null
/// A new instance
/// If is null
/// If it's not a .NET assembly (eg. not a .NET file or only a .NET module)
public static AssemblyDef Load(string fileName, ModuleCreationOptions options = null) {
if (fileName == null)
throw new ArgumentNullException("fileName");
ModuleDef module = null;
try {
module = ModuleDefMD.Load(fileName, options);
var asm = module.Assembly;
if (asm == null)
throw new BadImageFormatException(string.Format("{0} is only a .NET module, not a .NET assembly. Use ModuleDef.Load().", fileName));
return asm;
}
catch {
if (module != null)
module.Dispose();
throw;
}
}
///
/// Creates an instance from a byte[]
///
/// Contents of a .NET assembly
/// Module context or null
/// A new instance
/// If is null
/// If it's not a .NET assembly (eg. not a .NET file or only a .NET module)
public static AssemblyDef Load(byte[] data, ModuleContext context) {
return Load(data, new ModuleCreationOptions(context));
}
///
/// Creates an instance from a byte[]
///
/// Contents of a .NET assembly
/// Module creation options or null
/// A new instance
/// If is null
/// If it's not a .NET assembly (eg. not a .NET file or only a .NET module)
public static AssemblyDef Load(byte[] data, ModuleCreationOptions options = null) {
if (data == null)
throw new ArgumentNullException("data");
ModuleDef module = null;
try {
module = ModuleDefMD.Load(data, options);
var asm = module.Assembly;
if (asm == null)
throw new BadImageFormatException(string.Format("{0} is only a .NET module, not a .NET assembly. Use ModuleDef.Load().", module.ToString()));
return asm;
}
catch {
if (module != null)
module.Dispose();
throw;
}
}
///
/// Creates an instance from a memory location
///
/// Address of a .NET assembly
/// Module context or null
/// A new instance
/// If is null
/// If it's not a .NET assembly (eg. not a .NET file or only a .NET module)
public static AssemblyDef Load(IntPtr addr, ModuleContext context) {
return Load(addr, new ModuleCreationOptions(context));
}
///
/// Creates an instance from a memory location
///
/// Address of a .NET assembly
/// Module creation options or null
/// A new instance
/// If is null
/// If it's not a .NET assembly (eg. not a .NET file or only a .NET module)
public static AssemblyDef Load(IntPtr addr, ModuleCreationOptions options = null) {
if (addr == IntPtr.Zero)
throw new ArgumentNullException("addr");
ModuleDef module = null;
try {
module = ModuleDefMD.Load(addr, options);
var asm = module.Assembly;
if (asm == null)
throw new BadImageFormatException(string.Format("{0} (addr: {1:X8}) is only a .NET module, not a .NET assembly. Use ModuleDef.Load().", module.ToString(), addr.ToInt64()));
return asm;
}
catch {
if (module != null)
module.Dispose();
throw;
}
}
///
/// Creates an instance from a stream
///
/// This will read all bytes from the stream and call .
/// It's better to use one of the other Load() methods.
/// The stream
/// Module context or null
/// A new instance
/// If is null
/// If it's not a .NET assembly (eg. not a .NET file or only a .NET module)
public static AssemblyDef Load(Stream stream, ModuleContext context) {
return Load(stream, new ModuleCreationOptions(context));
}
///
/// Creates an instance from a stream
///
/// This will read all bytes from the stream and call .
/// It's better to use one of the other Load() methods.
/// The stream
/// Module creation options or null
/// A new instance
/// If is null
/// If it's not a .NET assembly (eg. not a .NET file or only a .NET module)
public static AssemblyDef Load(Stream stream, ModuleCreationOptions options = null) {
if (stream == null)
throw new ArgumentNullException("stream");
ModuleDef module = null;
try {
module = ModuleDefMD.Load(stream, options);
var asm = module.Assembly;
if (asm == null)
throw new BadImageFormatException(string.Format("{0} is only a .NET module, not a .NET assembly. Use ModuleDef.Load().", module.ToString()));
return asm;
}
catch {
if (module != null)
module.Dispose();
throw;
}
}
///
/// Gets the assembly name with the public key
///
public string GetFullNameWithPublicKey() {
return GetFullName(publicKey);
}
///
/// Gets the assembly name with the public key token
///
public string GetFullNameWithPublicKeyToken() {
return GetFullName(publicKey.Token);
}
string GetFullName(PublicKeyBase pkBase) {
return Utils.GetAssemblyNameString(name, version, culture, pkBase, Attributes);
}
///
/// Finds a . For speed, enable
/// if possible (read the documentation first).
///
/// Full name of the type (no assembly information)
/// true if it's a reflection name, and nested
/// type names are separated by a + character. If false, nested type names
/// are separated by a / character.
/// An existing or null if it wasn't found.
public TypeDef Find(string fullName, bool isReflectionName) {
foreach (var module in Modules.GetSafeEnumerable()) {
if (module == null)
continue;
var type = module.Find(fullName, isReflectionName);
if (type != null)
return type;
}
return null;
}
///
/// Finds a . Its scope (i.e., module or assembly) is ignored when
/// looking up the type. For speed, enable
/// if possible (read the documentation first).
///
/// The type ref
/// An existing or null if it wasn't found.
public TypeDef Find(TypeRef typeRef) {
foreach (var module in Modules.GetSafeEnumerable()) {
if (module == null)
continue;
var type = module.Find(typeRef);
if (type != null)
return type;
}
return null;
}
///
/// Writes the assembly to a file on disk. If the file exists, it will be truncated.
///
/// Filename
/// Writer options
public void Write(string filename, ModuleWriterOptions options = null) {
ManifestModule.Write(filename, options);
}
///
/// Writes the assembly to a stream.
///
/// Destination stream
/// Writer options
public void Write(Stream dest, ModuleWriterOptions options = null) {
ManifestModule.Write(dest, options);
}
///
/// Checks whether this assembly is a friend assembly of
///
/// Target assembly
public bool IsFriendAssemblyOf(AssemblyDef targetAsm) {
if (targetAsm == null)
return false;
if (this == targetAsm)
return true;
// Both must be unsigned or both must be signed according to the
// InternalsVisibleToAttribute documentation.
if (PublicKeyBase.IsNullOrEmpty2(publicKey) != PublicKeyBase.IsNullOrEmpty2(targetAsm.PublicKey))
return false;
foreach (var ca in targetAsm.CustomAttributes.FindAll("System.Runtime.CompilerServices.InternalsVisibleToAttribute")) {
if (ca.ConstructorArguments.Count != 1)
continue;
var arg = ca.ConstructorArguments.Get(0, default(CAArgument));
if (arg.Type.GetElementType() != ElementType.String)
continue;
var asmName = arg.Value as UTF8String;
if (UTF8String.IsNull(asmName))
continue;
var asmInfo = new AssemblyNameInfo(asmName);
if (asmInfo.Name != name)
continue;
if (!PublicKeyBase.IsNullOrEmpty2(publicKey)) {
if (!PublicKey.Equals(asmInfo.PublicKeyOrToken as PublicKey))
continue;
}
else if (!PublicKeyBase.IsNullOrEmpty2(asmInfo.PublicKeyOrToken))
continue;
return true;
}
return false;
}
///
/// Adds or updates an existing System.Reflection.AssemblySignatureKeyAttribute
/// attribute. This attribute is used in enhanced strong naming with key migration.
/// See http://msdn.microsoft.com/en-us/library/hh415055.aspx
///
/// Identity public key
/// Identity strong name key pair
/// Signature public key
public void UpdateOrCreateAssemblySignatureKeyAttribute(StrongNamePublicKey identityPubKey, StrongNameKey identityKey, StrongNamePublicKey signaturePubKey) {
var manifestModule = ManifestModule;
if (manifestModule == null)
return;
// Remove all existing attributes
var ca = CustomAttributes.ExecuteLocked(null, (tsList, arg) => {
CustomAttribute foundCa = null;
for (int i = 0; i < tsList.Count_NoLock(); i++) {
var caTmp = tsList.Get_NoLock(i);
if (caTmp.TypeFullName != "System.Reflection.AssemblySignatureKeyAttribute")
continue;
tsList.RemoveAt_NoLock(i);
i--;
if (foundCa == null)
foundCa = caTmp;
}
return foundCa;
});
if (IsValidAssemblySignatureKeyAttribute(ca))
ca.NamedArguments.Clear();
else
ca = CreateAssemblySignatureKeyAttribute();
var counterSig = StrongNameKey.CreateCounterSignatureAsString(identityPubKey, identityKey, signaturePubKey);
ca.ConstructorArguments[0] = new CAArgument(manifestModule.CorLibTypes.String, new UTF8String(signaturePubKey.ToString()));
ca.ConstructorArguments[1] = new CAArgument(manifestModule.CorLibTypes.String, new UTF8String(counterSig));
CustomAttributes.Add(ca);
}
bool IsValidAssemblySignatureKeyAttribute(CustomAttribute ca) {
#if THREAD_SAFE
return false;
#else
if (ca == null)
return false;
var ctor = ca.Constructor;
if (ctor == null)
return false;
var sig = ctor.MethodSig;
if (sig == null || sig.Params.Count != 2)
return false;
if (sig.Params[0].GetElementType() != ElementType.String)
return false;
if (sig.Params[1].GetElementType() != ElementType.String)
return false;
if (ca.ConstructorArguments.Count != 2)
return false;
return true;
#endif
}
CustomAttribute CreateAssemblySignatureKeyAttribute() {
var manifestModule = ManifestModule;
var owner = manifestModule.UpdateRowId(new TypeRefUser(manifestModule, "System.Reflection", "AssemblySignatureKeyAttribute", manifestModule.CorLibTypes.AssemblyRef));
var methodSig = MethodSig.CreateInstance(manifestModule.CorLibTypes.Void, manifestModule.CorLibTypes.String, manifestModule.CorLibTypes.String);
var ctor = manifestModule.UpdateRowId(new MemberRefUser(manifestModule, MethodDef.InstanceConstructorName, methodSig, owner));
var ca = new CustomAttribute(ctor);
ca.ConstructorArguments.Add(new CAArgument(manifestModule.CorLibTypes.String, UTF8String.Empty));
ca.ConstructorArguments.Add(new CAArgument(manifestModule.CorLibTypes.String, UTF8String.Empty));
return ca;
}
///
/// Gets the original System.Runtime.Versioning.TargetFrameworkAttribute custom attribute information if possible.
/// It reads this from the original metadata and doesn't use .
/// Returns false if the custom attribute isn't present or if it is invalid.
///
/// Framework name
/// Version
/// Profile
///
public virtual bool TryGetOriginalTargetFrameworkAttribute(out string framework, out Version version, out string profile) {
framework = null;
version = null;
profile = null;
return false;
}
///
void IListListener.OnLazyAdd(int index, ref ModuleDef module) {
if (module == null)
return;
#if DEBUG
if (module.Assembly == null)
throw new InvalidOperationException("Module.Assembly == null");
#endif
}
///
void IListListener.OnAdd(int index, ModuleDef module) {
if (module == null)
return;
if (module.Assembly != null)
throw new InvalidOperationException("Module already has an assembly. Remove it from that assembly before adding it to this assembly.");
module.Assembly = this;
}
///
void IListListener.OnRemove(int index, ModuleDef module) {
if (module != null)
module.Assembly = null;
}
///
void IListListener.OnResize(int index) {
}
///
void IListListener.OnClear() {
foreach (var module in Modules.GetEnumerable_NoLock()) {
if (module != null)
module.Assembly = null;
}
}
///
public override string ToString() {
return FullName;
}
}
///
/// An Assembly row created by the user and not present in the original .NET file
///
public class AssemblyDefUser : AssemblyDef {
///
/// Default constructor
///
public AssemblyDefUser()
: this(UTF8String.Empty, new Version(0, 0, 0, 0)) {
}
///
/// Constructor
///
/// Simple name
/// If any of the args is invalid
public AssemblyDefUser(UTF8String name)
: this(name, new Version(0, 0, 0, 0), new PublicKey()) {
}
///
/// Constructor
///
/// Simple name
/// Version
/// If any of the args is invalid
public AssemblyDefUser(UTF8String name, Version version)
: this(name, version, new PublicKey()) {
}
///
/// Constructor
///
/// Simple name
/// Version
/// Public key
/// If any of the args is invalid
public AssemblyDefUser(UTF8String name, Version version, PublicKey publicKey)
: this(name, version, publicKey, UTF8String.Empty) {
}
///
/// Constructor
///
/// Simple name
/// Version
/// Public key
/// Locale
/// If any of the args is invalid
public AssemblyDefUser(UTF8String name, Version version, PublicKey publicKey, UTF8String locale) {
if ((object)name == null)
throw new ArgumentNullException("name");
if (version == null)
throw new ArgumentNullException("version");
if ((object)locale == null)
throw new ArgumentNullException("locale");
this.modules = new LazyList(this);
this.name = name;
this.version = version;
this.publicKey = publicKey ?? new PublicKey();
this.culture = locale;
this.attributes = (int)AssemblyAttributes.None;
}
///
/// Constructor
///
/// Assembly name info
/// If is null
public AssemblyDefUser(AssemblyName asmName)
: this(new AssemblyNameInfo(asmName)) {
this.hashAlgorithm = (AssemblyHashAlgorithm)asmName.HashAlgorithm;
this.attributes = (int)asmName.Flags;
}
///
/// Constructor
///
/// Assembly name info
/// If is null
public AssemblyDefUser(IAssembly asmName) {
if (asmName == null)
throw new ArgumentNullException("asmName");
this.modules = new LazyList(this);
this.name = asmName.Name;
this.version = asmName.Version ?? new Version(0, 0, 0, 0);
this.publicKey = asmName.PublicKeyOrToken as PublicKey ?? new PublicKey();
this.culture = asmName.Culture;
this.attributes = (int)AssemblyAttributes.None;
this.hashAlgorithm = AssemblyHashAlgorithm.SHA1;
}
}
///
/// Created from a row in the Assembly table
///
sealed class AssemblyDefMD : AssemblyDef, IMDTokenProviderMD {
/// The module where this instance is located
readonly ModuleDefMD readerModule;
readonly uint origRid;
///
public uint OrigRid {
get { return origRid; }
}
///
protected override void InitializeDeclSecurities() {
var list = readerModule.MetaData.GetDeclSecurityRidList(Table.Assembly, origRid);
var tmp = new LazyList((int)list.Length, list, (list2, index) => readerModule.ResolveDeclSecurity(((RidList)list2)[index]));
Interlocked.CompareExchange(ref declSecurities, tmp, null);
}
///
protected override void InitializeModules() {
var list = readerModule.GetModuleRidList();
var tmp = new LazyList((int)list.Length + 1, this, list, (list2, index) => {
ModuleDef module;
if (index == 0)
module = readerModule;
else
module = readerModule.ReadModule(((RidList)list2)[index - 1], this);
if (module == null)
module = new ModuleDefUser("INVALID", Guid.NewGuid());
module.Assembly = this;
return module;
});
Interlocked.CompareExchange(ref modules, tmp, null);
}
///
protected override void InitializeCustomAttributes() {
var list = readerModule.MetaData.GetCustomAttributeRidList(Table.Assembly, origRid);
var tmp = new CustomAttributeCollection((int)list.Length, list, (list2, index) => readerModule.ReadCustomAttribute(((RidList)list2)[index]));
Interlocked.CompareExchange(ref customAttributes, tmp, null);
}
///
protected override void InitializeCustomDebugInfos() {
var list = ThreadSafeListCreator.Create();
readerModule.InitializeCustomDebugInfos(new MDToken(MDToken.Table, origRid), new GenericParamContext(), list);
Interlocked.CompareExchange(ref customDebugInfos, list, null);
}
///
public override bool TryGetOriginalTargetFrameworkAttribute(out string framework, out Version version, out string profile) {
if (!hasInitdTFA)
InitializeTargetFrameworkAttribute();
framework = tfaFramework;
version = tfaVersion;
profile = tfaProfile;
return tfaReturnValue;
}
volatile bool hasInitdTFA;
string tfaFramework;
Version tfaVersion;
string tfaProfile;
bool tfaReturnValue;
void InitializeTargetFrameworkAttribute() {
if (hasInitdTFA)
return;
var list = readerModule.MetaData.GetCustomAttributeRidList(Table.Assembly, origRid);
var gpContext = new GenericParamContext();
for (int i = 0; i < list.Count; i++) {
var caRid = list[i];
var caRow = readerModule.TablesStream.ReadCustomAttributeRow(caRid);
if (caRow == null)
continue;
var caType = readerModule.ResolveCustomAttributeType(caRow.Type, gpContext);
UTF8String ns, name;
if (!TryGetName(caType, out ns, out name))
continue;
if (ns != nameSystemRuntimeVersioning || name != nameTargetFrameworkAttribute)
continue;
var ca = CustomAttributeReader.Read(readerModule, caType, caRow.Value, gpContext);
if (ca == null || ca.ConstructorArguments.Count != 1)
continue;
var s = ca.ConstructorArguments[0].Value as UTF8String;
if ((object)s == null)
continue;
string tmpFramework, tmpProfile;
Version tmpVersion;
if (TryCreateTargetFrameworkInfo(s, out tmpFramework, out tmpVersion, out tmpProfile)) {
tfaFramework = tmpFramework;
tfaVersion = tmpVersion;
tfaProfile = tmpProfile;
tfaReturnValue = true;
break;
}
}
hasInitdTFA = true;
}
static readonly UTF8String nameSystemRuntimeVersioning = new UTF8String("System.Runtime.Versioning");
static readonly UTF8String nameTargetFrameworkAttribute = new UTF8String("TargetFrameworkAttribute");
static bool TryGetName(ICustomAttributeType caType, out UTF8String ns, out UTF8String name) {
ITypeDefOrRef type;
var mr = caType as MemberRef;
if (mr != null)
type = mr.DeclaringType;
else {
var md = caType as MethodDef;
type = md == null ? null : md.DeclaringType;
}
var tr = type as TypeRef;
if (tr != null) {
ns = tr.Namespace;
name = tr.Name;
return true;
}
var td = type as TypeDef;
if (td != null) {
ns = td.Namespace;
name = td.Name;
return true;
}
ns = null;
name = null;
return false;
}
static bool TryCreateTargetFrameworkInfo(string attrString, out string framework, out Version version, out string profile) {
framework = null;
version = null;
profile = null;
// See corclr/src/mscorlib/src/System/Runtime/Versioning/BinaryCompatibility.cs
var values = attrString.Split(new char[] { ',' });
if (values.Length < 2 || values.Length > 3)
return false;
var frameworkRes = values[0].Trim();
if (frameworkRes.Length == 0)
return false;
Version versionRes = null;
string profileRes = null;
for (int i = 1; i < values.Length; i++) {
var kvp = values[i].Split('=');
if (kvp.Length != 2)
return false;
var key = kvp[0].Trim();
var value = kvp[1].Trim();
if (key.Equals("Version", StringComparison.OrdinalIgnoreCase)) {
if (value.StartsWith("v", StringComparison.OrdinalIgnoreCase))
value = value.Substring(1);
if (!TryParse(value, out versionRes))
return false;
versionRes = new Version(versionRes.Major, versionRes.Minor, versionRes.Build == -1 ? 0 : versionRes.Build, 0);
}
else if (key.Equals("Profile", StringComparison.OrdinalIgnoreCase)) {
if (!string.IsNullOrEmpty(value))
profileRes = value;
}
}
if (versionRes == null)
return false;
framework = frameworkRes;
version = versionRes;
profile = profileRes;
return true;
}
static int ParseInt32(string s) {
int res;
return int.TryParse(s, out res) ? res : 0;
}
static bool TryParse(string s, out Version version) {
Match m;
m = Regex.Match(s, @"^(\d+)\.(\d+)$");
if (m.Groups.Count == 3) {
version = new Version(ParseInt32(m.Groups[1].Value), ParseInt32(m.Groups[2].Value));
return true;
}
m = Regex.Match(s, @"^(\d+)\.(\d+)\.(\d+)$");
if (m.Groups.Count == 4) {
version = new Version(ParseInt32(m.Groups[1].Value), ParseInt32(m.Groups[2].Value), ParseInt32(m.Groups[3].Value));
return true;
}
m = Regex.Match(s, @"^(\d+)\.(\d+)\.(\d+)\.(\d+)$");
if (m.Groups.Count == 5) {
version = new Version(ParseInt32(m.Groups[1].Value), ParseInt32(m.Groups[2].Value), ParseInt32(m.Groups[3].Value), ParseInt32(m.Groups[4].Value));
return true;
}
version = null;
return false;
}
///
/// Constructor
///
/// The module which contains this Assembly row
/// Row ID
/// If is null
/// If is invalid
public AssemblyDefMD(ModuleDefMD readerModule, uint rid) {
#if DEBUG
if (readerModule == null)
throw new ArgumentNullException("readerModule");
if (readerModule.TablesStream.AssemblyTable.IsInvalidRID(rid))
throw new BadImageFormatException(string.Format("Assembly rid {0} does not exist", rid));
#endif
this.origRid = rid;
this.rid = rid;
this.readerModule = readerModule;
if (rid != 1)
this.modules = new LazyList(this);
uint publicKey, name;
uint culture = readerModule.TablesStream.ReadAssemblyRow(origRid, out this.hashAlgorithm, out this.version, out this.attributes, out publicKey, out name);
this.name = readerModule.StringsStream.ReadNoNull(name);
this.culture = readerModule.StringsStream.ReadNoNull(culture);
this.publicKey = new PublicKey(readerModule.BlobStream.Read(publicKey));
}
}
}
dnlib-2.1_VS2010/src/DotNet/AssemblyHash.cs 0000664 0000000 0000000 00000010036 13250336635 0020263 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.IO;
using System.Security.Cryptography;
namespace dnlib.DotNet {
///
/// Hashes some data according to a
///
struct AssemblyHash : IDisposable {
readonly HashAlgorithm hasher;
///
/// Constructor
///
/// If is an unsupported hash algorithm, then
/// will be used as the hash algorithm.
/// The algorithm to use
public AssemblyHash(AssemblyHashAlgorithm hashAlgo) {
switch (hashAlgo) {
case AssemblyHashAlgorithm.MD5:
hasher = MD5.Create();
break;
case AssemblyHashAlgorithm.None:
case AssemblyHashAlgorithm.MD2:
case AssemblyHashAlgorithm.MD4:
case AssemblyHashAlgorithm.SHA1:
case AssemblyHashAlgorithm.MAC:
case AssemblyHashAlgorithm.SSL3_SHAMD5:
case AssemblyHashAlgorithm.HMAC:
case AssemblyHashAlgorithm.TLS1PRF:
case AssemblyHashAlgorithm.HASH_REPLACE_OWF:
default:
hasher = SHA1.Create();
break;
case AssemblyHashAlgorithm.SHA_256:
hasher = SHA256.Create();
break;
case AssemblyHashAlgorithm.SHA_384:
hasher = SHA384.Create();
break;
case AssemblyHashAlgorithm.SHA_512:
hasher = SHA512.Create();
break;
}
}
///
public void Dispose() {
if (hasher != null)
((IDisposable)hasher).Dispose();
}
///
/// Hash data
///
/// If is an unsupported hash algorithm, then
/// will be used as the hash algorithm.
/// The data
/// The algorithm to use
/// Hashed data or null if was null
public static byte[] Hash(byte[] data, AssemblyHashAlgorithm hashAlgo) {
if (data == null)
return null;
using (var asmHash = new AssemblyHash(hashAlgo)) {
asmHash.Hash(data);
return asmHash.ComputeHash();
}
}
///
/// Hash data
///
/// Data
public void Hash(byte[] data) {
Hash(data, 0, data.Length);
}
///
/// Hash data
///
/// Data
/// Offset
/// Length
public void Hash(byte[] data, int offset, int length) {
if (hasher.TransformBlock(data, offset, length, data, offset) != length)
throw new IOException("Could not calculate hash");
}
///
/// Hash stream data
///
/// Stream
/// Number of bytes to hash
/// Temp buffer
public void Hash(Stream stream, uint length, byte[] buffer) {
while (length > 0) {
int len = length > (uint)buffer.Length ? buffer.Length : (int)length;
if (stream.Read(buffer, 0, len) != len)
throw new IOException("Could not read data");
Hash(buffer, 0, len);
length -= (uint)len;
}
}
///
/// Computes the hash
///
public byte[] ComputeHash() {
hasher.TransformFinalBlock(new byte[0], 0, 0);
return hasher.Hash;
}
///
/// Creates a public key token from the hash of some
///
/// A public key is hashed, and the last 8 bytes of the hash, in reverse
/// order, is used as the public key token
/// The data
/// A new instance
public static PublicKeyToken CreatePublicKeyToken(byte[] publicKeyData) {
if (publicKeyData == null)
return new PublicKeyToken();
var hash = Hash(publicKeyData, AssemblyHashAlgorithm.SHA1);
byte[] pkt = new byte[8];
for (int i = 0; i < pkt.Length && i < hash.Length; i++)
pkt[i] = hash[hash.Length - i - 1];
return new PublicKeyToken(pkt);
}
}
}
dnlib-2.1_VS2010/src/DotNet/AssemblyHashAlgorithm.cs 0000664 0000000 0000000 00000003150 13250336635 0022131 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
namespace dnlib.DotNet {
///
/// Any ALG_CLASS_HASH type in WinCrypt.h can be used by Microsoft's CLI implementation
///
public enum AssemblyHashAlgorithm : uint {
///
None = 0,
///
MD2 = 0x8001,
///
MD4 = 0x8002,
/// This is a reserved value in the CLI
MD5 = 0x8003,
/// The only algorithm supported by the CLI
SHA1 = 0x8004,
///
MAC = 0x8005,
///
SSL3_SHAMD5 = 0x8008,
///
HMAC = 0x8009,
///
TLS1PRF = 0x800A,
///
HASH_REPLACE_OWF = 0x800B,
///
SHA_256 = 0x800C,
///
SHA_384 = 0x800D,
///
SHA_512 = 0x800E,
}
public static partial class Extensions {
internal static string GetName(this AssemblyHashAlgorithm hashAlg) {
switch (hashAlg) {
case AssemblyHashAlgorithm.MD2: return null;
case AssemblyHashAlgorithm.MD4: return null;
case AssemblyHashAlgorithm.MD5: return "MD5";
case AssemblyHashAlgorithm.SHA1: return "SHA1";
case AssemblyHashAlgorithm.MAC: return null;
case AssemblyHashAlgorithm.SSL3_SHAMD5: return null;
case AssemblyHashAlgorithm.HMAC: return null;
case AssemblyHashAlgorithm.TLS1PRF: return null;
case AssemblyHashAlgorithm.HASH_REPLACE_OWF: return null;
case AssemblyHashAlgorithm.SHA_256: return "SHA256";
case AssemblyHashAlgorithm.SHA_384: return "SHA384";
case AssemblyHashAlgorithm.SHA_512: return "SHA512";
default: return null;
}
}
}
}
dnlib-2.1_VS2010/src/DotNet/AssemblyNameComparer.cs 0000664 0000000 0000000 00000017717 13250336635 0021766 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
namespace dnlib.DotNet {
///
/// Flags used by
///
[Flags]
public enum AssemblyNameComparerFlags {
///
/// Compare assembly simple name
///
Name = 1,
///
/// Compare assembly version
///
Version = 2,
///
/// Compare assembly public key token
///
PublicKeyToken = 4,
///
/// Compare assembly culture
///
Culture = 8,
///
/// Compare content type
///
ContentType = 0x10,
///
/// Compare assembly simple name, version, public key token, locale and content type
///
All = Name | Version | PublicKeyToken | Culture | ContentType,
}
///
/// Compares two assembly names
///
public struct AssemblyNameComparer : IEqualityComparer {
///
/// Compares the name, version, public key token, culture and content type
///
public static AssemblyNameComparer CompareAll = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
///
/// Compares only the name and the public key token
///
public static AssemblyNameComparer NameAndPublicKeyTokenOnly = new AssemblyNameComparer(AssemblyNameComparerFlags.Name | AssemblyNameComparerFlags.PublicKeyToken);
///
/// Compares only the name
///
public static AssemblyNameComparer NameOnly = new AssemblyNameComparer(AssemblyNameComparerFlags.Name);
readonly AssemblyNameComparerFlags flags;
///
/// Gets the bit
///
public bool CompareName {
get { return (flags & AssemblyNameComparerFlags.Name) != 0; }
}
///
/// Gets the bit
///
public bool CompareVersion {
get { return (flags & AssemblyNameComparerFlags.Version) != 0; }
}
///
/// Gets the bit
///
public bool ComparePublicKeyToken {
get { return (flags & AssemblyNameComparerFlags.PublicKeyToken) != 0; }
}
///
/// Gets the bit
///
public bool CompareCulture {
get { return (flags & AssemblyNameComparerFlags.Culture) != 0; }
}
///
/// Gets the bit
///
public bool CompareContentType {
get { return (flags & AssemblyNameComparerFlags.ContentType) != 0; }
}
///
/// Constructor
///
/// Comparison flags
public AssemblyNameComparer(AssemblyNameComparerFlags flags) {
this.flags = flags;
}
///
/// Compares two assembly names
///
/// First
/// Second
/// < 0 if a < b, 0 if a == b, > 0 if a > b
public int CompareTo(IAssembly a, IAssembly b) {
if (a == b)
return 0;
if (a == null)
return -1;
if (b == null)
return 1;
int v;
if (CompareName && (v = UTF8String.CaseInsensitiveCompareTo(a.Name, b.Name)) != 0)
return v;
if (CompareVersion && (v = Utils.CompareTo(a.Version, b.Version)) != 0)
return v;
if (ComparePublicKeyToken && (v = PublicKeyBase.TokenCompareTo(a.PublicKeyOrToken, b.PublicKeyOrToken)) != 0)
return v;
if (CompareCulture && (v = Utils.LocaleCompareTo(a.Culture, b.Culture)) != 0)
return v;
if (CompareContentType && (v = a.ContentType.CompareTo(b.ContentType)) != 0)
return v;
return 0;
}
///
/// Compares two assembly names
///
/// First
/// Second
/// true if equal, false otherwise
public bool Equals(IAssembly a, IAssembly b) {
return CompareTo(a, b) == 0;
}
///
/// Figures out which of two assembly names is closer to another assembly name
///
/// Requested assembly name
/// First
/// Second
/// -1 if both are equally close, 0 if is closest, 1 if
/// is closest
public int CompareClosest(IAssembly requested, IAssembly a, IAssembly b) {
if (a == b)
return 0;
if (a == null)
return !CompareName ? 1 : UTF8String.CaseInsensitiveEquals(requested.Name, b.Name) ? 1 : 0;
if (b == null)
return !CompareName ? 0 : UTF8String.CaseInsensitiveEquals(requested.Name, a.Name) ? 0 : 1;
// Compare the most important parts first:
// 1. Assembly simple name
// 2. Public key token
// 3. Version
// 4. Locale
// 5. Content type
if (CompareName) {
// If the name only matches one of a or b, return that one.
bool na = UTF8String.CaseInsensitiveEquals(requested.Name, a.Name);
bool nb = UTF8String.CaseInsensitiveEquals(requested.Name, b.Name);
if (na && !nb)
return 0;
if (!na && nb)
return 1;
if (!na && !nb)
return -1;
}
if (ComparePublicKeyToken) {
bool pa, pb;
if (PublicKeyBase.IsNullOrEmpty2(requested.PublicKeyOrToken)) {
// If one of them has a pkt but the other one hasn't, return the one with
// no pkt.
pa = PublicKeyBase.IsNullOrEmpty2(a.PublicKeyOrToken);
pb = PublicKeyBase.IsNullOrEmpty2(b.PublicKeyOrToken);
}
else {
// If one of them has the correct pkt, but the other one has an incorrect
// pkt, return the one with the correct pkt.
pa = PublicKeyBase.TokenEquals(requested.PublicKeyOrToken, a.PublicKeyOrToken);
pb = PublicKeyBase.TokenEquals(requested.PublicKeyOrToken, b.PublicKeyOrToken);
}
if (pa && !pb)
return 0;
if (!pa && pb)
return 1;
}
if (CompareVersion && !Utils.Equals(a.Version, b.Version)) {
var rv = Utils.CreateVersionWithNoUndefinedValues(requested.Version);
if (rv == new Version(0, 0, 0, 0))
rv = new Version(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
int va = Utils.CompareTo(a.Version, rv);
int vb = Utils.CompareTo(b.Version, rv);
if (va == 0)
return 0; // vb != 0 so return 0
if (vb == 0)
return 1; // va != 0 so return 1
if (va > 0 && vb < 0)
return 0;
if (va < 0 && vb > 0)
return 1;
// Now either both a and b's version > req version or both are < req version
if (va > 0) {
// a.Version and b.Version > req.Version. Pick the one that is closest.
return Utils.CompareTo(a.Version, b.Version) < 0 ? 0 : 1;
}
else {
// a.Version and b.Version < req.Version. Pick the one that is closest.
return Utils.CompareTo(a.Version, b.Version) > 0 ? 0 : 1;
}
}
if (CompareCulture) {
bool la = Utils.LocaleEquals(requested.Culture, a.Culture);
bool lb = Utils.LocaleEquals(requested.Culture, b.Culture);
if (la && !lb)
return 0;
if (!la && lb)
return 1;
}
if (CompareContentType) {
bool ca = requested.ContentType == a.ContentType;
bool cb = requested.ContentType == b.ContentType;
if (ca && !cb)
return 0;
if (!ca && cb)
return 1;
}
return -1;
}
///
/// Gets the hash code of an assembly name
///
/// Assembly name
/// The hash code
public int GetHashCode(IAssembly a) {
if (a == null)
return 0;
int hash = 0;
if (CompareName)
hash += UTF8String.GetHashCode(a.Name);
if (CompareVersion)
hash += Utils.CreateVersionWithNoUndefinedValues(a.Version).GetHashCode();
if (ComparePublicKeyToken)
hash += PublicKeyBase.GetHashCodeToken(a.PublicKeyOrToken);
if (CompareCulture)
hash += Utils.GetHashCodeLocale(a.Culture);
if (CompareContentType)
hash += (int)a.ContentType;
return hash;
}
}
}
dnlib-2.1_VS2010/src/DotNet/AssemblyNameInfo.cs 0000664 0000000 0000000 00000021336 13250336635 0021101 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Reflection;
namespace dnlib.DotNet {
///
/// Stores assembly name information
///
public sealed class AssemblyNameInfo : IAssembly {
AssemblyHashAlgorithm hashAlgId;
Version version;
AssemblyAttributes flags;
PublicKeyBase publicKeyOrToken;
UTF8String name;
UTF8String culture;
///
/// Gets/sets the
///
public AssemblyHashAlgorithm HashAlgId {
get { return hashAlgId; }
set { hashAlgId = value; }
}
///
/// Gets/sets the or null if none specified
///
public Version Version {
get { return version; }
set { version = value; }
}
///
/// Gets/sets the
///
public AssemblyAttributes Attributes {
get { return flags; }
set { flags = value; }
}
///
/// Gets/sets the public key or token
///
public PublicKeyBase PublicKeyOrToken {
get { return publicKeyOrToken; }
set { publicKeyOrToken = value; }
}
///
/// Gets/sets the name
///
public UTF8String Name {
get { return name; }
set { name = value; }
}
///
/// Gets/sets the culture or null if none specified
///
public UTF8String Culture {
get { return culture; }
set { culture = value; }
}
///
/// Gets the full name of the assembly
///
public string FullName {
get { return FullNameToken; }
}
///
/// Gets the full name of the assembly but use a public key token
///
public string FullNameToken {
get {
var pk = publicKeyOrToken;
if (pk is PublicKey)
pk = (pk as PublicKey).Token;
return Utils.GetAssemblyNameString(name, version, culture, pk, flags);
}
}
///
/// Modify property: =
/// ( & ) | .
///
/// Value to AND
/// Value to OR
void ModifyAttributes(AssemblyAttributes andMask, AssemblyAttributes orMask) {
Attributes = (Attributes & andMask) | orMask;
}
///
/// Set or clear flags in
///
/// true if flags should be set, false if flags should
/// be cleared
/// Flags to set or clear
void ModifyAttributes(bool set, AssemblyAttributes flags) {
if (set)
Attributes |= flags;
else
Attributes &= ~flags;
}
///
/// Gets/sets the bit
///
public bool HasPublicKey {
get { return (Attributes & AssemblyAttributes.PublicKey) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.PublicKey); }
}
///
/// Gets/sets the processor architecture
///
public AssemblyAttributes ProcessorArchitecture {
get { return Attributes & AssemblyAttributes.PA_Mask; }
set { ModifyAttributes(~AssemblyAttributes.PA_Mask, value & AssemblyAttributes.PA_Mask); }
}
///
/// Gets/sets the processor architecture
///
public AssemblyAttributes ProcessorArchitectureFull {
get { return Attributes & AssemblyAttributes.PA_FullMask; }
set { ModifyAttributes(~AssemblyAttributes.PA_FullMask, value & AssemblyAttributes.PA_FullMask); }
}
///
/// true if unspecified processor architecture
///
public bool IsProcessorArchitectureNone {
get { return (Attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_None; }
}
///
/// true if neutral (PE32) architecture
///
public bool IsProcessorArchitectureMSIL {
get { return (Attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_MSIL; }
}
///
/// true if x86 (PE32) architecture
///
public bool IsProcessorArchitectureX86 {
get { return (Attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_x86; }
}
///
/// true if IA-64 (PE32+) architecture
///
public bool IsProcessorArchitectureIA64 {
get { return (Attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_IA64; }
}
///
/// true if x64 (PE32+) architecture
///
public bool IsProcessorArchitectureX64 {
get { return (Attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_AMD64; }
}
///
/// true if ARM (PE32) architecture
///
public bool IsProcessorArchitectureARM {
get { return (Attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_ARM; }
}
///
/// true if eg. reference assembly (not runnable)
///
public bool IsProcessorArchitectureNoPlatform {
get { return (Attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_NoPlatform; }
}
///
/// Gets/sets the bit
///
public bool IsProcessorArchitectureSpecified {
get { return (Attributes & AssemblyAttributes.PA_Specified) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.PA_Specified); }
}
///
/// Gets/sets the bit
///
public bool EnableJITcompileTracking {
get { return (Attributes & AssemblyAttributes.EnableJITcompileTracking) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.EnableJITcompileTracking); }
}
///
/// Gets/sets the bit
///
public bool DisableJITcompileOptimizer {
get { return (Attributes & AssemblyAttributes.DisableJITcompileOptimizer) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.DisableJITcompileOptimizer); }
}
///
/// Gets/sets the bit
///
public bool IsRetargetable {
get { return (Attributes & AssemblyAttributes.Retargetable) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.Retargetable); }
}
///
/// Gets/sets the content type
///
public AssemblyAttributes ContentType {
get { return Attributes & AssemblyAttributes.ContentType_Mask; }
set { ModifyAttributes(~AssemblyAttributes.ContentType_Mask, value & AssemblyAttributes.ContentType_Mask); }
}
///
/// true if content type is Default
///
public bool IsContentTypeDefault {
get { return (Attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_Default; }
}
///
/// true if content type is WindowsRuntime
///
public bool IsContentTypeWindowsRuntime {
get { return (Attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_WindowsRuntime; }
}
///
/// Default constructor
///
public AssemblyNameInfo() {
}
///
/// Constructor
///
/// An assembly name
public AssemblyNameInfo(string asmFullName)
: this(ReflectionTypeNameParser.ParseAssemblyRef(asmFullName)) {
}
///
/// Constructor
///
/// The assembly
public AssemblyNameInfo(IAssembly asm) {
if (asm == null)
return;
var asmDef = asm as AssemblyDef;
this.hashAlgId = asmDef == null ? 0 : asmDef.HashAlgorithm;
this.version = asm.Version ?? new Version(0, 0, 0, 0);
this.flags = asm.Attributes;
this.publicKeyOrToken = asm.PublicKeyOrToken;
this.name = UTF8String.IsNullOrEmpty(asm.Name) ? UTF8String.Empty : asm.Name;
this.culture = UTF8String.IsNullOrEmpty(asm.Culture) ? UTF8String.Empty : asm.Culture;
}
///
/// Constructor
///
/// Assembly name info
public AssemblyNameInfo(AssemblyName asmName) {
if (asmName == null)
return;
this.hashAlgId = (AssemblyHashAlgorithm)asmName.HashAlgorithm;
this.version = asmName.Version ?? new Version(0, 0, 0, 0);
this.flags = (AssemblyAttributes)asmName.Flags;
this.publicKeyOrToken = (PublicKeyBase)PublicKeyBase.CreatePublicKey(asmName.GetPublicKey()) ??
PublicKeyBase.CreatePublicKeyToken(asmName.GetPublicKeyToken());
this.name = asmName.Name ?? string.Empty;
this.culture = asmName.CultureInfo != null && asmName.CultureInfo.Name != null ? asmName.CultureInfo.Name : string.Empty;
}
///
public override string ToString() {
return FullName;
}
}
}
dnlib-2.1_VS2010/src/DotNet/AssemblyRef.cs 0000664 0000000 0000000 00000044004 13250336635 0020116 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Reflection;
using System.Threading;
using dnlib.DotNet.MD;
using dnlib.DotNet.Pdb;
using dnlib.Threading;
#if THREAD_SAFE
using ThreadSafe = dnlib.Threading.Collections;
#else
using ThreadSafe = System.Collections.Generic;
#endif
namespace dnlib.DotNet {
///
/// A high-level representation of a row in the AssemblyRef table
///
public abstract class AssemblyRef : IHasCustomAttribute, IImplementation, IResolutionScope, IHasCustomDebugInformation, IAssembly, IScope {
///
/// An assembly ref that can be used to indicate that it references the current assembly
/// when the current assembly is not known (eg. a type string without any assembly info
/// when it references a type in the current assembly).
///
public static readonly AssemblyRef CurrentAssembly = new AssemblyRefUser("<<>>");
///
/// The row id in its table
///
protected uint rid;
///
public MDToken MDToken {
get { return new MDToken(Table.AssemblyRef, rid); }
}
///
public uint Rid {
get { return rid; }
set { rid = value; }
}
///
public int HasCustomAttributeTag {
get { return 15; }
}
///
public int ImplementationTag {
get { return 1; }
}
///
public int ResolutionScopeTag {
get { return 2; }
}
///
public ScopeType ScopeType {
get { return ScopeType.AssemblyRef; }
}
///
public string ScopeName {
get { return FullName; }
}
///
/// From columns AssemblyRef.MajorVersion, AssemblyRef.MinorVersion,
/// AssemblyRef.BuildNumber, AssemblyRef.RevisionNumber
///
/// If is null
public Version Version {
get { return version; }
set {
if (value == null)
throw new ArgumentNullException("value");
version = value;
}
}
///
protected Version version;
///
/// From column AssemblyRef.Flags
///
public AssemblyAttributes Attributes {
get { return (AssemblyAttributes)attributes; }
set { attributes = (int)value; }
}
/// Attributes
protected int attributes;
///
/// From column AssemblyRef.PublicKeyOrToken
///
/// If is null
public PublicKeyBase PublicKeyOrToken {
get { return publicKeyOrToken; }
set {
if (value == null)
throw new ArgumentNullException("value");
publicKeyOrToken = value;
}
}
///
protected PublicKeyBase publicKeyOrToken;
///
/// From column AssemblyRef.Name
///
public UTF8String Name {
get { return name; }
set { name = value; }
}
/// Name
protected UTF8String name;
///
/// From column AssemblyRef.Locale
///
public UTF8String Culture {
get { return culture; }
set { culture = value; }
}
/// Culture
protected UTF8String culture;
///
/// From column AssemblyRef.HashValue
///
public byte[] Hash {
get { return hashValue; }
set { hashValue = value; }
}
///
protected byte[] hashValue;
///
/// Gets all custom attributes
///
public CustomAttributeCollection CustomAttributes {
get {
if (customAttributes == null)
InitializeCustomAttributes();
return customAttributes;
}
}
///
protected CustomAttributeCollection customAttributes;
/// Initializes
protected virtual void InitializeCustomAttributes() {
Interlocked.CompareExchange(ref customAttributes, new CustomAttributeCollection(), null);
}
///
public bool HasCustomAttributes {
get { return CustomAttributes.Count > 0; }
}
///
public int HasCustomDebugInformationTag {
get { return 15; }
}
///
public bool HasCustomDebugInfos {
get { return CustomDebugInfos.Count > 0; }
}
///
/// Gets all custom debug infos
///
public ThreadSafe.IList CustomDebugInfos {
get {
if (customDebugInfos == null)
InitializeCustomDebugInfos();
return customDebugInfos;
}
}
///
protected ThreadSafe.IList customDebugInfos;
/// Initializes
protected virtual void InitializeCustomDebugInfos() {
Interlocked.CompareExchange(ref customDebugInfos, ThreadSafeListCreator.Create(), null);
}
///
public string FullName {
get { return FullNameToken; }
}
///
/// Same as , except that it uses the PublicKey if available.
///
public string RealFullName {
get { return Utils.GetAssemblyNameString(name, version, culture, publicKeyOrToken, Attributes); }
}
///
/// Gets the full name of the assembly but use a public key token
///
public string FullNameToken {
get { return Utils.GetAssemblyNameString(name, version, culture, PublicKeyBase.ToPublicKeyToken(publicKeyOrToken), Attributes); }
}
///
/// Modify property: =
/// ( & ) | .
///
/// Value to AND
/// Value to OR
void ModifyAttributes(AssemblyAttributes andMask, AssemblyAttributes orMask) {
#if THREAD_SAFE
int origVal, newVal;
do {
origVal = attributes;
newVal = (origVal & (int)andMask) | (int)orMask;
} while (Interlocked.CompareExchange(ref attributes, newVal, origVal) != origVal);
#else
attributes = (attributes & (int)andMask) | (int)orMask;
#endif
}
///
/// Set or clear flags in
///
/// true if flags should be set, false if flags should
/// be cleared
/// Flags to set or clear
void ModifyAttributes(bool set, AssemblyAttributes flags) {
#if THREAD_SAFE
int origVal, newVal;
do {
origVal = attributes;
if (set)
newVal = origVal | (int)flags;
else
newVal = origVal & ~(int)flags;
} while (Interlocked.CompareExchange(ref attributes, newVal, origVal) != origVal);
#else
if (set)
attributes |= (int)flags;
else
attributes &= ~(int)flags;
#endif
}
///
/// Gets/sets the bit
///
public bool HasPublicKey {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PublicKey) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.PublicKey); }
}
///
/// Gets/sets the processor architecture
///
public AssemblyAttributes ProcessorArchitecture {
get { return (AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask; }
set { ModifyAttributes(~AssemblyAttributes.PA_Mask, value & AssemblyAttributes.PA_Mask); }
}
///
/// Gets/sets the processor architecture
///
public AssemblyAttributes ProcessorArchitectureFull {
get { return (AssemblyAttributes)attributes & AssemblyAttributes.PA_FullMask; }
set { ModifyAttributes(~AssemblyAttributes.PA_FullMask, value & AssemblyAttributes.PA_FullMask); }
}
///
/// true if unspecified processor architecture
///
public bool IsProcessorArchitectureNone {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_None; }
}
///
/// true if neutral (PE32) architecture
///
public bool IsProcessorArchitectureMSIL {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_MSIL; }
}
///
/// true if x86 (PE32) architecture
///
public bool IsProcessorArchitectureX86 {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_x86; }
}
///
/// true if IA-64 (PE32+) architecture
///
public bool IsProcessorArchitectureIA64 {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_IA64; }
}
///
/// true if x64 (PE32+) architecture
///
public bool IsProcessorArchitectureX64 {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_AMD64; }
}
///
/// true if ARM (PE32) architecture
///
public bool IsProcessorArchitectureARM {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_ARM; }
}
///
/// true if eg. reference assembly (not runnable)
///
public bool IsProcessorArchitectureNoPlatform {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Mask) == AssemblyAttributes.PA_NoPlatform; }
}
///
/// Gets/sets the bit
///
public bool IsProcessorArchitectureSpecified {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.PA_Specified) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.PA_Specified); }
}
///
/// Gets/sets the bit
///
public bool EnableJITcompileTracking {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.EnableJITcompileTracking) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.EnableJITcompileTracking); }
}
///
/// Gets/sets the bit
///
public bool DisableJITcompileOptimizer {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.DisableJITcompileOptimizer) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.DisableJITcompileOptimizer); }
}
///
/// Gets/sets the bit
///
public bool IsRetargetable {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.Retargetable) != 0; }
set { ModifyAttributes(value, AssemblyAttributes.Retargetable); }
}
///
/// Gets/sets the content type
///
public AssemblyAttributes ContentType {
get { return (AssemblyAttributes)attributes & AssemblyAttributes.ContentType_Mask; }
set { ModifyAttributes(~AssemblyAttributes.ContentType_Mask, value & AssemblyAttributes.ContentType_Mask); }
}
///
/// true if content type is Default
///
public bool IsContentTypeDefault {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_Default; }
}
///
/// true if content type is WindowsRuntime
///
public bool IsContentTypeWindowsRuntime {
get { return ((AssemblyAttributes)attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_WindowsRuntime; }
}
///
public override string ToString() {
return FullName;
}
}
///
/// An AssemblyRef row created by the user and not present in the original .NET file
///
public class AssemblyRefUser : AssemblyRef {
///
/// Creates a reference to CLR 1.0's mscorlib
///
public static AssemblyRefUser CreateMscorlibReferenceCLR10() {
return new AssemblyRefUser("mscorlib", new Version(1, 0, 3300, 0), new PublicKeyToken("b77a5c561934e089"));
}
///
/// Creates a reference to CLR 1.1's mscorlib
///
public static AssemblyRefUser CreateMscorlibReferenceCLR11() {
return new AssemblyRefUser("mscorlib", new Version(1, 0, 5000, 0), new PublicKeyToken("b77a5c561934e089"));
}
///
/// Creates a reference to CLR 2.0's mscorlib
///
public static AssemblyRefUser CreateMscorlibReferenceCLR20() {
return new AssemblyRefUser("mscorlib", new Version(2, 0, 0, 0), new PublicKeyToken("b77a5c561934e089"));
}
///
/// Creates a reference to CLR 4.0's mscorlib
///
public static AssemblyRefUser CreateMscorlibReferenceCLR40() {
return new AssemblyRefUser("mscorlib", new Version(4, 0, 0, 0), new PublicKeyToken("b77a5c561934e089"));
}
///
/// Default constructor
///
public AssemblyRefUser()
: this(UTF8String.Empty) {
}
///
/// Constructor
///
/// Simple name
/// If any of the args is invalid
public AssemblyRefUser(UTF8String name)
: this(name, new Version(0, 0, 0, 0)) {
}
///
/// Constructor
///
/// Simple name
/// Version
/// If any of the args is invalid
public AssemblyRefUser(UTF8String name, Version version)
: this(name, version, new PublicKey()) {
}
///
/// Constructor
///
/// Simple name
/// Version
/// Public key or public key token
/// If any of the args is invalid
public AssemblyRefUser(UTF8String name, Version version, PublicKeyBase publicKey)
: this(name, version, publicKey, UTF8String.Empty) {
}
///
/// Constructor
///
/// Simple name
/// Version
/// Public key or public key token
/// Locale
/// If any of the args is invalid
public AssemblyRefUser(UTF8String name, Version version, PublicKeyBase publicKey, UTF8String locale) {
if ((object)name == null)
throw new ArgumentNullException("name");
if (version == null)
throw new ArgumentNullException("version");
if ((object)locale == null)
throw new ArgumentNullException("locale");
this.name = name;
this.version = version;
this.publicKeyOrToken = publicKey;
this.culture = locale;
this.attributes = (int)(publicKey is PublicKey ? AssemblyAttributes.PublicKey : AssemblyAttributes.None);
}
///
/// Constructor
///
/// Assembly name info
/// If is null
public AssemblyRefUser(AssemblyName asmName)
: this(new AssemblyNameInfo(asmName)) {
this.attributes = (int)asmName.Flags;
}
///
/// Constructor
///
/// Assembly
public AssemblyRefUser(IAssembly assembly) {
if (assembly == null)
throw new ArgumentNullException("asmName");
this.version = assembly.Version ?? new Version(0, 0, 0, 0);
this.publicKeyOrToken = assembly.PublicKeyOrToken;
this.name = UTF8String.IsNullOrEmpty(assembly.Name) ? UTF8String.Empty : assembly.Name;
this.culture = assembly.Culture;
this.attributes = (int)((publicKeyOrToken is PublicKey ? AssemblyAttributes.PublicKey : AssemblyAttributes.None) | assembly.ContentType);
}
}
///
/// Created from a row in the AssemblyRef table
///
sealed class AssemblyRefMD : AssemblyRef, IMDTokenProviderMD {
/// The module where this instance is located
readonly ModuleDefMD readerModule;
readonly uint origRid;
///
public uint OrigRid {
get { return origRid; }
}
///
protected override void InitializeCustomAttributes() {
var list = readerModule.MetaData.GetCustomAttributeRidList(Table.AssemblyRef, origRid);
var tmp = new CustomAttributeCollection((int)list.Length, list, (list2, index) => readerModule.ReadCustomAttribute(((RidList)list2)[index]));
Interlocked.CompareExchange(ref customAttributes, tmp, null);
}
///
protected override void InitializeCustomDebugInfos() {
var list = ThreadSafeListCreator.Create();
readerModule.InitializeCustomDebugInfos(new MDToken(MDToken.Table, origRid), new GenericParamContext(), list);
Interlocked.CompareExchange(ref customDebugInfos, list, null);
}
///
/// Constructor
///
/// The module which contains this AssemblyRef row
/// Row ID
/// If is null
/// If is invalid
public AssemblyRefMD(ModuleDefMD readerModule, uint rid) {
#if DEBUG
if (readerModule == null)
throw new ArgumentNullException("readerModule");
if (readerModule.TablesStream.AssemblyRefTable.IsInvalidRID(rid))
throw new BadImageFormatException(string.Format("AssemblyRef rid {0} does not exist", rid));
#endif
this.origRid = rid;
this.rid = rid;
this.readerModule = readerModule;
uint publicKeyOrToken, name, culture;
uint hashValue = readerModule.TablesStream.ReadAssemblyRefRow(origRid, out this.version, out this.attributes, out publicKeyOrToken, out name, out culture);
var pkData = readerModule.BlobStream.Read(publicKeyOrToken);
if ((this.attributes & (uint)AssemblyAttributes.PublicKey) != 0)
this.publicKeyOrToken = new PublicKey(pkData);
else
this.publicKeyOrToken = new PublicKeyToken(pkData);
this.name = readerModule.StringsStream.ReadNoNull(name);
this.culture = readerModule.StringsStream.ReadNoNull(culture);
this.hashValue = readerModule.BlobStream.Read(hashValue);
}
}
}
dnlib-2.1_VS2010/src/DotNet/AssemblyResolver.cs 0000664 0000000 0000000 00000106225 13250336635 0021207 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml;
using dnlib.Threading;
#if THREAD_SAFE
using ThreadSafe = dnlib.Threading.Collections;
#else
using ThreadSafe = System.Collections.Generic;
#endif
namespace dnlib.DotNet {
///
/// Resolves assemblies
///
public class AssemblyResolver : IAssemblyResolver {
static readonly ModuleDef nullModule = new ModuleDefUser();
// DLL files are searched before EXE files
static readonly string[] assemblyExtensions = new string[] { ".dll", ".exe" };
static readonly string[] winMDAssemblyExtensions = new string[] { ".winmd" };
static readonly List gacInfos;
static readonly string[] extraMonoPaths;
static readonly string[] monoVerDirs = new string[] {
// The "-api" dirs are reference assembly dirs.
"4.5", @"4.5\Facades", "4.5-api", @"4.5-api\Facades", "4.0", "4.0-api",
"3.5", "3.5-api", "3.0", "3.0-api", "2.0", "2.0-api",
"1.1", "1.0",
};
ModuleContext defaultModuleContext;
readonly Dictionary> moduleSearchPaths = new Dictionary>();
readonly Dictionary cachedAssemblies = new Dictionary(StringComparer.Ordinal);
readonly ThreadSafe.IList preSearchPaths = ThreadSafeListCreator.Create();
readonly ThreadSafe.IList postSearchPaths = ThreadSafeListCreator.Create();
bool findExactMatch;
bool enableFrameworkRedirect;
bool enableTypeDefCache = true;
bool useGac = true;
#if THREAD_SAFE
readonly Lock theLock = Lock.Create();
#endif
sealed class GacInfo {
public readonly int Version;
public readonly string Path;
public readonly string Prefix;
public readonly IList SubDirs;
public GacInfo(int version, string prefix, string path, IList subDirs) {
this.Version = version;
this.Prefix = prefix;
this.Path = path;
this.SubDirs = subDirs;
}
}
static AssemblyResolver() {
gacInfos = new List();
if (Type.GetType("Mono.Runtime") != null) {
var dirs = new Dictionary(StringComparer.OrdinalIgnoreCase);
var extraMonoPathsList = new List();
foreach (var prefix in FindMonoPrefixes()) {
var dir = Path.Combine(Path.Combine(Path.Combine(prefix, "lib"), "mono"), "gac");
if (dirs.ContainsKey(dir))
continue;
dirs[dir] = true;
if (Directory.Exists(dir)) {
gacInfos.Add(new GacInfo(-1, "", Path.GetDirectoryName(dir), new string[] {
Path.GetFileName(dir)
}));
}
dir = Path.GetDirectoryName(dir);
foreach (var verDir in monoVerDirs) {
var dir2 = dir;
foreach (var d in verDir.Split(new char[] { '\\' }))
dir2 = Path.Combine(dir2, d);
if (Directory.Exists(dir2))
extraMonoPathsList.Add(dir2);
}
}
var paths = Environment.GetEnvironmentVariable("MONO_PATH");
if (paths != null) {
foreach (var tmp in paths.Split(Path.PathSeparator)) {
var path = tmp.Trim();
if (path != string.Empty && Directory.Exists(path))
extraMonoPathsList.Add(path);
}
}
extraMonoPaths = extraMonoPathsList.ToArray();
}
else {
var windir = Environment.GetEnvironmentVariable("WINDIR");
if (!string.IsNullOrEmpty(windir)) {
string path;
// .NET 1.x and 2.x
path = Path.Combine(windir, "assembly");
if (Directory.Exists(path)) {
gacInfos.Add(new GacInfo(2, "", path, new string[] {
"GAC_32", "GAC_64", "GAC_MSIL", "GAC"
}));
}
// .NET 4.x
path = Path.Combine(Path.Combine(windir, "Microsoft.NET"), "assembly");
if (Directory.Exists(path)) {
gacInfos.Add(new GacInfo(4, "v4.0_", path, new string[] {
"GAC_32", "GAC_64", "GAC_MSIL"
}));
}
}
}
}
static string GetCurrentMonoPrefix() {
var path = typeof(object).Module.FullyQualifiedName;
for (int i = 0; i < 4; i++)
path = Path.GetDirectoryName(path);
return path;
}
static IEnumerable FindMonoPrefixes() {
yield return GetCurrentMonoPrefix();
var prefixes = Environment.GetEnvironmentVariable("MONO_GAC_PREFIX");
if (!string.IsNullOrEmpty(prefixes)) {
foreach (var tmp in prefixes.Split(Path.PathSeparator)) {
var prefix = tmp.Trim();
if (prefix != string.Empty)
yield return prefix;
}
}
}
///
/// Gets/sets the default
///
public ModuleContext DefaultModuleContext {
get { return defaultModuleContext; }
set { defaultModuleContext = value; }
}
///
/// true if should find an assembly that matches exactly.
/// false if it first tries to match exactly, and if that fails, it picks an
/// assembly that is closest to the requested assembly.
///
public bool FindExactMatch {
get { return findExactMatch; }
set { findExactMatch = value; }
}
///
/// true if resolved .NET framework assemblies can be redirected to the source
/// module's framework assembly version. Eg. if a resolved .NET 3.5 assembly can be
/// redirected to a .NET 4.0 assembly if the source module is a .NET 4.0 assembly. This is
/// ignored if is true.
///
public bool EnableFrameworkRedirect {
get { return enableFrameworkRedirect; }
set { enableFrameworkRedirect = value; }
}
///
/// If true, all modules in newly resolved assemblies will have their
/// property set to true. This is
/// enabled by default since these modules shouldn't be modified by the user.
///
public bool EnableTypeDefCache {
get { return enableTypeDefCache; }
set { enableTypeDefCache = value; }
}
///
/// true to search the Global Assembly Cache. Default value is true.
///
public bool UseGAC {
get { return useGac; }
set { useGac = value; }
}
///
/// Gets paths searched before trying the standard locations
///
public ThreadSafe.IList PreSearchPaths {
get { return preSearchPaths; }
}
///
/// Gets paths searched after trying the standard locations
///
public ThreadSafe.IList PostSearchPaths {
get { return postSearchPaths; }
}
///
/// Default constructor
///
public AssemblyResolver()
: this(null, true) {
}
///
/// Constructor
///
/// Module context for all resolved assemblies
public AssemblyResolver(ModuleContext defaultModuleContext)
: this(defaultModuleContext, true) {
}
///
/// Constructor
///
/// Module context for all resolved assemblies
/// If true, add other common assembly search
/// paths, not just the module search paths and the GAC.
public AssemblyResolver(ModuleContext defaultModuleContext, bool addOtherSearchPaths) {
this.defaultModuleContext = defaultModuleContext;
this.enableFrameworkRedirect = true;
if (addOtherSearchPaths)
AddOtherSearchPaths(postSearchPaths);
}
///
public AssemblyDef Resolve(IAssembly assembly, ModuleDef sourceModule) {
if (assembly == null)
return null;
if (EnableFrameworkRedirect && !FindExactMatch)
FrameworkRedirect.ApplyFrameworkRedirect(ref assembly, sourceModule);
#if THREAD_SAFE
theLock.EnterWriteLock(); try {
#endif
AssemblyDef resolvedAssembly = Resolve2(assembly, sourceModule);
if (resolvedAssembly == null) {
string asmName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
string asmNameTrimmed = asmName.Trim();
if (asmName != asmNameTrimmed) {
assembly = new AssemblyNameInfo {
Name = asmNameTrimmed,
Version = assembly.Version,
PublicKeyOrToken = assembly.PublicKeyOrToken,
Culture = assembly.Culture,
};
resolvedAssembly = Resolve2(assembly, sourceModule);
}
}
if (resolvedAssembly == null) {
// Make sure we don't search for this assembly again. This speeds up callers who
// keep asking for this assembly when trying to resolve many different TypeRefs
cachedAssemblies[GetAssemblyNameKey(assembly)] = null;
return null;
}
var key1 = GetAssemblyNameKey(resolvedAssembly);
var key2 = GetAssemblyNameKey(assembly);
AssemblyDef asm1, asm2;
cachedAssemblies.TryGetValue(key1, out asm1);
cachedAssemblies.TryGetValue(key2, out asm2);
if (asm1 != resolvedAssembly && asm2 != resolvedAssembly) {
// This assembly was just resolved
if (enableTypeDefCache) {
foreach (var module in resolvedAssembly.Modules.GetSafeEnumerable()) {
if (module != null)
module.EnableTypeDefFindCache = true;
}
}
}
bool inserted = false;
if (!cachedAssemblies.ContainsKey(key1)) {
cachedAssemblies.Add(key1, resolvedAssembly);
inserted = true;
}
if (!cachedAssemblies.ContainsKey(key2)) {
cachedAssemblies.Add(key2, resolvedAssembly);
inserted = true;
}
if (inserted || asm1 == resolvedAssembly || asm2 == resolvedAssembly)
return resolvedAssembly;
// Dupe assembly. Don't insert it.
var dupeModule = resolvedAssembly.ManifestModule;
if (dupeModule != null)
dupeModule.Dispose();
return asm1 ?? asm2;
#if THREAD_SAFE
} finally { theLock.ExitWriteLock(); }
#endif
}
///
public bool AddToCache(AssemblyDef asm) {
if (asm == null)
return false;
var asmKey = GetAssemblyNameKey(asm);
AssemblyDef cachedAsm;
#if THREAD_SAFE
theLock.EnterWriteLock(); try {
#endif
if (cachedAssemblies.TryGetValue(asmKey, out cachedAsm) && cachedAsm != null)
return asm == cachedAsm;
cachedAssemblies[asmKey] = asm;
return true;
#if THREAD_SAFE
} finally { theLock.ExitWriteLock(); }
#endif
}
///
public bool Remove(AssemblyDef asm) {
if (asm == null)
return false;
var asmKey = GetAssemblyNameKey(asm);
#if THREAD_SAFE
theLock.EnterWriteLock(); try {
#endif
return cachedAssemblies.Remove(asmKey);
#if THREAD_SAFE
} finally { theLock.ExitWriteLock(); }
#endif
}
///
public void Clear() {
List asms;
#if THREAD_SAFE
theLock.EnterWriteLock(); try {
#endif
asms = new List(cachedAssemblies.Values);
cachedAssemblies.Clear();
#if THREAD_SAFE
} finally { theLock.ExitWriteLock(); }
#endif
foreach (var asm in asms) {
if (asm == null)
continue;
foreach (var mod in asm.Modules.GetSafeEnumerable())
mod.Dispose();
}
}
static string GetAssemblyNameKey(IAssembly asmName) {
// Make sure the name contains PublicKeyToken= and not PublicKey=
return asmName.FullNameToken.ToUpperInvariant();
}
AssemblyDef Resolve2(IAssembly assembly, ModuleDef sourceModule) {
AssemblyDef resolvedAssembly;
if (cachedAssemblies.TryGetValue(GetAssemblyNameKey(assembly), out resolvedAssembly))
return resolvedAssembly;
var moduleContext = defaultModuleContext;
if (moduleContext == null && sourceModule != null)
moduleContext = sourceModule.Context;
resolvedAssembly = FindExactAssembly(assembly, PreFindAssemblies(assembly, sourceModule, true), moduleContext) ??
FindExactAssembly(assembly, FindAssemblies(assembly, sourceModule, true), moduleContext) ??
FindExactAssembly(assembly, PostFindAssemblies(assembly, sourceModule, true), moduleContext);
if (resolvedAssembly != null)
return resolvedAssembly;
if (!findExactMatch) {
resolvedAssembly = FindClosestAssembly(assembly);
resolvedAssembly = FindClosestAssembly(assembly, resolvedAssembly, PreFindAssemblies(assembly, sourceModule, false), moduleContext);
resolvedAssembly = FindClosestAssembly(assembly, resolvedAssembly, FindAssemblies(assembly, sourceModule, false), moduleContext);
resolvedAssembly = FindClosestAssembly(assembly, resolvedAssembly, PostFindAssemblies(assembly, sourceModule, false), moduleContext);
}
return resolvedAssembly;
}
///
/// Finds an assembly that exactly matches the requested assembly
///
/// Assembly to find
/// Search paths or null if none
/// Module context
/// An instance or null if an exact match
/// couldn't be found.
AssemblyDef FindExactAssembly(IAssembly assembly, IEnumerable paths, ModuleContext moduleContext) {
if (paths == null)
return null;
var asmComparer = AssemblyNameComparer.CompareAll;
foreach (var path in paths.GetSafeEnumerable()) {
ModuleDefMD mod = null;
try {
mod = ModuleDefMD.Load(path, moduleContext);
var asm = mod.Assembly;
if (asm != null && asmComparer.Equals(assembly, asm)) {
mod = null;
return asm;
}
}
catch {
}
finally {
if (mod != null)
mod.Dispose();
}
}
return null;
}
///
/// Finds the closest assembly from the already cached assemblies
///
/// Assembly to find
/// The closest or null if none found
AssemblyDef FindClosestAssembly(IAssembly assembly) {
AssemblyDef closest = null;
var asmComparer = AssemblyNameComparer.CompareAll;
foreach (var asm in cachedAssemblies.Values) {
if (asm == null)
continue;
if (asmComparer.CompareClosest(assembly, closest, asm) == 1)
closest = asm;
}
return closest;
}
AssemblyDef FindClosestAssembly(IAssembly assembly, AssemblyDef closest, IEnumerable paths, ModuleContext moduleContext) {
if (paths == null)
return closest;
var asmComparer = AssemblyNameComparer.CompareAll;
foreach (var path in paths.GetSafeEnumerable()) {
ModuleDefMD mod = null;
try {
mod = ModuleDefMD.Load(path, moduleContext);
var asm = mod.Assembly;
if (asm != null && asmComparer.CompareClosest(assembly, closest, asm) == 1) {
if (!IsCached(closest) && closest != null) {
var closeMod = closest.ManifestModule;
if (closeMod != null)
closeMod.Dispose();
}
closest = asm;
mod = null;
}
}
catch {
}
finally {
if (mod != null)
mod.Dispose();
}
}
return closest;
}
///
/// Returns true if is inserted in
///
/// Assembly to check
bool IsCached(AssemblyDef asm) {
if (asm == null)
return false;
AssemblyDef cachedAsm;
return cachedAssemblies.TryGetValue(GetAssemblyNameKey(asm), out cachedAsm) &&
cachedAsm == asm;
}
IEnumerable FindAssemblies2(IAssembly assembly, IEnumerable paths) {
if (paths != null) {
var asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
var exts = assembly.IsContentTypeWindowsRuntime ? winMDAssemblyExtensions : assemblyExtensions;
foreach (var ext in exts) {
foreach (var path in paths.GetSafeEnumerable()) {
var fullPath = Path.Combine(path, asmSimpleName + ext);
if (File.Exists(fullPath))
yield return fullPath;
}
}
}
}
///
/// Called before
///
/// Assembly to find
/// The module that needs to resolve an assembly or null
/// We're trying to find an exact match
/// null or an enumerable of full paths to try
protected virtual IEnumerable PreFindAssemblies(IAssembly assembly, ModuleDef sourceModule, bool matchExactly) {
foreach (var path in FindAssemblies2(assembly, preSearchPaths))
yield return path;
}
///
/// Called after (if it fails)
///
/// Assembly to find
/// The module that needs to resolve an assembly or null
/// We're trying to find an exact match
/// null or an enumerable of full paths to try
protected virtual IEnumerable PostFindAssemblies(IAssembly assembly, ModuleDef sourceModule, bool matchExactly) {
foreach (var path in FindAssemblies2(assembly, postSearchPaths))
yield return path;
}
///
/// Called after (if it fails)
///
/// Assembly to find
/// The module that needs to resolve an assembly or null
/// We're trying to find an exact match
/// null or an enumerable of full paths to try
protected virtual IEnumerable FindAssemblies(IAssembly assembly, ModuleDef sourceModule, bool matchExactly) {
if (assembly.IsContentTypeWindowsRuntime) {
var path = Path.Combine(Path.Combine(Environment.SystemDirectory, "WinMetadata"), assembly.Name + ".winmd");
if (File.Exists(path))
yield return path;
}
else {
if (UseGAC) {
foreach (var path in FindAssembliesGac(assembly, sourceModule, matchExactly))
yield return path;
}
}
foreach (var path in FindAssembliesModuleSearchPaths(assembly, sourceModule, matchExactly))
yield return path;
}
IEnumerable FindAssembliesGac(IAssembly assembly, ModuleDef sourceModule, bool matchExactly) {
if (matchExactly)
return FindAssembliesGacExactly(assembly, sourceModule);
return FindAssembliesGacAny(assembly, sourceModule);
}
IEnumerable GetGacInfos(ModuleDef sourceModule) {
int version = sourceModule == null ? int.MinValue : sourceModule.IsClr40 ? 4 : 2;
// Try the correct GAC first (eg. GAC4 if it's a .NET 4 assembly)
foreach (var gacInfo in gacInfos) {
if (gacInfo.Version == version)
yield return gacInfo;
}
foreach (var gacInfo in gacInfos) {
if (gacInfo.Version != version)
yield return gacInfo;
}
}
IEnumerable FindAssembliesGacExactly(IAssembly assembly, ModuleDef sourceModule) {
foreach (var gacInfo in GetGacInfos(sourceModule)) {
foreach (var path in FindAssembliesGacExactly(gacInfo, assembly, sourceModule))
yield return path;
}
if (extraMonoPaths != null) {
foreach (var path in GetExtraMonoPaths(assembly, sourceModule))
yield return path;
}
}
static IEnumerable GetExtraMonoPaths(IAssembly assembly, ModuleDef sourceModule) {
if (extraMonoPaths != null) {
foreach (var dir in extraMonoPaths) {
var file = Path.Combine(dir, assembly.Name + ".dll");
if (File.Exists(file))
yield return file;
}
}
}
IEnumerable FindAssembliesGacExactly(GacInfo gacInfo, IAssembly assembly, ModuleDef sourceModule) {
var pkt = PublicKeyBase.ToPublicKeyToken(assembly.PublicKeyOrToken);
if (gacInfo != null && pkt != null) {
string pktString = pkt.ToString();
string verString = Utils.CreateVersionWithNoUndefinedValues(assembly.Version).ToString();
var cultureString = UTF8String.ToSystemStringOrEmpty(assembly.Culture);
if (cultureString.Equals("neutral", StringComparison.OrdinalIgnoreCase))
cultureString = string.Empty;
var asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
foreach (var subDir in gacInfo.SubDirs) {
var baseDir = Path.Combine(gacInfo.Path, subDir);
baseDir = Path.Combine(baseDir, asmSimpleName);
baseDir = Path.Combine(baseDir, string.Format("{0}{1}_{2}_{3}", gacInfo.Prefix, verString, cultureString, pktString));
var pathName = Path.Combine(baseDir, asmSimpleName + ".dll");
if (File.Exists(pathName))
yield return pathName;
}
}
}
IEnumerable FindAssembliesGacAny(IAssembly assembly, ModuleDef sourceModule) {
foreach (var gacInfo in GetGacInfos(sourceModule)) {
foreach (var path in FindAssembliesGacAny(gacInfo, assembly, sourceModule))
yield return path;
}
if (extraMonoPaths != null) {
foreach (var path in GetExtraMonoPaths(assembly, sourceModule))
yield return path;
}
}
IEnumerable FindAssembliesGacAny(GacInfo gacInfo, IAssembly assembly, ModuleDef sourceModule) {
if (gacInfo != null) {
var asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
foreach (var subDir in gacInfo.SubDirs) {
var baseDir = Path.Combine(gacInfo.Path, subDir);
baseDir = Path.Combine(baseDir, asmSimpleName);
foreach (var dir in GetDirs(baseDir)) {
var pathName = Path.Combine(dir, asmSimpleName + ".dll");
if (File.Exists(pathName))
yield return pathName;
}
}
}
}
IEnumerable GetDirs(string baseDir) {
if (!Directory.Exists(baseDir))
return emtpyStringArray;
var dirs = new List();
try {
foreach (var di in new DirectoryInfo(baseDir).GetDirectories())
dirs.Add(di.FullName);
}
catch {
}
return dirs;
}
static readonly string[] emtpyStringArray = new string[0];
IEnumerable FindAssembliesModuleSearchPaths(IAssembly assembly, ModuleDef sourceModule, bool matchExactly) {
string asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
var searchPaths = GetSearchPaths(sourceModule);
var exts = assembly.IsContentTypeWindowsRuntime ? winMDAssemblyExtensions : assemblyExtensions;
foreach (var ext in exts) {
foreach (var path in searchPaths.GetSafeEnumerable()) {
for (int i = 0; i < 2; i++) {
string path2;
if (i == 0)
path2 = Path.Combine(path, asmSimpleName + ext);
else
path2 = Path.Combine(Path.Combine(path, asmSimpleName), asmSimpleName + ext);
if (File.Exists(path2))
yield return path2;
}
}
}
}
///
/// Gets all search paths to use for this module
///
/// The module or null if unknown
/// A list of all search paths to use for this module
IEnumerable GetSearchPaths(ModuleDef module) {
ModuleDef keyModule = module;
if (keyModule == null)
keyModule = nullModule;
IList searchPaths;
if (moduleSearchPaths.TryGetValue(keyModule, out searchPaths))
return searchPaths;
moduleSearchPaths[keyModule] = searchPaths = new List(GetModuleSearchPaths(module));
return searchPaths;
}
///
/// Gets all module search paths. This is usually empty unless its assembly has
/// a .config file specifying any additional private search paths in a
/// <probing/> element.
///
/// The module or null if unknown
/// A list of search paths
protected virtual IEnumerable GetModuleSearchPaths(ModuleDef module) {
return GetModulePrivateSearchPaths(module);
}
///
/// Gets all private assembly search paths as found in the module's .config file.
///
/// The module or null if unknown
/// A list of search paths
protected IEnumerable GetModulePrivateSearchPaths(ModuleDef module) {
if (module == null)
return new string[0];
var asm = module.Assembly;
if (asm == null)
return new string[0];
module = asm.ManifestModule;
if (module == null)
return new string[0]; // Should never happen
string baseDir = null;
try {
var imageName = module.Location;
if (imageName != string.Empty) {
baseDir = Directory.GetParent(imageName).FullName;
var configName = imageName + ".config";
if (File.Exists(configName))
return GetPrivatePaths(baseDir, configName);
}
}
catch {
}
if (baseDir != null)
return new List { baseDir };
return new string[0];
}
IEnumerable GetPrivatePaths(string baseDir, string configFileName) {
var searchPaths = new List();
try {
var dirName = Path.GetDirectoryName(Path.GetFullPath(configFileName));
searchPaths.Add(dirName);
using (var xmlStream = new FileStream(configFileName, FileMode.Open, FileAccess.Read, FileShare.Read)) {
var doc = new XmlDocument();
doc.Load(XmlReader.Create(xmlStream));
foreach (var tmp in doc.GetElementsByTagName("probing")) {
var probingElem = tmp as XmlElement;
if (probingElem == null)
continue;
var privatePath = probingElem.GetAttribute("privatePath");
if (string.IsNullOrEmpty(privatePath))
continue;
foreach (var tmp2 in privatePath.Split(';')) {
var path = tmp2.Trim();
if (path == "")
continue;
var newPath = Path.GetFullPath(Path.Combine(dirName, path.Replace('\\', Path.DirectorySeparatorChar)));
if (Directory.Exists(newPath) && newPath.StartsWith(baseDir + Path.DirectorySeparatorChar))
searchPaths.Add(newPath);
}
}
}
}
catch (ArgumentException) {
}
catch (IOException) {
}
catch (XmlException) {
}
return searchPaths;
}
///
/// Add other common search paths
///
/// A list that gets updated with the new paths
protected static void AddOtherSearchPaths(IList paths) {
var dirPF = Environment.GetEnvironmentVariable("ProgramFiles");
AddOtherAssemblySearchPaths(paths, dirPF);
var dirPFx86 = Environment.GetEnvironmentVariable("ProgramFiles(x86)");
if (!StringComparer.OrdinalIgnoreCase.Equals(dirPF, dirPFx86))
AddOtherAssemblySearchPaths(paths, dirPFx86);
var windir = Environment.GetEnvironmentVariable("WINDIR");
if (!string.IsNullOrEmpty(windir)) {
AddIfExists(paths, windir, @"Microsoft.NET\Framework\v1.1.4322");
AddIfExists(paths, windir, @"Microsoft.NET\Framework\v1.0.3705");
}
}
static void AddOtherAssemblySearchPaths(IList paths, string path) {
if (string.IsNullOrEmpty(path))
return;
AddSilverlightDirs(paths, Path.Combine(path, @"Microsoft Silverlight"));
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v2.0\Libraries\Client");
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v2.0\Libraries\Server");
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v2.0\Reference Assemblies");
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v3.0\Libraries\Client");
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v3.0\Libraries\Server");
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v4.0\Libraries\Client");
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v4.0\Libraries\Server");
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v5.0\Libraries\Client");
AddIfExists(paths, path, @"Microsoft SDKs\Silverlight\v5.0\Libraries\Server");
AddIfExists(paths, path, @"Microsoft.NET\SDK\CompactFramework\v2.0\WindowsCE");
AddIfExists(paths, path, @"Microsoft.NET\SDK\CompactFramework\v3.5\WindowsCE");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5.2");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\Profile\Client");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETFramework\v3.5\Profile\Client");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETCore\v5.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETCore\v4.5.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETCore\v4.5");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETMicroFramework\v3.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETMicroFramework\v4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETMicroFramework\v4.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETMicroFramework\v4.2");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETMicroFramework\v4.3");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETPortable\v4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETPortable\v4.5");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETPortable\v4.6");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\.NETPortable\v5.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\v3.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\v3.5");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\Silverlight\v3.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\Silverlight\v4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\Silverlight\v5.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\WindowsPhone\v8.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\Framework\WindowsPhoneApp\v8.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETCore\3.259.4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETCore\3.259.3.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETCore\3.78.4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETCore\3.78.3.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETCore\3.7.4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETCore\3.3.1.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETFramework\v2.0\2.3.0.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.0.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.1.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.4.0.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETPortable\2.3.5.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETPortable\2.3.5.1");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\.NETPortable\3.47.4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\2.0\Runtime\v2.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\2.0\Runtime\v4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\3.0\Runtime\.NETPortable");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\3.0\Runtime\v2.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\FSharp\3.0\Runtime\v4.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\WindowsPowerShell\v1.0");
AddIfExists(paths, path, @"Reference Assemblies\Microsoft\WindowsPowerShell\3.0");
AddIfExists(paths, path, @"Microsoft Visual Studio .NET\Common7\IDE\PublicAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio .NET\Common7\IDE\PrivateAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio .NET 2003\Common7\IDE\PublicAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio .NET 2003\Common7\IDE\PrivateAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 8\Common7\IDE\PublicAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 8\Common7\IDE\PrivateAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 10.0\Common7\IDE\PublicAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 11.0\Common7\IDE\PublicAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 11.0\Common7\IDE\PrivateAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 12.0\Common7\IDE\PublicAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 12.0\Common7\IDE\PrivateAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 14.0\Common7\IDE\PublicAssemblies");
AddIfExists(paths, path, @"Microsoft Visual Studio 14.0\Common7\IDE\PrivateAssemblies");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v2.0\References\Windows\x86");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v2.0\References\Xbox360");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v3.0\References\Windows\x86");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v3.0\References\Xbox360");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v3.0\References\Zune");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v3.1\References\Windows\x86");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v3.1\References\Xbox360");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v3.1\References\Zune");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v4.0\References\Windows\x86");
AddIfExists(paths, path, @"Microsoft XNA\XNA Game Studio\v4.0\References\Xbox360");
AddIfExists(paths, path, @"Windows CE Tools\wce500\Windows Mobile 5.0 Pocket PC SDK\Designtimereferences");
AddIfExists(paths, path, @"Windows CE Tools\wce500\Windows Mobile 5.0 Smartphone SDK\Designtimereferences");
AddIfExists(paths, path, @"Windows Mobile 5.0 SDK R2\Managed Libraries");
AddIfExists(paths, path, @"Windows Mobile 6 SDK\Managed Libraries");
AddIfExists(paths, path, @"Windows Mobile 6.5.3 DTK\Managed Libraries");
AddIfExists(paths, path, @"Microsoft SQL Server\90\SDK\Assemblies");
AddIfExists(paths, path, @"Microsoft SQL Server\100\SDK\Assemblies");
AddIfExists(paths, path, @"Microsoft SQL Server\110\SDK\Assemblies");
AddIfExists(paths, path, @"Microsoft SQL Server\120\SDK\Assemblies");
AddIfExists(paths, path, @"Microsoft ASP.NET\ASP.NET MVC 2\Assemblies");
AddIfExists(paths, path, @"Microsoft ASP.NET\ASP.NET MVC 3\Assemblies");
AddIfExists(paths, path, @"Microsoft ASP.NET\ASP.NET MVC 4\Assemblies");
AddIfExists(paths, path, @"Microsoft ASP.NET\ASP.NET Web Pages\v1.0\Assemblies");
AddIfExists(paths, path, @"Microsoft ASP.NET\ASP.NET Web Pages\v2.0\Assemblies");
AddIfExists(paths, path, @"Microsoft SDKs\F#\3.0\Framework\v4.0");
}
static void AddSilverlightDirs(IList paths, string basePath) {
if (!Directory.Exists(basePath))
return;
try {
var di = new DirectoryInfo(basePath);
foreach (var dir in di.GetDirectories()) {
if (Regex.IsMatch(dir.Name, @"^\d+(?:\.\d+){3}$"))
AddIfExists(paths, basePath, dir.Name);
}
}
catch {
}
}
static void AddIfExists(IList paths, string basePath, string extraPath) {
var path = Path.Combine(basePath, extraPath);
if (Directory.Exists(path))
paths.Add(path);
}
}
}
dnlib-2.1_VS2010/src/DotNet/CallingConvention.cs 0000664 0000000 0000000 00000002212 13250336635 0021311 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
namespace dnlib.DotNet {
///
/// See CorHdr.h/CorCallingConvention
///
[Flags]
public enum CallingConvention : byte {
/// The managed calling convention
Default = 0x0,
///
C = 0x1,
///
StdCall = 0x2,
///
ThisCall = 0x3,
///
FastCall = 0x4,
///
VarArg = 0x5,
///
Field = 0x6,
///
LocalSig = 0x7,
///
Property = 0x8,
///
Unmanaged = 0x9,
/// generic method instantiation
GenericInst = 0xA,
/// used ONLY for 64bit vararg PInvoke calls
NativeVarArg = 0xB,
/// Calling convention is bottom 4 bits
Mask = 0x0F,
/// Generic method
Generic = 0x10,
/// Method needs a 'this' parameter
HasThis = 0x20,
/// 'this' parameter is the first arg if set (else it's hidden)
ExplicitThis = 0x40,
/// Used internally by the CLR
ReservedByCLR = 0x80,
}
}
dnlib-2.1_VS2010/src/DotNet/CallingConventionSig.cs 0000664 0000000 0000000 00000116354 13250336635 0021771 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System.Collections.Generic;
using dnlib.Threading;
#if THREAD_SAFE
using ThreadSafe = dnlib.Threading.Collections;
#else
using ThreadSafe = System.Collections.Generic;
#endif
/*
All signature classes:
CallingConventionSig
FieldSig
MethodBaseSig
MethodSig
PropertySig
LocalSig
GenericInstMethodSig
*/
namespace dnlib.DotNet {
///
/// Base class for sigs with a calling convention
///
public abstract class CallingConventionSig : IContainsGenericParameter {
///
/// The calling convention
///
protected CallingConvention callingConvention;
byte[] extraData;
///
/// Gets/sets the extra data found after the signature
///
public byte[] ExtraData {
get { return extraData; }
set { extraData = value; }
}
///
/// Returns true if is set
///
public bool IsDefault {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.Default; }
}
///
/// Returns true if is set
///
public bool IsC {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.C; }
}
///
/// Returns true if is set
///
public bool IsStdCall {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.StdCall; }
}
///
/// Returns true if is set
///
public bool IsThisCall {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.ThisCall; }
}
///
/// Returns true if is set
///
public bool IsFastCall {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.FastCall; }
}
///
/// Returns true if is set
///
public bool IsVarArg {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.VarArg; }
}
///
/// Returns true if is set
///
public bool IsField {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.Field; }
}
///
/// Returns true if is set
///
public bool IsLocalSig {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.LocalSig; }
}
///
/// Returns true if is set
///
public bool IsProperty {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.Property; }
}
///
/// Returns true if is set
///
public bool IsUnmanaged {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.Unmanaged; }
}
///
/// Returns true if is set
///
public bool IsGenericInst {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.GenericInst; }
}
///
/// Returns true if is set
///
public bool IsNativeVarArg {
get { return (callingConvention & CallingConvention.Mask) == CallingConvention.NativeVarArg; }
}
///
/// Gets/sets the bit
///
public bool Generic {
get { return (callingConvention & CallingConvention.Generic) != 0; }
set {
if (value)
callingConvention |= CallingConvention.Generic;
else
callingConvention &= ~CallingConvention.Generic;
}
}
///
/// Gets/sets the bit
///
public bool HasThis {
get { return (callingConvention & CallingConvention.HasThis) != 0; }
set {
if (value)
callingConvention |= CallingConvention.HasThis;
else
callingConvention &= ~CallingConvention.HasThis;
}
}
///
/// Gets/sets the bit
///
public bool ExplicitThis {
get { return (callingConvention & CallingConvention.ExplicitThis) != 0; }
set {
if (value)
callingConvention |= CallingConvention.ExplicitThis;
else
callingConvention &= ~CallingConvention.ExplicitThis;
}
}
///
/// Gets/sets the bit
///
public bool ReservedByCLR {
get { return (callingConvention & CallingConvention.ReservedByCLR) != 0; }
set {
if (value)
callingConvention |= CallingConvention.ReservedByCLR;
else
callingConvention &= ~CallingConvention.ReservedByCLR;
}
}
///
/// true if there's an implicit this parameter
///
public bool ImplicitThis {
get { return HasThis && !ExplicitThis; }
}
///
/// true if this contains a
/// or a .
///
public bool ContainsGenericParameter {
get { return TypeHelper.ContainsGenericParameter(this); }
}
///
/// Default constructor
///
protected CallingConventionSig() {
}
///
/// Constructor
///
/// The calling convention
protected CallingConventionSig(CallingConvention callingConvention) {
this.callingConvention = callingConvention;
}
///
/// Gets the calling convention
///
public CallingConvention GetCallingConvention() {
return callingConvention;
}
}
///
/// A field signature
///
public sealed class FieldSig : CallingConventionSig {
TypeSig type;
///
/// Gets/sets the field type
///
public TypeSig Type {
get { return type; }
set { type = value; }
}
///
/// Default constructor
///
public FieldSig() {
this.callingConvention = CallingConvention.Field;
}
///
/// Constructor
///
/// Field type
public FieldSig(TypeSig type) {
this.callingConvention = CallingConvention.Field;
this.type = type;
}
///
/// Constructor
///
/// Field type
/// The calling convention (must have Field set)
internal FieldSig(CallingConvention callingConvention, TypeSig type) {
this.callingConvention = callingConvention;
this.type = type;
}
///
/// Clone this
///
public FieldSig Clone() {
return new FieldSig(callingConvention, type);
}
///
public override string ToString() {
return FullNameCreator.FullName(type == null ? null : type, false, null, null, null, null);
}
}
///
/// Method sig base class
///
public abstract class MethodBaseSig : CallingConventionSig {
///
protected TypeSig retType;
///
protected ThreadSafe.IList parameters;
///
protected uint genParamCount;
///
protected ThreadSafe.IList paramsAfterSentinel;
///
/// Gets/sets the calling convention
///
public CallingConvention CallingConvention {
get { return callingConvention; }
set { callingConvention = value; }
}
///
/// Gets/sets the return type
///
public TypeSig RetType {
get { return retType; }
set { retType = value; }
}
///
/// Gets the parameters. This is never null
///
public ThreadSafe.IList Params {
get { return parameters; }
}
///
/// Gets/sets the generic param count
///
public uint GenParamCount {
get { return genParamCount; }
set { genParamCount = value; }
}
///
/// Gets the parameters that are present after the sentinel. Note that this is null
/// if there's no sentinel. It can still be empty even if it's not null.
///
public ThreadSafe.IList ParamsAfterSentinel {
get { return paramsAfterSentinel; }
set { paramsAfterSentinel = value; }
}
}
///
/// A method signature
///
public sealed class MethodSig : MethodBaseSig {
uint origToken;
///
/// Gets/sets the original token. It's set when reading calli instruction operands
/// and it's a hint to the module writer if it tries to re-use the same token.
///
public uint OriginalToken {
get { return origToken; }
set { origToken = value; }
}
///
/// Creates a static MethodSig
///
/// Return type
public static MethodSig CreateStatic(TypeSig retType) {
return new MethodSig(CallingConvention.Default, 0, retType);
}
///
/// Creates a static MethodSig
///
/// Return type
/// Arg type #1
public static MethodSig CreateStatic(TypeSig retType, TypeSig argType1) {
return new MethodSig(CallingConvention.Default, 0, retType, argType1);
}
///
/// Creates a static MethodSig
///
/// Return type
/// Arg type #1
/// Arg type #2
public static MethodSig CreateStatic(TypeSig retType, TypeSig argType1, TypeSig argType2) {
return new MethodSig(CallingConvention.Default, 0, retType, argType1, argType2);
}
///
/// Creates a static MethodSig
///
/// Return type
/// Arg type #1
/// Arg type #2
/// Arg type #3
public static MethodSig CreateStatic(TypeSig retType, TypeSig argType1, TypeSig argType2, TypeSig argType3) {
return new MethodSig(CallingConvention.Default, 0, retType, argType1, argType2, argType3);
}
///
/// Creates a static MethodSig
///
/// Return type
/// Argument types
public static MethodSig CreateStatic(TypeSig retType, params TypeSig[] argTypes) {
return new MethodSig(CallingConvention.Default, 0, retType, argTypes);
}
///
/// Creates an instance MethodSig
///
/// Return type
public static MethodSig CreateInstance(TypeSig retType) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis, 0, retType);
}
///
/// Creates an instance MethodSig
///
/// Return type
/// Arg type #1
public static MethodSig CreateInstance(TypeSig retType, TypeSig argType1) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis, 0, retType, argType1);
}
///
/// Creates an instance MethodSig
///
/// Return type
/// Arg type #1
/// Arg type #2
public static MethodSig CreateInstance(TypeSig retType, TypeSig argType1, TypeSig argType2) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis, 0, retType, argType1, argType2);
}
///
/// Creates an instance MethodSig
///
/// Return type
/// Arg type #1
/// Arg type #2
/// Arg type #3
public static MethodSig CreateInstance(TypeSig retType, TypeSig argType1, TypeSig argType2, TypeSig argType3) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis, 0, retType, argType1, argType2, argType3);
}
///
/// Creates an instance MethodSig
///
/// Return type
/// Argument types
public static MethodSig CreateInstance(TypeSig retType, params TypeSig[] argTypes) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis, 0, retType, argTypes);
}
///
/// Creates a static generic MethodSig
///
/// Number of generic parameters
/// Return type
public static MethodSig CreateStaticGeneric(uint genParamCount, TypeSig retType) {
return new MethodSig(CallingConvention.Default | CallingConvention.Generic, genParamCount, retType);
}
///
/// Creates a static generic MethodSig
///
/// Number of generic parameters
/// Return type
/// Arg type #1
public static MethodSig CreateStaticGeneric(uint genParamCount, TypeSig retType, TypeSig argType1) {
return new MethodSig(CallingConvention.Default | CallingConvention.Generic, genParamCount, retType, argType1);
}
///
/// Creates a static generic MethodSig
///
/// Number of generic parameters
/// Return type
/// Arg type #1
/// Arg type #2
public static MethodSig CreateStaticGeneric(uint genParamCount, TypeSig retType, TypeSig argType1, TypeSig argType2) {
return new MethodSig(CallingConvention.Default | CallingConvention.Generic, genParamCount, retType, argType1, argType2);
}
///
/// Creates a static generic MethodSig
///
/// Number of generic parameters
/// Return type
/// Arg type #1
/// Arg type #2
/// Arg type #3
public static MethodSig CreateStaticGeneric(uint genParamCount, TypeSig retType, TypeSig argType1, TypeSig argType2, TypeSig argType3) {
return new MethodSig(CallingConvention.Default | CallingConvention.Generic, genParamCount, retType, argType1, argType2, argType3);
}
///
/// Creates a static generic MethodSig
///
/// Number of generic parameters
/// Return type
/// Argument types
public static MethodSig CreateStaticGeneric(uint genParamCount, TypeSig retType, params TypeSig[] argTypes) {
return new MethodSig(CallingConvention.Default | CallingConvention.Generic, genParamCount, retType, argTypes);
}
///
/// Creates an instance generic MethodSig
///
/// Number of generic parameters
/// Return type
public static MethodSig CreateInstanceGeneric(uint genParamCount, TypeSig retType) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis | CallingConvention.Generic, genParamCount, retType);
}
///
/// Creates an instance generic MethodSig
///
/// Number of generic parameters
/// Return type
/// Arg type #1
public static MethodSig CreateInstanceGeneric(uint genParamCount, TypeSig retType, TypeSig argType1) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis | CallingConvention.Generic, genParamCount, retType, argType1);
}
///
/// Creates an instance generic MethodSig
///
/// Number of generic parameters
/// Return type
/// Arg type #1
/// Arg type #2
public static MethodSig CreateInstanceGeneric(uint genParamCount, TypeSig retType, TypeSig argType1, TypeSig argType2) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis | CallingConvention.Generic, genParamCount, retType, argType1, argType2);
}
///
/// Creates an instance generic MethodSig
///
/// Number of generic parameters
/// Return type
/// Arg type #1
/// Arg type #2
/// Arg type #3
public static MethodSig CreateInstanceGeneric(uint genParamCount, TypeSig retType, TypeSig argType1, TypeSig argType2, TypeSig argType3) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis | CallingConvention.Generic, genParamCount, retType, argType1, argType2, argType3);
}
///
/// Creates an instance generic MethodSig
///
/// Number of generic parameters
/// Return type
/// Argument types
public static MethodSig CreateInstanceGeneric(uint genParamCount, TypeSig retType, params TypeSig[] argTypes) {
return new MethodSig(CallingConvention.Default | CallingConvention.HasThis | CallingConvention.Generic, genParamCount, retType, argTypes);
}
///
/// Default constructor
///
public MethodSig() {
this.parameters = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// Calling convention
public MethodSig(CallingConvention callingConvention) {
this.callingConvention = callingConvention;
this.parameters = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
public MethodSig(CallingConvention callingConvention, uint genParamCount) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.parameters = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
/// Return type
public MethodSig(CallingConvention callingConvention, uint genParamCount, TypeSig retType) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
/// Return type
/// Arg type #1
public MethodSig(CallingConvention callingConvention, uint genParamCount, TypeSig retType, TypeSig argType1) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argType1);
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
/// Return type
/// Arg type #1
/// Arg type #2
public MethodSig(CallingConvention callingConvention, uint genParamCount, TypeSig retType, TypeSig argType1, TypeSig argType2) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argType1, argType2);
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
/// Return type
/// Arg type #1
/// Arg type #2
/// Arg type #3
public MethodSig(CallingConvention callingConvention, uint genParamCount, TypeSig retType, TypeSig argType1, TypeSig argType2, TypeSig argType3) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argType1, argType2, argType3);
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
/// Return type
/// Argument types
public MethodSig(CallingConvention callingConvention, uint genParamCount, TypeSig retType, params TypeSig[] argTypes) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argTypes);
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
/// Return type
/// Argument types
public MethodSig(CallingConvention callingConvention, uint genParamCount, TypeSig retType, IList argTypes) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argTypes);
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
/// Return type
/// Argument types
/// Parameters after sentinel
public MethodSig(CallingConvention callingConvention, uint genParamCount, TypeSig retType, IList argTypes, IList paramsAfterSentinel) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argTypes);
this.paramsAfterSentinel = paramsAfterSentinel == null ? null : ThreadSafeListCreator.Create(paramsAfterSentinel);
}
///
/// Clone this
///
public MethodSig Clone() {
return new MethodSig(callingConvention, genParamCount, retType, parameters, paramsAfterSentinel);
}
///
public override string ToString() {
return FullNameCreator.MethodBaseSigFullName(this, null);
}
}
///
/// A property signature
///
public sealed class PropertySig : MethodBaseSig {
///
/// Creates a static PropertySig
///
/// Return type
public static PropertySig CreateStatic(TypeSig retType) {
return new PropertySig(false, retType);
}
///
/// Creates a static PropertySig
///
/// Return type
/// Arg type #1
public static PropertySig CreateStatic(TypeSig retType, TypeSig argType1) {
return new PropertySig(false, retType, argType1);
}
///
/// Creates a static PropertySig
///
/// Return type
/// Arg type #1
/// Arg type #2
public static PropertySig CreateStatic(TypeSig retType, TypeSig argType1, TypeSig argType2) {
return new PropertySig(false, retType, argType1, argType2);
}
///
/// Creates a static PropertySig
///
/// Return type
/// Arg type #1
/// Arg type #2
/// Arg type #3
public static PropertySig CreateStatic(TypeSig retType, TypeSig argType1, TypeSig argType2, TypeSig argType3) {
return new PropertySig(false, retType, argType1, argType2, argType3);
}
///
/// Creates a static PropertySig
///
/// Return type
/// Argument types
public static PropertySig CreateStatic(TypeSig retType, params TypeSig[] argTypes) {
return new PropertySig(false, retType, argTypes);
}
///
/// Creates an instance PropertySig
///
/// Return type
public static PropertySig CreateInstance(TypeSig retType) {
return new PropertySig(true, retType);
}
///
/// Creates an instance PropertySig
///
/// Return type
/// Arg type #1
public static PropertySig CreateInstance(TypeSig retType, TypeSig argType1) {
return new PropertySig(true, retType, argType1);
}
///
/// Creates an instance PropertySig
///
/// Return type
/// Arg type #1
/// Arg type #2
public static PropertySig CreateInstance(TypeSig retType, TypeSig argType1, TypeSig argType2) {
return new PropertySig(true, retType, argType1, argType2);
}
///
/// Creates an instance PropertySig
///
/// Return type
/// Arg type #1
/// Arg type #2
/// Arg type #3
public static PropertySig CreateInstance(TypeSig retType, TypeSig argType1, TypeSig argType2, TypeSig argType3) {
return new PropertySig(true, retType, argType1, argType2, argType3);
}
///
/// Creates an instance PropertySig
///
/// Return type
/// Argument types
public static PropertySig CreateInstance(TypeSig retType, params TypeSig[] argTypes) {
return new PropertySig(true, retType, argTypes);
}
///
/// Default constructor
///
public PropertySig() {
this.callingConvention = CallingConvention.Property;
this.parameters = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// Calling convention (must have Property set)
internal PropertySig(CallingConvention callingConvention) {
this.callingConvention = callingConvention;
this.parameters = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// true if instance, false if static
public PropertySig(bool hasThis) {
this.callingConvention = CallingConvention.Property | (hasThis ? CallingConvention.HasThis : 0);
this.parameters = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// true if instance, false if static
/// Return type
public PropertySig(bool hasThis, TypeSig retType) {
this.callingConvention = CallingConvention.Property | (hasThis ? CallingConvention.HasThis : 0);
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// true if instance, false if static
/// Return type
/// Arg type #1
public PropertySig(bool hasThis, TypeSig retType, TypeSig argType1) {
this.callingConvention = CallingConvention.Property | (hasThis ? CallingConvention.HasThis : 0);
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argType1);
}
///
/// Constructor
///
/// true if instance, false if static
/// Return type
/// Arg type #1
/// Arg type #2
public PropertySig(bool hasThis, TypeSig retType, TypeSig argType1, TypeSig argType2) {
this.callingConvention = CallingConvention.Property | (hasThis ? CallingConvention.HasThis : 0);
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argType1, argType2);
}
///
/// Constructor
///
/// true if instance, false if static
/// Return type
/// Arg type #1
/// Arg type #2
/// Arg type #3
public PropertySig(bool hasThis, TypeSig retType, TypeSig argType1, TypeSig argType2, TypeSig argType3) {
this.callingConvention = CallingConvention.Property | (hasThis ? CallingConvention.HasThis : 0);
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argType1, argType2, argType3);
}
///
/// Constructor
///
/// true if instance, false if static
/// Return type
/// Argument types
public PropertySig(bool hasThis, TypeSig retType, params TypeSig[] argTypes) {
this.callingConvention = CallingConvention.Property | (hasThis ? CallingConvention.HasThis : 0);
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argTypes);
}
///
/// Constructor
///
/// Calling convention
/// Number of generic parameters
/// Return type
/// Argument types
/// Parameters after sentinel
internal PropertySig(CallingConvention callingConvention, uint genParamCount, TypeSig retType, IList argTypes, IList paramsAfterSentinel) {
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.retType = retType;
this.parameters = ThreadSafeListCreator.Create(argTypes);
this.paramsAfterSentinel = paramsAfterSentinel == null ? null : ThreadSafeListCreator.Create(paramsAfterSentinel);
}
///
/// Clone this
///
public PropertySig Clone() {
return new PropertySig(callingConvention, genParamCount, retType, parameters, paramsAfterSentinel);
}
///
public override string ToString() {
return FullNameCreator.MethodBaseSigFullName(this, null);
}
}
///
/// A local variables signature
///
public sealed class LocalSig : CallingConventionSig {
readonly ThreadSafe.IList locals;
///
/// All local types. This is never null.
///
public ThreadSafe.IList Locals {
get { return locals; }
}
///
/// Default constructor
///
public LocalSig() {
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// Calling convention (must have LocalSig set)
/// Number of locals
internal LocalSig(CallingConvention callingConvention, uint count) {
this.callingConvention = callingConvention;
this.locals = ThreadSafeListCreator.Create((int)count);
}
///
/// Constructor
///
/// Local type #1
public LocalSig(TypeSig local1) {
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.Create(local1);
}
///
/// Constructor
///
/// Local type #1
/// Local type #2
public LocalSig(TypeSig local1, TypeSig local2) {
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.Create(local1, local2);
}
///
/// Constructor
///
/// Local type #1
/// Local type #2
/// Local type #3
public LocalSig(TypeSig local1, TypeSig local2, TypeSig local3) {
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.Create(local1, local2, local3);
}
///
/// Constructor
///
/// All locals
public LocalSig(params TypeSig[] locals) {
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.Create(locals);
}
///
/// Constructor
///
/// All locals
public LocalSig(IList locals) {
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.Create(locals);
}
///
/// Constructor
///
/// All locals (this instance now owns it)
/// Dummy
internal LocalSig(IList locals, bool dummy) {
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.MakeThreadSafe(locals);
}
///
/// Clone this
///
public LocalSig Clone() {
return new LocalSig(locals);
}
}
///
/// An instantiated generic method signature
///
public sealed class GenericInstMethodSig : CallingConventionSig {
readonly ThreadSafe.IList genericArgs;
///
/// Gets the generic arguments (must be instantiated types, i.e., closed types)
///
public ThreadSafe.IList GenericArguments {
get { return genericArgs; }
}
///
/// Default constructor
///
public GenericInstMethodSig() {
this.callingConvention = CallingConvention.GenericInst;
this.genericArgs = ThreadSafeListCreator.Create();
}
///
/// Constructor
///
/// Calling convention (must have GenericInst set)
/// Number of generic args
internal GenericInstMethodSig(CallingConvention callingConvention, uint size) {
this.callingConvention = callingConvention;
this.genericArgs = ThreadSafeListCreator.Create((int)size);
}
///
/// Constructor
///
/// Generic arg #1
public GenericInstMethodSig(TypeSig arg1) {
this.callingConvention = CallingConvention.GenericInst;
this.genericArgs = ThreadSafeListCreator.Create(arg1);
}
///
/// Constructor
///
/// Generic arg #1
/// Generic arg #2
public GenericInstMethodSig(TypeSig arg1, TypeSig arg2) {
this.callingConvention = CallingConvention.GenericInst;
this.genericArgs = ThreadSafeListCreator.Create(arg1, arg2);
}
///
/// Constructor
///
/// Generic arg #1
/// Generic arg #2
/// Generic arg #3
public GenericInstMethodSig(TypeSig arg1, TypeSig arg2, TypeSig arg3) {
this.callingConvention = CallingConvention.GenericInst;
this.genericArgs = ThreadSafeListCreator.Create(arg1, arg2, arg3);
}
///
/// Constructor
///
/// Generic args
public GenericInstMethodSig(params TypeSig[] args) {
this.callingConvention = CallingConvention.GenericInst;
this.genericArgs = ThreadSafeListCreator.Create(args);
}
///
/// Constructor
///
/// Generic args
public GenericInstMethodSig(IList args) {
this.callingConvention = CallingConvention.GenericInst;
this.genericArgs = ThreadSafeListCreator.Create(args);
}
///
/// Clone this
///
public GenericInstMethodSig Clone() {
return new GenericInstMethodSig(genericArgs);
}
}
public static partial class Extensions {
///
/// Gets the field type
///
/// this
/// Field type or null if none
public static TypeSig GetFieldType(this FieldSig sig) {
return sig == null ? null : sig.Type;
}
///
/// Gets the return type
///
/// this
/// Return type or null if none
public static TypeSig GetRetType(this MethodBaseSig sig) {
return sig == null ? null : sig.RetType;
}
///
/// Gets the parameters
///
/// this
/// The parameters
public static IList GetParams(this MethodBaseSig sig) {
return sig == null ? ThreadSafeListCreator.Create() : sig.Params;
}
///
/// Gets the parameter count
///
/// this
/// Parameter count
public static int GetParamCount(this MethodBaseSig sig) {
return sig == null ? 0 : sig.Params.Count;
}
///
/// Gets the generic parameter count
///
/// this
/// Generic parameter count
public static uint GetGenParamCount(this MethodBaseSig sig) {
return sig == null ? 0 : sig.GenParamCount;
}
///
/// Gets the parameters after the sentinel
///
/// this
/// Parameters after sentinel or null if none
public static IList GetParamsAfterSentinel(this MethodBaseSig sig) {
return sig == null ? null : sig.ParamsAfterSentinel;
}
///
/// Gets the locals
///
/// this
/// All locals
public static IList GetLocals(this LocalSig sig) {
return sig == null ? ThreadSafeListCreator.Create() : sig.Locals;
}
///
/// Gets the generic arguments
///
/// this
/// All generic arguments
public static IList GetGenericArguments(this GenericInstMethodSig sig) {
return sig == null ? ThreadSafeListCreator.Create() : sig.GenericArguments;
}
///
/// Gets the property
///
/// this
/// The type's property or
/// false if input isnull
public static bool GetIsDefault(this CallingConventionSig sig) {
return sig == null ? false : sig.IsDefault;
}
}
}
dnlib-2.1_VS2010/src/DotNet/ClassLayout.cs 0000664 0000000 0000000 00000005077 13250336635 0020154 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using dnlib.DotNet.MD;
namespace dnlib.DotNet {
///
/// A high-level representation of a row in the ClassLayout table
///
public abstract class ClassLayout : IMDTokenProvider {
///
/// The row id in its table
///
protected uint rid;
///
public MDToken MDToken {
get { return new MDToken(Table.ClassLayout, rid); }
}
///
public uint Rid {
get { return rid; }
set { rid = value; }
}
///
/// From column ClassLayout.PackingSize
///
public ushort PackingSize {
get { return packingSize; }
set { packingSize = value; }
}
///
protected ushort packingSize;
///
/// From column ClassLayout.ClassSize
///
public uint ClassSize {
get { return classSize; }
set { classSize = value; }
}
///
protected uint classSize;
}
///
/// A ClassLayout row created by the user and not present in the original .NET file
///
public class ClassLayoutUser : ClassLayout {
///
/// Default constructor
///
public ClassLayoutUser() {
}
///
/// Constructor
///
/// PackingSize
/// ClassSize
public ClassLayoutUser(ushort packingSize, uint classSize) {
this.packingSize = packingSize;
this.classSize = classSize;
}
}
///
/// Created from a row in the ClassLayout table
///
sealed class ClassLayoutMD : ClassLayout, IMDTokenProviderMD {
readonly uint origRid;
///
public uint OrigRid {
get { return origRid; }
}
///
/// Constructor
///
/// The module which contains this ClassLayout row
/// Row ID
/// If is null
/// If is invalid
public ClassLayoutMD(ModuleDefMD readerModule, uint rid) {
#if DEBUG
if (readerModule == null)
throw new ArgumentNullException("readerModule");
if (readerModule.TablesStream.ClassLayoutTable.IsInvalidRID(rid))
throw new BadImageFormatException(string.Format("ClassLayout rid {0} does not exist", rid));
#endif
this.origRid = rid;
this.rid = rid;
this.classSize = readerModule.TablesStream.ReadClassLayoutRow(origRid, out this.packingSize);
}
}
}
dnlib-2.1_VS2010/src/DotNet/Constant.cs 0000664 0000000 0000000 00000012502 13250336635 0017471 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Text;
using dnlib.DotNet.MD;
namespace dnlib.DotNet {
///
/// A high-level representation of a row in the Constant table
///
public abstract class Constant : IMDTokenProvider {
///
/// The row id in its table
///
protected uint rid;
///
public MDToken MDToken {
get { return new MDToken(Table.Constant, rid); }
}
///
public uint Rid {
get { return rid; }
set { rid = value; }
}
///
/// From column Constant.Type
///
public ElementType Type {
get { return type; }
set { type = value; }
}
///
protected ElementType type;
///
/// From column Constant.Value
///
public object Value {
get { return value; }
set { this.value = value; }
}
///
protected object value;
}
///
/// A Constant row created by the user and not present in the original .NET file
///
public class ConstantUser : Constant {
///
/// Default constructor
///
public ConstantUser() {
}
///
/// Constructor
///
/// Value
public ConstantUser(object value) {
this.type = GetElementType(value);
this.value = value;
}
///
/// Constructor
///
/// Value
/// Type
public ConstantUser(object value, ElementType type) {
this.type = type;
this.value = value;
}
static ElementType GetElementType(object value) {
if (value == null)
return ElementType.Class;
switch (System.Type.GetTypeCode(value.GetType())) {
case TypeCode.Boolean: return ElementType.Boolean;
case TypeCode.Char: return ElementType.Char;
case TypeCode.SByte: return ElementType.I1;
case TypeCode.Byte: return ElementType.U1;
case TypeCode.Int16: return ElementType.I2;
case TypeCode.UInt16: return ElementType.U2;
case TypeCode.Int32: return ElementType.I4;
case TypeCode.UInt32: return ElementType.U4;
case TypeCode.Int64: return ElementType.I8;
case TypeCode.UInt64: return ElementType.U8;
case TypeCode.Single: return ElementType.R4;
case TypeCode.Double: return ElementType.R8;
case TypeCode.String: return ElementType.String;
default: return ElementType.Void;
}
}
}
///
/// Created from a row in the Constant table
///
sealed class ConstantMD : Constant, IMDTokenProviderMD {
readonly uint origRid;
///
public uint OrigRid {
get { return origRid; }
}
///
/// Constructor
///
/// The module which contains this Constant row
/// Row ID
/// If is null
/// If is invalid
public ConstantMD(ModuleDefMD readerModule, uint rid) {
#if DEBUG
if (readerModule == null)
throw new ArgumentNullException("readerModule");
if (readerModule.TablesStream.ConstantTable.IsInvalidRID(rid))
throw new BadImageFormatException(string.Format("Constant rid {0} does not exist", rid));
#endif
this.origRid = rid;
this.rid = rid;
uint value = readerModule.TablesStream.ReadConstantRow(origRid, out this.type);
this.value = GetValue(this.type, readerModule.BlobStream.ReadNoNull(value));
}
static object GetValue(ElementType etype, byte[] data) {
switch (etype) {
case ElementType.Boolean:
if (data == null || data.Length < 1)
return false;
return BitConverter.ToBoolean(data, 0);
case ElementType.Char:
if (data == null || data.Length < 2)
return (char)0;
return BitConverter.ToChar(data, 0);
case ElementType.I1:
if (data == null || data.Length < 1)
return (sbyte)0;
return (sbyte)data[0];
case ElementType.U1:
if (data == null || data.Length < 1)
return (byte)0;
return data[0];
case ElementType.I2:
if (data == null || data.Length < 2)
return (short)0;
return BitConverter.ToInt16(data, 0);
case ElementType.U2:
if (data == null || data.Length < 2)
return (ushort)0;
return BitConverter.ToUInt16(data, 0);
case ElementType.I4:
if (data == null || data.Length < 4)
return (int)0;
return BitConverter.ToInt32(data, 0);
case ElementType.U4:
if (data == null || data.Length < 4)
return (uint)0;
return BitConverter.ToUInt32(data, 0);
case ElementType.I8:
if (data == null || data.Length < 8)
return (long)0;
return BitConverter.ToInt64(data, 0);
case ElementType.U8:
if (data == null || data.Length < 8)
return (ulong)0;
return BitConverter.ToUInt64(data, 0);
case ElementType.R4:
if (data == null || data.Length < 4)
return (float)0;
return BitConverter.ToSingle(data, 0);
case ElementType.R8:
if (data == null || data.Length < 8)
return (double)0;
return BitConverter.ToDouble(data, 0);
case ElementType.String:
if (data == null)
return string.Empty;
return Encoding.Unicode.GetString(data, 0, data.Length / 2 * 2);
case ElementType.Class:
return null;
default:
return null;
}
}
}
}
dnlib-2.1_VS2010/src/DotNet/CorLibTypes.cs 0000664 0000000 0000000 00000012421 13250336635 0020077 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
namespace dnlib.DotNet {
///
/// Default implementation of
///
public sealed class CorLibTypes : ICorLibTypes {
readonly ModuleDef module;
CorLibTypeSig typeVoid;
CorLibTypeSig typeBoolean;
CorLibTypeSig typeChar;
CorLibTypeSig typeSByte;
CorLibTypeSig typeByte;
CorLibTypeSig typeInt16;
CorLibTypeSig typeUInt16;
CorLibTypeSig typeInt32;
CorLibTypeSig typeUInt32;
CorLibTypeSig typeInt64;
CorLibTypeSig typeUInt64;
CorLibTypeSig typeSingle;
CorLibTypeSig typeDouble;
CorLibTypeSig typeString;
CorLibTypeSig typeTypedReference;
CorLibTypeSig typeIntPtr;
CorLibTypeSig typeUIntPtr;
CorLibTypeSig typeObject;
readonly AssemblyRef corLibAssemblyRef;
///
public CorLibTypeSig Void {
get { return typeVoid; }
}
///
public CorLibTypeSig Boolean {
get { return typeBoolean; }
}
///
public CorLibTypeSig Char {
get { return typeChar; }
}
///
public CorLibTypeSig SByte {
get { return typeSByte; }
}
///
public CorLibTypeSig Byte {
get { return typeByte; }
}
///
public CorLibTypeSig Int16 {
get { return typeInt16; }
}
///
public CorLibTypeSig UInt16 {
get { return typeUInt16; }
}
///
public CorLibTypeSig Int32 {
get { return typeInt32; }
}
///
public CorLibTypeSig UInt32 {
get { return typeUInt32; }
}
///
public CorLibTypeSig Int64 {
get { return typeInt64; }
}
///
public CorLibTypeSig UInt64 {
get { return typeUInt64; }
}
///
public CorLibTypeSig Single {
get { return typeSingle; }
}
///
public CorLibTypeSig Double {
get { return typeDouble; }
}
///
public CorLibTypeSig String {
get { return typeString; }
}
///
public CorLibTypeSig TypedReference {
get { return typeTypedReference; }
}
///
public CorLibTypeSig IntPtr {
get { return typeIntPtr; }
}
///
public CorLibTypeSig UIntPtr {
get { return typeUIntPtr; }
}
///
public CorLibTypeSig Object {
get { return typeObject; }
}
///
public AssemblyRef AssemblyRef {
get { return corLibAssemblyRef; }
}
///
/// Constructor
///
/// The owner module
public CorLibTypes(ModuleDef module)
: this(module, null) {
}
///
/// Constructor
///
/// The owner module
/// Corlib assembly reference or null if a default
/// assembly reference should be created
public CorLibTypes(ModuleDef module, AssemblyRef corLibAssemblyRef) {
this.module = module;
this.corLibAssemblyRef = corLibAssemblyRef ?? CreateCorLibAssemblyRef();
Initialize();
}
AssemblyRef CreateCorLibAssemblyRef() {
return module.UpdateRowId(AssemblyRefUser.CreateMscorlibReferenceCLR20());
}
void Initialize() {
bool isCorLib = module.Assembly.IsCorLib();
typeVoid = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Void"), ElementType.Void);
typeBoolean = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Boolean"), ElementType.Boolean);
typeChar = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Char"), ElementType.Char);
typeSByte = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "SByte"), ElementType.I1);
typeByte = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Byte"), ElementType.U1);
typeInt16 = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Int16"), ElementType.I2);
typeUInt16 = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "UInt16"), ElementType.U2);
typeInt32 = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Int32"), ElementType.I4);
typeUInt32 = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "UInt32"), ElementType.U4);
typeInt64 = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Int64"), ElementType.I8);
typeUInt64 = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "UInt64"), ElementType.U8);
typeSingle = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Single"), ElementType.R4);
typeDouble = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Double"), ElementType.R8);
typeString = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "String"), ElementType.String);
typeTypedReference = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "TypedReference"), ElementType.TypedByRef);
typeIntPtr = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "IntPtr"), ElementType.I);
typeUIntPtr = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "UIntPtr"), ElementType.U);
typeObject = new CorLibTypeSig(CreateCorLibTypeRef(isCorLib, "Object"), ElementType.Object);
}
ITypeDefOrRef CreateCorLibTypeRef(bool isCorLib, string name) {
var tr = new TypeRefUser(module, "System", name, corLibAssemblyRef);
if (isCorLib) {
var td = module.Find(tr);
if (td != null)
return td;
}
return module.UpdateRowId(tr);
}
///
public TypeRef GetTypeRef(string @namespace, string name) {
return module.UpdateRowId(new TypeRefUser(module, @namespace, name, corLibAssemblyRef));
}
}
}
dnlib-2.1_VS2010/src/DotNet/CpuArch.cs 0000664 0000000 0000000 00000027341 13250336635 0017234 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using dnlib.DotNet.Writer;
using dnlib.IO;
using dnlib.PE;
namespace dnlib.DotNet {
enum StubType {
Export,
EntryPoint,
}
abstract class CpuArch {
static readonly Dictionary toCpuArch = new Dictionary {
// To support a new CPU arch, the easiest way is to check coreclr/src/ilasm/writer.cpp or
// coreclr/src/dlls/mscorpe/stubs.h, eg. ExportStubAMD64Template, ExportStubX86Template,
// ExportStubARMTemplate, ExportStubIA64Template, or use ilasm to generate a file with
// exports and check the stub
{ Machine.I386, new X86CpuArch() },
{ Machine.AMD64, new X64CpuArch() },
{ Machine.IA64, new ItaniumCpuArch() },
{ Machine.ARMNT, new ArmCpuArch() },
//TODO: Support ARM64
// { Machine.ARM64, new Arm64CpuArch() },
};
///
/// Gets the required alignment for the stubs, must be a power of 2
///
/// Stub type
///
public abstract uint GetStubAlignment(StubType stubType);
///
/// Gets the size of a stub, it doesn't have to be a multiple of
///
/// Stub type
///
public abstract uint GetStubSize(StubType stubType);
///
/// Gets the offset of the code (entry point) relative to the start of the stub
///
/// Stub type
///
public abstract uint GetStubCodeOffset(StubType stubType);
public static bool TryGetCpuArch(Machine machine, out CpuArch cpuArch) {
return toCpuArch.TryGetValue(machine, out cpuArch);
}
///
/// Gets the RVA of the func field that the stub jumps to
///
/// Reader, positioned at the stub func
/// PE image
/// Updated with RVA of func field
///
public bool TryGetExportedRvaFromStub(IBinaryReader reader, IPEImage peImage, out uint funcRva) {
bool b = TryGetExportedRvaFromStubCore(reader, peImage, out funcRva);
Debug.Assert(b);
return b;
}
protected abstract bool TryGetExportedRvaFromStubCore(IBinaryReader reader, IPEImage peImage, out uint funcRva);
///
/// Writes stub relocs, if needed
///
/// Stub type
/// Reloc directory
/// The chunk where this stub will be written to
/// Offset of this stub in
public abstract void WriteStubRelocs(StubType stubType, RelocDirectory relocDirectory, IChunk chunk, uint stubOffset);
///
/// Writes the stub that jumps to the managed function
///
/// Stub type
/// Writer
/// Image base
/// RVA of this stub
/// RVA of a pointer-sized field that contains the absolute address of the managed function
public abstract void WriteStub(StubType stubType, BinaryWriter writer, ulong imageBase, uint stubRva, uint managedFuncRva);
}
sealed class X86CpuArch : CpuArch {
public override uint GetStubAlignment(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 4;
default:
throw new ArgumentOutOfRangeException();
}
}
public override uint GetStubSize(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 2/*padding*/ + 6;
default:
throw new ArgumentOutOfRangeException();
}
}
public override uint GetStubCodeOffset(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 2/*padding*/;
default:
throw new ArgumentOutOfRangeException();
}
}
protected override bool TryGetExportedRvaFromStubCore(IBinaryReader reader, IPEImage peImage, out uint funcRva) {
funcRva = 0;
// FF25xxxxxxxx jmp DWORD PTR [xxxxxxxx]
if (reader.ReadUInt16() != 0x25FF)
return false;
funcRva = reader.ReadUInt32() - (uint)peImage.ImageNTHeaders.OptionalHeader.ImageBase;
return true;
}
public override void WriteStubRelocs(StubType stubType, RelocDirectory relocDirectory, IChunk chunk, uint stubOffset) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
relocDirectory.Add(chunk, stubOffset + 4);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override void WriteStub(StubType stubType, BinaryWriter writer, ulong imageBase, uint stubRva, uint managedFuncRva) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
writer.Write((ushort)0);// padding
writer.Write((ushort)0x25FF);
writer.Write((uint)imageBase + managedFuncRva);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
sealed class X64CpuArch : CpuArch {
public override uint GetStubAlignment(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 4;
default:
throw new ArgumentOutOfRangeException();
}
}
public override uint GetStubSize(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 2/*padding*/ + 12;
default:
throw new ArgumentOutOfRangeException();
}
}
public override uint GetStubCodeOffset(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 2/*padding*/;
default:
throw new ArgumentOutOfRangeException();
}
}
protected override bool TryGetExportedRvaFromStubCore(IBinaryReader reader, IPEImage peImage, out uint funcRva) {
funcRva = 0;
// 48A1xxxxxxxxxxxxxxxx movabs rax,[xxxxxxxxxxxxxxxx]
// FFE0 jmp rax
if (reader.ReadUInt16() != 0xA148)
return false;
ulong absAddr = reader.ReadUInt64();
if (reader.ReadUInt16() != 0xE0FF)
return false;
ulong rva = absAddr - peImage.ImageNTHeaders.OptionalHeader.ImageBase;
if (rva > uint.MaxValue)
return false;
funcRva = (uint)rva;
return true;
}
public override void WriteStubRelocs(StubType stubType, RelocDirectory relocDirectory, IChunk chunk, uint stubOffset) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
relocDirectory.Add(chunk, stubOffset + 4);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override void WriteStub(StubType stubType, BinaryWriter writer, ulong imageBase, uint stubRva, uint managedFuncRva) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
writer.Write((ushort)0);// padding
writer.Write((ushort)0xA148);
writer.Write(imageBase + managedFuncRva);
writer.Write((ushort)0xE0FF);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
sealed class ItaniumCpuArch : CpuArch {
public override uint GetStubAlignment(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 16;
default:
throw new ArgumentOutOfRangeException();
}
}
public override uint GetStubSize(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 0x30;
default:
throw new ArgumentOutOfRangeException();
}
}
public override uint GetStubCodeOffset(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 0x20;
default:
throw new ArgumentOutOfRangeException();
}
}
protected override bool TryGetExportedRvaFromStubCore(IBinaryReader reader, IPEImage peImage, out uint funcRva) {
funcRva = 0;
// From ExportStubIA64Template in coreclr/src/ilasm/writer.cpp
//
// ld8 r9 = [gp] ;;
// ld8 r10 = [r9],8
// nop.i ;;
// ld8 gp = [r9]
// mov b6 = r10
// br.cond.sptk.few b6
//
// 0x0B, 0x48, 0x00, 0x02, 0x18, 0x10, 0xA0, 0x40,
// 0x24, 0x30, 0x28, 0x00, 0x00, 0x00, 0x04, 0x00,
// 0x10, 0x08, 0x00, 0x12, 0x18, 0x10, 0x60, 0x50,
// 0x04, 0x80, 0x03, 0x00, 0x60, 0x00, 0x80, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,//address of the template
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 //address of VTFixup slot
ulong addrTemplate = reader.ReadUInt64();
ulong absAddr = reader.ReadUInt64();
reader.Position = (long)peImage.ToFileOffset((RVA)(addrTemplate - peImage.ImageNTHeaders.OptionalHeader.ImageBase));
if (reader.ReadUInt64() != 0x40A010180200480BUL)
return false;
if (reader.ReadUInt64() != 0x0004000000283024UL)
return false;
if (reader.ReadUInt64() != 0x5060101812000810UL)
return false;
if (reader.ReadUInt64() != 0x0080006000038004UL)
return false;
ulong rva = absAddr - peImage.ImageNTHeaders.OptionalHeader.ImageBase;
if (rva > uint.MaxValue)
return false;
funcRva = (uint)rva;
return true;
}
public override void WriteStubRelocs(StubType stubType, RelocDirectory relocDirectory, IChunk chunk, uint stubOffset) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
relocDirectory.Add(chunk, stubOffset + 0x20);
relocDirectory.Add(chunk, stubOffset + 0x28);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override void WriteStub(StubType stubType, BinaryWriter writer, ulong imageBase, uint stubRva, uint managedFuncRva) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
writer.Write(0x40A010180200480BUL);
writer.Write(0x0004000000283024UL);
writer.Write(0x5060101812000810UL);
writer.Write(0x0080006000038004UL);
writer.Write(imageBase + stubRva);
writer.Write(imageBase + managedFuncRva);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
sealed class ArmCpuArch : CpuArch {
public override uint GetStubAlignment(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 4;
default:
throw new ArgumentOutOfRangeException();
}
}
public override uint GetStubSize(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 8;
default:
throw new ArgumentOutOfRangeException();
}
}
public override uint GetStubCodeOffset(StubType stubType) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
return 0;
default:
throw new ArgumentOutOfRangeException();
}
}
protected override bool TryGetExportedRvaFromStubCore(IBinaryReader reader, IPEImage peImage, out uint funcRva) {
funcRva = 0;
// DFF800F0 ldr.w pc,[pc]
// xxxxxxxx
if (reader.ReadUInt32() != 0xF000F8DF)
return false;
funcRva = reader.ReadUInt32() - (uint)peImage.ImageNTHeaders.OptionalHeader.ImageBase;
return true;
}
public override void WriteStubRelocs(StubType stubType, RelocDirectory relocDirectory, IChunk chunk, uint stubOffset) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
relocDirectory.Add(chunk, stubOffset + 4);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override void WriteStub(StubType stubType, BinaryWriter writer, ulong imageBase, uint stubRva, uint managedFuncRva) {
switch (stubType) {
case StubType.Export:
case StubType.EntryPoint:
writer.Write(0xF000F8DF);
writer.Write((uint)imageBase + managedFuncRva);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
dnlib-2.1_VS2010/src/DotNet/CustomAttribute.cs 0000664 0000000 0000000 00000034750 13250336635 0021047 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
using dnlib.Threading;
using dnlib.IO;
#if THREAD_SAFE
using ThreadSafe = dnlib.Threading.Collections;
#else
using ThreadSafe = System.Collections.Generic;
#endif
namespace dnlib.DotNet {
///
/// A custom attribute
///
public sealed class CustomAttribute : ICustomAttribute {
ICustomAttributeType ctor;
byte[] rawData;
readonly ThreadSafe.IList arguments;
readonly ThreadSafe.IList namedArguments;
IBinaryReader blobReader;
///
/// Gets/sets the custom attribute constructor
///
public ICustomAttributeType Constructor {
get { return ctor; }
set { ctor = value; }
}
///
/// Gets the attribute type
///
public ITypeDefOrRef AttributeType {
get {
var cat = ctor;
return cat == null ? null : cat.DeclaringType;
}
}
///
/// Gets the full name of the attribute type
///
public string TypeFullName {
get {
var mrCtor = ctor as MemberRef;
if (mrCtor != null)
return mrCtor.GetDeclaringTypeFullName() ?? string.Empty;
var mdCtor = ctor as MethodDef;
if (mdCtor != null) {
var declType = mdCtor.DeclaringType;
if (declType != null)
return declType.FullName;
}
return string.Empty;
}
}
///
/// true if the raw custom attribute blob hasn't been parsed
///
public bool IsRawBlob {
get { return rawData != null; }
}
///
/// Gets the raw custom attribute blob or null if the CA was successfully parsed.
///
public byte[] RawData {
get { return rawData; }
}
///
/// Gets all constructor arguments
///
public ThreadSafe.IList ConstructorArguments {
get { return arguments; }
}
///
/// true if is not empty
///
public bool HasConstructorArguments {
get { return arguments.Count > 0; }
}
///
/// Gets all named arguments (field and property values)
///
public ThreadSafe.IList NamedArguments {
get { return namedArguments; }
}
///
/// true if is not empty
///
public bool HasNamedArguments {
get { return namedArguments.Count > 0; }
}
///
/// Gets all s that are field arguments
///
public IEnumerable Fields {
get {
foreach (var namedArg in namedArguments.GetSafeEnumerable()) {
if (namedArg.IsField)
yield return namedArg;
}
}
}
///
/// Gets all s that are property arguments
///
public IEnumerable Properties {
get {
foreach (var namedArg in namedArguments.GetSafeEnumerable()) {
if (namedArg.IsProperty)
yield return namedArg;
}
}
}
///
/// Constructor
///
/// Custom attribute constructor
/// Raw custom attribute blob
public CustomAttribute(ICustomAttributeType ctor, byte[] rawData)
: this(ctor, null, null, null) {
this.rawData = rawData;
}
///
/// Constructor
///
/// Custom attribute constructor
public CustomAttribute(ICustomAttributeType ctor)
: this(ctor, null, null, null) {
}
///
/// Constructor
///
/// Custom attribute constructor
/// Constructor arguments or null if none
public CustomAttribute(ICustomAttributeType ctor, IEnumerable arguments)
: this(ctor, arguments, null) {
}
///
/// Constructor
///
/// Custom attribute constructor
/// Named arguments or null if none
public CustomAttribute(ICustomAttributeType ctor, IEnumerable namedArguments)
: this(ctor, null, namedArguments) {
}
///
/// Constructor
///
/// Custom attribute constructor
/// Constructor arguments or null if none
/// Named arguments or null if none
public CustomAttribute(ICustomAttributeType ctor, IEnumerable arguments, IEnumerable namedArguments)
: this(ctor, arguments, namedArguments, null) {
}
///
/// Constructor
///
/// Custom attribute constructor
/// Constructor arguments or null if none
/// Named arguments or null if none
/// A reader that returns the original custom attribute blob data
public CustomAttribute(ICustomAttributeType ctor, IEnumerable arguments, IEnumerable namedArguments, IBinaryReader blobReader) {
this.ctor = ctor;
this.arguments = arguments == null ? ThreadSafeListCreator.Create() : ThreadSafeListCreator.Create(arguments);
this.namedArguments = namedArguments == null ? ThreadSafeListCreator.Create() : ThreadSafeListCreator.Create(namedArguments);
this.blobReader = blobReader;
}
///
/// Constructor
///
/// Custom attribute constructor
/// Constructor arguments. The list is now owned by this instance.
/// Named arguments. The list is now owned by this instance.
/// A reader that returns the original custom attribute blob data
internal CustomAttribute(ICustomAttributeType ctor, List arguments, List namedArguments, IBinaryReader blobReader) {
this.ctor = ctor;
this.arguments = arguments == null ? ThreadSafeListCreator.Create() : ThreadSafeListCreator.MakeThreadSafe(arguments);
this.namedArguments = namedArguments == null ? ThreadSafeListCreator.Create() : ThreadSafeListCreator.MakeThreadSafe(namedArguments);
this.blobReader = blobReader;
}
///
/// Gets the field named
///
/// Name of field
/// A instance or null if not found
public CANamedArgument GetField(string name) {
return GetNamedArgument(name, true);
}
///
/// Gets the field named
///
/// Name of field
/// A instance or null if not found
public CANamedArgument GetField(UTF8String name) {
return GetNamedArgument(name, true);
}
///
/// Gets the property named
///
/// Name of property
/// A instance or null if not found
public CANamedArgument GetProperty(string name) {
return GetNamedArgument(name, false);
}
///
/// Gets the property named
///
/// Name of property
/// A instance or null if not found
public CANamedArgument GetProperty(UTF8String name) {
return GetNamedArgument(name, false);
}
///
/// Gets the property/field named
///
/// Name of property/field
/// true if it's a field, false if it's a property
/// A instance or null if not found
public CANamedArgument GetNamedArgument(string name, bool isField) {
foreach (var namedArg in namedArguments.GetSafeEnumerable()) {
if (namedArg.IsField == isField && UTF8String.ToSystemStringOrEmpty(namedArg.Name) == name)
return namedArg;
}
return null;
}
///
/// Gets the property/field named
///
/// Name of property/field
/// true if it's a field, false if it's a property
/// A instance or null if not found
public CANamedArgument GetNamedArgument(UTF8String name, bool isField) {
foreach (var namedArg in namedArguments.GetSafeEnumerable()) {
if (namedArg.IsField == isField && UTF8String.Equals(namedArg.Name, name))
return namedArg;
}
return null;
}
///
/// Gets the binary custom attribute data that was used to create this instance.
///
/// Blob of this custom attribute
public byte[] GetBlob() {
if (rawData != null)
return rawData;
if (blob != null)
return blob;
#if THREAD_SAFE
if (blobReader != null) {
lock (this) {
#endif
if (blobReader != null) {
blob = blobReader.ReadAllBytes();
blobReader.Dispose();
blobReader = null;
return blob;
}
#if THREAD_SAFE
}
}
#endif
if (blob != null)
return blob;
return blob = new byte[0];
}
byte[] blob;
///
public override string ToString() {
return TypeFullName;
}
}
///
/// A custom attribute constructor argument
///
public struct CAArgument : ICloneable {
TypeSig type;
object value;
///
/// Gets/sets the argument type
///
public TypeSig Type {
get { return type; }
set { type = value; }
}
///
/// Gets/sets the argument value
///
public object Value {
get { return value; }
set { this.value = value; }
}
///
/// Constructor
///
/// Argument type
public CAArgument(TypeSig type) {
this.type = type;
this.value = null;
}
///
/// Constructor
///
/// Argument type
/// Argument value
public CAArgument(TypeSig type, object value) {
this.type = type;
this.value = value;
}
object ICloneable.Clone() {
return Clone();
}
///
/// Clones this instance and any s and s
/// referenced from this instance.
///
///
public CAArgument Clone() {
var value = this.value;
if (value is CAArgument)
value = ((CAArgument)value).Clone();
else if (value is IList) {
var args = (IList)value;
var newArgs = ThreadSafeListCreator.Create(args.Count);
foreach (var arg in args.GetSafeEnumerable())
newArgs.Add(arg.Clone());
value = newArgs;
}
return new CAArgument(type, value);
}
///
public override string ToString() {
object v = value;
return string.Format("{0} ({1})", v == null ? "null" : v, type);
}
}
///
/// A custom attribute field/property argument
///
public sealed class CANamedArgument : ICloneable {
bool isField;
TypeSig type;
UTF8String name;
CAArgument argument;
///
/// true if it's a field
///
public bool IsField {
get { return isField; }
set { isField = value; }
}
///
/// true if it's a property
///
public bool IsProperty {
get { return !isField; }
set { isField = !value; }
}
///
/// Gets/sets the field/property type
///
public TypeSig Type {
get { return type; }
set { type = value; }
}
///
/// Gets/sets the property/field name
///
public UTF8String Name {
get { return name; }
set { name = value; }
}
///
/// Gets/sets the argument
///
public CAArgument Argument {
get { return argument; }
set { argument = value; }
}
///
/// Gets/sets the argument type
///
public TypeSig ArgumentType {
get { return argument.Type; }
set { argument.Type = value; }
}
///
/// Gets/sets the argument value
///
public object Value {
get { return argument.Value; }
set { argument.Value = value; }
}
///
/// Default constructor
///
public CANamedArgument() {
}
///
/// Constructor
///
/// true if field, false if property
public CANamedArgument(bool isField) {
this.isField = isField;
}
///
/// Constructor
///
/// true if field, false if property
/// Field/property type
public CANamedArgument(bool isField, TypeSig type) {
this.isField = isField;
this.type = type;
}
///
/// Constructor
///
/// true if field, false if property
/// Field/property type
/// Name of field/property
public CANamedArgument(bool isField, TypeSig type, UTF8String name) {
this.isField = isField;
this.type = type;
this.name = name;
}
///
/// Constructor
///
/// true if field, false if property
/// Field/property type
/// Name of field/property
/// Field/property argument
public CANamedArgument(bool isField, TypeSig type, UTF8String name, CAArgument argument) {
this.isField = isField;
this.type = type;
this.name = name;
this.argument = argument;
}
object ICloneable.Clone() {
return Clone();
}
///
/// Clones this instance and any s referenced from this instance.
///
///
public CANamedArgument Clone() {
return new CANamedArgument(isField, type, name, argument.Clone());
}
///
public override string ToString() {
object v = Value;
return string.Format("({0}) {1} {2} = {3} ({4})", isField ? "field" : "property", type, name, v == null ? "null" : v, ArgumentType);
}
}
}
dnlib-2.1_VS2010/src/DotNet/CustomAttributeCollection.cs 0000664 0000000 0000000 00000010117 13250336635 0023052 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System.Collections.Generic;
using dnlib.Utils;
using dnlib.Threading;
namespace dnlib.DotNet {
///
/// Stores s
///
public class CustomAttributeCollection : LazyList {
///
/// Default constructor
///
public CustomAttributeCollection() {
}
///
/// Constructor
///
/// Initial length of the list
/// Context passed to
/// Delegate instance that returns original values
public CustomAttributeCollection(int length, object context, MFunc readOriginalValue)
: base(length, context, readOriginalValue) {
}
///
/// Checks whether a custom attribute is present
///
/// Full name of custom attribute type
/// true if the custom attribute type is present, false otherwise
public bool IsDefined(string fullName) {
return Find(fullName) != null;
}
///
/// Removes all custom attributes of a certain type
///
/// Full name of custom attribute type that should be removed
public void RemoveAll(string fullName) {
this.IterateAllReverse((tsList, index, value) => {
if (value.TypeFullName == fullName)
RemoveAt_NoLock(index);
});
}
///
/// Finds a custom attribute
///
/// Full name of custom attribute type
/// A or null if it wasn't found
public CustomAttribute Find(string fullName) {
foreach (var ca in this.GetSafeEnumerable()) {
if (ca != null && ca.TypeFullName == fullName)
return ca;
}
return null;
}
///
/// Finds all custom attributes of a certain type
///
/// Full name of custom attribute type
/// All s of the requested type
public IEnumerable FindAll(string fullName) {
foreach (var ca in this.GetSafeEnumerable()) {
if (ca != null && ca.TypeFullName == fullName)
yield return ca;
}
}
///
/// Finds a custom attribute
///
/// Custom attribute type
/// The first found or null if none found
public CustomAttribute Find(IType attrType) {
return Find(attrType, 0);
}
///
/// Finds a custom attribute
///
/// Custom attribute type
/// Attribute type comparison flags
/// The first found or null if none found
public CustomAttribute Find(IType attrType, SigComparerOptions options) {
var comparer = new SigComparer(options);
foreach (var ca in this.GetSafeEnumerable()) {
if (comparer.Equals(ca.AttributeType, attrType))
return ca;
}
return null;
}
///
/// Finds all custom attributes of a certain type
///
/// Custom attribute type
/// All s of the requested type
public IEnumerable FindAll(IType attrType) {
return FindAll(attrType, 0);
}
///
/// Finds all custom attributes of a certain type
///
/// Custom attribute type
/// Attribute type comparison flags
/// All s of the requested type
public IEnumerable FindAll(IType attrType, SigComparerOptions options) {
var comparer = new SigComparer(options);
foreach (var ca in this.GetSafeEnumerable()) {
if (comparer.Equals(ca.AttributeType, attrType))
yield return ca;
}
}
}
}
dnlib-2.1_VS2010/src/DotNet/CustomAttributeReader.cs 0000664 0000000 0000000 00000051637 13250336635 0022175 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using dnlib.IO;
using dnlib.Threading;
namespace dnlib.DotNet {
///
/// Searches for a type according to custom attribute search rules: first try the
/// current assembly, and if that fails, try mscorlib
///
sealed class CAAssemblyRefFinder : IAssemblyRefFinder {
readonly ModuleDef module;
///
/// Constructor
///
/// The module to search first
public CAAssemblyRefFinder(ModuleDef module) {
this.module = module;
}
///
public AssemblyRef FindAssemblyRef(TypeRef nonNestedTypeRef) {
var modAsm = module.Assembly;
if (modAsm != null) {
var type = modAsm.Find(nonNestedTypeRef);
if (type != null)
return module.UpdateRowId(new AssemblyRefUser(modAsm));
}
else if (module.Find(nonNestedTypeRef) != null)
return AssemblyRef.CurrentAssembly;
var corLibAsm = module.Context.AssemblyResolver.Resolve(module.CorLibTypes.AssemblyRef, module);
if (corLibAsm != null) {
var type = corLibAsm.Find(nonNestedTypeRef);
if (type != null)
return module.CorLibTypes.AssemblyRef;
}
if (modAsm != null)
return module.UpdateRowId(new AssemblyRefUser(modAsm));
return AssemblyRef.CurrentAssembly;
}
}
///
/// Thrown by CustomAttributeReader when it fails to parse a custom attribute blob
///
[Serializable]
public class CABlobParserException : Exception {
///
/// Default constructor
///
public CABlobParserException() {
}
///
/// Constructor
///
/// Error message
public CABlobParserException(string message)
: base(message) {
}
///
/// Constructor
///
/// Error message
/// Other exception
public CABlobParserException(string message, Exception innerException)
: base(message, innerException) {
}
///
/// Constructor
///
///
///
protected CABlobParserException(SerializationInfo info, StreamingContext context)
: base(info, context) {
}
}
///
/// Reads custom attributes from the #Blob stream
///
public struct CustomAttributeReader : IDisposable {
readonly ModuleDef module;
readonly IBinaryReader reader;
readonly GenericParamContext gpContext;
GenericArguments genericArguments;
RecursionCounter recursionCounter;
bool verifyReadAllBytes;
readonly bool ownReader;
///
/// Reads a custom attribute
///
/// Reader module
/// Custom attribute constructor
/// Offset of custom attribute in the #Blob stream
/// A new instance
public static CustomAttribute Read(ModuleDefMD readerModule, ICustomAttributeType ctor, uint offset) {
return Read(readerModule, ctor, offset, new GenericParamContext());
}
///
/// Reads a custom attribute
///
/// Reader module
/// Custom attribute constructor
/// Offset of custom attribute in the #Blob stream
/// Generic parameter context
/// A new instance
public static CustomAttribute Read(ModuleDefMD readerModule, ICustomAttributeType ctor, uint offset, GenericParamContext gpContext) {
using (var reader = new CustomAttributeReader(readerModule, offset, gpContext)) {
try {
if (ctor == null)
return reader.CreateRaw(ctor);
return reader.Read(ctor);
}
catch (CABlobParserException) {
return reader.CreateRaw(ctor);
}
catch (IOException) {
return reader.CreateRaw(ctor);
}
}
}
CustomAttribute CreateRaw(ICustomAttributeType ctor) {
return new CustomAttribute(ctor, GetRawBlob());
}
///
/// Reads a custom attribute
///
/// Owner module
/// CA blob
/// Custom attribute constructor
/// A new instance
public static CustomAttribute Read(ModuleDef module, byte[] caBlob, ICustomAttributeType ctor) {
return Read(module, MemoryImageStream.Create(caBlob), ctor, new GenericParamContext());
}
///
/// Reads a custom attribute
///
/// Owner module
/// A stream positioned at the the first byte of the CA blob
/// Custom attribute constructor
/// A new instance
public static CustomAttribute Read(ModuleDef module, IBinaryReader stream, ICustomAttributeType ctor) {
return Read(module, stream, ctor, new GenericParamContext());
}
///
/// Reads a custom attribute
///
/// Owner module
/// CA blob
/// Custom attribute constructor
/// Generic parameter context
/// A new instance
public static CustomAttribute Read(ModuleDef module, byte[] caBlob, ICustomAttributeType ctor, GenericParamContext gpContext) {
return Read(module, MemoryImageStream.Create(caBlob), ctor, gpContext);
}
///
/// Reads a custom attribute
///
/// Owner module
/// A stream positioned at the the first byte of the CA blob
/// Custom attribute constructor
/// Generic parameter context
/// A new instance
public static CustomAttribute Read(ModuleDef module, IBinaryReader stream, ICustomAttributeType ctor, GenericParamContext gpContext) {
using (var reader = new CustomAttributeReader(module, stream, gpContext)) {
try {
if (stream == null || ctor == null)
return reader.CreateRaw(ctor);
return reader.Read(ctor);
}
catch (CABlobParserException) {
return reader.CreateRaw(ctor);
}
catch (IOException) {
return reader.CreateRaw(ctor);
}
}
}
///
/// Reads custom attribute named arguments
///
/// Owner module
/// A stream positioned at the the first byte of the CA blob
/// Number of named arguments to read from
/// Generic parameter context
/// A list of s or null if some error
/// occurred.
internal static List ReadNamedArguments(ModuleDef module, IBinaryReader stream, int numNamedArgs, GenericParamContext gpContext) {
try {
using (var reader = new CustomAttributeReader(module, stream, false, gpContext))
return reader.ReadNamedArguments(numNamedArgs);
}
catch (CABlobParserException) {
return null;
}
catch (IOException) {
return null;
}
}
CustomAttributeReader(ModuleDefMD readerModule, uint offset, GenericParamContext gpContext) {
this.module = readerModule;
this.reader = readerModule.BlobStream.CreateStream(offset);
this.ownReader = true;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
this.gpContext = gpContext;
}
CustomAttributeReader(ModuleDef module, IBinaryReader reader, GenericParamContext gpContext) {
this.module = module;
this.reader = reader;
this.ownReader = false;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
this.gpContext = gpContext;
}
CustomAttributeReader(ModuleDef module, IBinaryReader reader, bool ownRerader, GenericParamContext gpContext) {
this.module = module;
this.reader = reader;
this.ownReader = ownRerader;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
this.gpContext = gpContext;
}
byte[] GetRawBlob() {
return reader.ReadAllBytes();
}
CustomAttribute Read(ICustomAttributeType ctor) {
var methodSig = ctor == null ? null : ctor.MethodSig;
if (methodSig == null)
throw new CABlobParserException("ctor is null or not a method");
var mrCtor = ctor as MemberRef;
if (mrCtor != null) {
var owner = mrCtor.Class as TypeSpec;
if (owner != null) {
var gis = owner.TypeSig as GenericInstSig;
if (gis != null) {
genericArguments = new GenericArguments();
genericArguments.PushTypeArgs(gis.GenericArguments);
}
}
}
bool isEmpty = methodSig.Params.Count == 0 && reader.Position == reader.Length;
if (!isEmpty && reader.ReadUInt16() != 1)
throw new CABlobParserException("Invalid CA blob prolog");
var ctorArgs = new List(methodSig.Params.Count);
foreach (var arg in methodSig.Params.GetSafeEnumerable())
ctorArgs.Add(ReadFixedArg(FixTypeSig(arg)));
// Some tools don't write the next ushort if there are no named arguments.
int numNamedArgs = reader.Position == reader.Length ? 0 : reader.ReadUInt16();
var namedArgs = ReadNamedArguments(numNamedArgs);
// verifyReadAllBytes will be set when we guess the underlying type of an enum.
// To make sure we guessed right, verify that we read all bytes.
if (verifyReadAllBytes && reader.Position != reader.Length)
throw new CABlobParserException("Not all CA blob bytes were read");
return new CustomAttribute(ctor, ctorArgs, namedArgs, CloneBlobReader(reader));
}
static IBinaryReader CloneBlobReader(IBinaryReader reader) {
if (reader == null)
return null;
var imgStream = reader as IImageStream;
if (imgStream != null)
return imgStream.Clone();
return MemoryImageStream.Create(reader.ReadAllBytes());
}
List ReadNamedArguments(int numNamedArgs) {
var namedArgs = new List(numNamedArgs);
for (int i = 0; i < numNamedArgs; i++) {
if (reader.Position == reader.Length)
break;
namedArgs.Add(ReadNamedArgument());
}
return namedArgs;
}
TypeSig FixTypeSig(TypeSig type) {
return SubstituteGenericParameter(type.RemoveModifiers()).RemoveModifiers();
}
TypeSig SubstituteGenericParameter(TypeSig type) {
if (genericArguments == null)
return type;
return genericArguments.Resolve(type);
}
CAArgument ReadFixedArg(TypeSig argType) {
if (!recursionCounter.Increment())
throw new CABlobParserException("Too much recursion");
if (argType == null)
throw new CABlobParserException("null argType");
CAArgument result;
var arrayType = argType as SZArraySig;
if (arrayType != null)
result = ReadArrayArgument(arrayType);
else
result = ReadElem(argType);
recursionCounter.Decrement();
return result;
}
CAArgument ReadElem(TypeSig argType) {
if (argType == null)
throw new CABlobParserException("null argType");
TypeSig realArgType;
var value = ReadValue((SerializationType)argType.ElementType, argType, out realArgType);
if (realArgType == null)
throw new CABlobParserException("Invalid arg type");
// One example when this is true is when prop/field type is object and
// value type is string[]
if (value is CAArgument)
return (CAArgument)value;
return new CAArgument(realArgType, value);
}
object ReadValue(SerializationType etype, TypeSig argType, out TypeSig realArgType) {
if (!recursionCounter.Increment())
throw new CABlobParserException("Too much recursion");
object result;
switch (etype) {
case SerializationType.Boolean:
realArgType = module.CorLibTypes.Boolean;
result = reader.ReadByte() != 0;
break;
case SerializationType.Char:
realArgType = module.CorLibTypes.Char;
result = (char)reader.ReadUInt16();
break;
case SerializationType.I1:
realArgType = module.CorLibTypes.SByte;
result = reader.ReadSByte();
break;
case SerializationType.U1:
realArgType = module.CorLibTypes.Byte;
result = reader.ReadByte();
break;
case SerializationType.I2:
realArgType = module.CorLibTypes.Int16;
result = reader.ReadInt16();
break;
case SerializationType.U2:
realArgType = module.CorLibTypes.UInt16;
result = reader.ReadUInt16();
break;
case SerializationType.I4:
realArgType = module.CorLibTypes.Int32;
result = reader.ReadInt32();
break;
case SerializationType.U4:
realArgType = module.CorLibTypes.UInt32;
result = reader.ReadUInt32();
break;
case SerializationType.I8:
realArgType = module.CorLibTypes.Int64;
result = reader.ReadInt64();
break;
case SerializationType.U8:
realArgType = module.CorLibTypes.UInt64;
result = reader.ReadUInt64();
break;
case SerializationType.R4:
realArgType = module.CorLibTypes.Single;
result = reader.ReadSingle();
break;
case SerializationType.R8:
realArgType = module.CorLibTypes.Double;
result = reader.ReadDouble();
break;
case SerializationType.String:
realArgType = module.CorLibTypes.String;
result = ReadUTF8String();
break;
// It's ET.ValueType if it's eg. a ctor enum arg type
case (SerializationType)ElementType.ValueType:
if (argType == null)
throw new CABlobParserException("Invalid element type");
realArgType = argType;
result = ReadEnumValue(GetEnumUnderlyingType(argType));
break;
// It's ET.Object if it's a ctor object arg type
case (SerializationType)ElementType.Object:
case SerializationType.TaggedObject:
realArgType = ReadFieldOrPropType();
var arraySig = realArgType as SZArraySig;
if (arraySig != null)
result = ReadArrayArgument(arraySig);
else {
TypeSig tmpType;
result = ReadValue((SerializationType)realArgType.ElementType, realArgType, out tmpType);
}
break;
// It's ET.Class if it's eg. a ctor System.Type arg type
case (SerializationType)ElementType.Class:
var tdr = argType as TypeDefOrRefSig;
if (tdr != null && tdr.DefinitionAssembly.IsCorLib() && tdr.Namespace == "System") {
if (tdr.TypeName == "Type") {
result = ReadValue(SerializationType.Type, tdr, out realArgType);
break;
}
if (tdr.TypeName == "String") {
result = ReadValue(SerializationType.String, tdr, out realArgType);
break;
}
if (tdr.TypeName == "Object") {
result = ReadValue(SerializationType.TaggedObject, tdr, out realArgType);
break;
}
}
// Assume it's an enum that couldn't be resolved
realArgType = argType;
result = ReadEnumValue(null);
break;
case SerializationType.Type:
realArgType = argType;
result = ReadType(true);
break;
case SerializationType.Enum:
realArgType = ReadType(false);
result = ReadEnumValue(GetEnumUnderlyingType(realArgType));
break;
default:
throw new CABlobParserException("Invalid element type");
}
recursionCounter.Decrement();
return result;
}
object ReadEnumValue(TypeSig underlyingType) {
if (underlyingType != null) {
if (underlyingType.ElementType < ElementType.Boolean || underlyingType.ElementType > ElementType.U8)
throw new CABlobParserException("Invalid enum underlying type");
TypeSig realArgType;
return ReadValue((SerializationType)underlyingType.ElementType, underlyingType, out realArgType);
}
// We couldn't resolve the type ref. It should be an enum, but we don't know for sure.
// Most enums use Int32 as the underlying type. Assume that's true also in this case.
// Since we're guessing, verify that we've read all CA blob bytes. If we haven't, then
// we probably guessed wrong.
verifyReadAllBytes = true;
return reader.ReadInt32();
}
TypeSig ReadType(bool canReturnNull) {
var name = ReadUTF8String();
if (canReturnNull && (object)name == null)
return null;
var asmRefFinder = new CAAssemblyRefFinder(module);
var type = TypeNameParser.ParseAsTypeSigReflection(module, UTF8String.ToSystemStringOrEmpty(name), asmRefFinder, gpContext);
if (type == null)
throw new CABlobParserException("Could not parse type");
return type;
}
///
/// Gets the enum's underlying type
///
/// An enum type
/// The underlying type or null if we couldn't resolve the type ref
/// If is not an enum or null
static TypeSig GetEnumUnderlyingType(TypeSig type) {
if (type == null)
throw new CABlobParserException("null enum type");
var td = GetTypeDef(type);
if (td == null)
return null;
if (!td.IsEnum)
throw new CABlobParserException("Not an enum");
return td.GetEnumUnderlyingType().RemoveModifiers();
}
///
/// Converts to a , possibly resolving
/// a
///
/// The type
/// A or null if we couldn't resolve the
/// or if is a type spec
static TypeDef GetTypeDef(TypeSig type) {
var tdr = type as TypeDefOrRefSig;
if (tdr != null) {
var td = tdr.TypeDef;
if (td != null)
return td;
var tr = tdr.TypeRef;
if (tr != null)
return tr.Resolve();
}
return null;
}
CAArgument ReadArrayArgument(SZArraySig arrayType) {
if (!recursionCounter.Increment())
throw new CABlobParserException("Too much recursion");
var arg = new CAArgument(arrayType);
int arrayCount = reader.ReadInt32();
if (arrayCount == -1) { // -1 if it's null
}
else if (arrayCount < 0)
throw new CABlobParserException("Array is too big");
else {
var array = ThreadSafeListCreator.Create(arrayCount);
arg.Value = array;
for (int i = 0; i < arrayCount; i++)
array.Add(ReadFixedArg(FixTypeSig(arrayType.Next)));
}
recursionCounter.Decrement();
return arg;
}
CANamedArgument ReadNamedArgument() {
bool isField;
switch ((SerializationType)reader.ReadByte()) {
case SerializationType.Property:isField = false; break;
case SerializationType.Field: isField = true; break;
default: throw new CABlobParserException("Named argument is not a field/property");
}
TypeSig fieldPropType = ReadFieldOrPropType();
var name = ReadUTF8String();
var argument = ReadFixedArg(fieldPropType);
return new CANamedArgument(isField, fieldPropType, name, argument);
}
TypeSig ReadFieldOrPropType() {
if (!recursionCounter.Increment())
throw new CABlobParserException("Too much recursion");
TypeSig result;
switch ((SerializationType)reader.ReadByte()) {
case SerializationType.Boolean: result = module.CorLibTypes.Boolean; break;
case SerializationType.Char: result = module.CorLibTypes.Char; break;
case SerializationType.I1: result = module.CorLibTypes.SByte; break;
case SerializationType.U1: result = module.CorLibTypes.Byte; break;
case SerializationType.I2: result = module.CorLibTypes.Int16; break;
case SerializationType.U2: result = module.CorLibTypes.UInt16; break;
case SerializationType.I4: result = module.CorLibTypes.Int32; break;
case SerializationType.U4: result = module.CorLibTypes.UInt32; break;
case SerializationType.I8: result = module.CorLibTypes.Int64; break;
case SerializationType.U8: result = module.CorLibTypes.UInt64; break;
case SerializationType.R4: result = module.CorLibTypes.Single; break;
case SerializationType.R8: result = module.CorLibTypes.Double; break;
case SerializationType.String: result = module.CorLibTypes.String; break;
case SerializationType.SZArray: result = new SZArraySig(ReadFieldOrPropType()); break;
case SerializationType.Type: result = new ClassSig(module.CorLibTypes.GetTypeRef("System", "Type")); break;
case SerializationType.TaggedObject: result = module.CorLibTypes.Object; break;
case SerializationType.Enum: result = ReadType(false); break;
default: throw new CABlobParserException("Invalid type");
}
recursionCounter.Decrement();
return result;
}
UTF8String ReadUTF8String() {
if (reader.ReadByte() == 0xFF)
return null;
reader.Position--;
uint len;
if (!reader.ReadCompressedUInt32(out len))
throw new CABlobParserException("Could not read compressed UInt32");
if (len == 0)
return UTF8String.Empty;
return new UTF8String(reader.ReadBytes((int)len));
}
///
public void Dispose() {
if (ownReader && reader != null)
reader.Dispose();
}
}
}
dnlib-2.1_VS2010/src/DotNet/DeclSecurity.cs 0000664 0000000 0000000 00000017115 13250336635 0020304 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using dnlib.DotNet.MD;
using dnlib.DotNet.Pdb;
using dnlib.Threading;
#if THREAD_SAFE
using ThreadSafe = dnlib.Threading.Collections;
#else
using ThreadSafe = System.Collections.Generic;
#endif
namespace dnlib.DotNet {
///
/// A high-level representation of a row in the DeclSecurity table
///
[DebuggerDisplay("{Action} Count={SecurityAttributes.Count}")]
public abstract class DeclSecurity : IHasCustomAttribute, IHasCustomDebugInformation {
///
/// The row id in its table
///
protected uint rid;
///
public MDToken MDToken {
get { return new MDToken(Table.DeclSecurity, rid); }
}
///
public uint Rid {
get { return rid; }
set { rid = value; }
}
///
public int HasCustomAttributeTag {
get { return 8; }
}
///
/// From column DeclSecurity.Action
///
public SecurityAction Action {
get { return action; }
set { action = value; }
}
///
protected SecurityAction action;
///
/// From column DeclSecurity.PermissionSet
///
public ThreadSafe.IList SecurityAttributes {
get {
if (securityAttributes == null)
InitializeSecurityAttributes();
return securityAttributes;
}
}
///
protected ThreadSafe.IList securityAttributes;
/// Initializes
protected virtual void InitializeSecurityAttributes() {
Interlocked.CompareExchange(ref securityAttributes, ThreadSafeListCreator.Create(), null);
}
///
/// Gets all custom attributes
///
public CustomAttributeCollection CustomAttributes {
get {
if (customAttributes == null)
InitializeCustomAttributes();
return customAttributes;
}
}
///
protected CustomAttributeCollection customAttributes;
/// Initializes
protected virtual void InitializeCustomAttributes() {
Interlocked.CompareExchange(ref customAttributes, new CustomAttributeCollection(), null);
}
///
public bool HasCustomAttributes {
get { return CustomAttributes.Count > 0; }
}
///
public int HasCustomDebugInformationTag {
get { return 8; }
}
///
public bool HasCustomDebugInfos {
get { return CustomDebugInfos.Count > 0; }
}
///
/// Gets all custom debug infos
///
public ThreadSafe.IList CustomDebugInfos {
get {
if (customDebugInfos == null)
InitializeCustomDebugInfos();
return customDebugInfos;
}
}
///
protected ThreadSafe.IList customDebugInfos;
/// Initializes
protected virtual void InitializeCustomDebugInfos() {
Interlocked.CompareExchange(ref customDebugInfos, ThreadSafeListCreator.Create(), null);
}
///
/// true if is not empty
///
public bool HasSecurityAttributes {
get { return SecurityAttributes.Count > 0; }
}
///
/// Gets the blob data or null if there's none
///
/// Blob data or null
public abstract byte[] GetBlob();
///
/// Returns the .NET 1.x XML string or null if it's not a .NET 1.x format
///
///
public string GetNet1xXmlString() {
return GetNet1xXmlStringInternal(SecurityAttributes);
}
internal static string GetNet1xXmlStringInternal(IList secAttrs) {
if (secAttrs == null || secAttrs.Count != 1)
return null;
var sa = secAttrs[0];
if (sa == null || sa.TypeFullName != "System.Security.Permissions.PermissionSetAttribute")
return null;
if (sa.NamedArguments.Count != 1)
return null;
var na = sa.NamedArguments[0];
if (na == null || !na.IsProperty || na.Name != "XML")
return null;
if (na.ArgumentType.GetElementType() != ElementType.String)
return null;
var arg = na.Argument;
if (arg.Type.GetElementType() != ElementType.String)
return null;
var utf8 = arg.Value as UTF8String;
if ((object)utf8 != null)
return utf8;
var s = arg.Value as string;
if (s != null)
return s;
return null;
}
}
///
/// A DeclSecurity row created by the user and not present in the original .NET file
///
public class DeclSecurityUser : DeclSecurity {
///
/// Default constructor
///
public DeclSecurityUser() {
}
///
/// Constructor
///
/// The security action
/// The security attributes (now owned by this)
public DeclSecurityUser(SecurityAction action, IList securityAttrs) {
this.action = action;
this.securityAttributes = ThreadSafeListCreator.MakeThreadSafe(securityAttrs);
}
///
public override byte[] GetBlob() {
return null;
}
}
///
/// Created from a row in the DeclSecurity table
///
sealed class DeclSecurityMD : DeclSecurity, IMDTokenProviderMD {
/// The module where this instance is located
readonly ModuleDefMD readerModule;
readonly uint origRid;
readonly uint permissionSet;
///
public uint OrigRid {
get { return origRid; }
}
///
protected override void InitializeSecurityAttributes() {
var gpContext = new GenericParamContext();
var tmp = DeclSecurityReader.Read(readerModule, permissionSet, gpContext);
Interlocked.CompareExchange(ref securityAttributes, tmp, null);
}
///
protected override void InitializeCustomAttributes() {
var list = readerModule.MetaData.GetCustomAttributeRidList(Table.DeclSecurity, origRid);
var tmp = new CustomAttributeCollection((int)list.Length, list, (list2, index) => readerModule.ReadCustomAttribute(((RidList)list2)[index]));
Interlocked.CompareExchange(ref customAttributes, tmp, null);
}
///
protected override void InitializeCustomDebugInfos() {
var list = ThreadSafeListCreator.Create();
var gpContext = new GenericParamContext();
readerModule.InitializeCustomDebugInfos(new MDToken(MDToken.Table, origRid), gpContext, list);
Interlocked.CompareExchange(ref customDebugInfos, list, null);
}
///
/// Constructor
///
/// The module which contains this DeclSecurity row
/// Row ID
/// If is null
/// If is invalid
public DeclSecurityMD(ModuleDefMD readerModule, uint rid) {
#if DEBUG
if (readerModule == null)
throw new ArgumentNullException("readerModule");
if (readerModule.TablesStream.DeclSecurityTable.IsInvalidRID(rid))
throw new BadImageFormatException(string.Format("DeclSecurity rid {0} does not exist", rid));
#endif
this.origRid = rid;
this.rid = rid;
this.readerModule = readerModule;
this.permissionSet = readerModule.TablesStream.ReadDeclSecurityRow(origRid, out this.action);
}
///
public override byte[] GetBlob() {
return readerModule.BlobStream.Read(permissionSet);
}
}
}
dnlib-2.1_VS2010/src/DotNet/DeclSecurityReader.cs 0000664 0000000 0000000 00000013212 13250336635 0021421 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Text;
using dnlib.IO;
using dnlib.Threading;
#if THREAD_SAFE
using ThreadSafe = dnlib.Threading.Collections;
#else
using ThreadSafe = System.Collections.Generic;
#endif
namespace dnlib.DotNet {
///
/// Reads DeclSecurity blobs
///
public struct DeclSecurityReader : IDisposable {
readonly IBinaryReader reader;
readonly ModuleDef module;
readonly GenericParamContext gpContext;
///
/// Reads a DeclSecurity blob
///
/// Module that will own the returned list
/// #Blob offset of DeclSecurity signature
/// A list of s
public static ThreadSafe.IList Read(ModuleDefMD module, uint sig) {
return Read(module, module.BlobStream.CreateStream(sig), new GenericParamContext());
}
///
/// Reads a DeclSecurity blob
///
/// Module that will own the returned list
/// #Blob offset of DeclSecurity signature
/// Generic parameter context
/// A list of s
public static ThreadSafe.IList Read(ModuleDefMD module, uint sig, GenericParamContext gpContext) {
return Read(module, module.BlobStream.CreateStream(sig), gpContext);
}
///
/// Reads a DeclSecurity blob
///
/// Module that will own the returned list
/// DeclSecurity blob
/// A list of s
public static ThreadSafe.IList Read(ModuleDef module, byte[] blob) {
return Read(module, MemoryImageStream.Create(blob), new GenericParamContext());
}
///
/// Reads a DeclSecurity blob
///
/// Module that will own the returned list
/// DeclSecurity blob
/// Generic parameter context///
/// A list of s
public static ThreadSafe.IList Read(ModuleDef module, byte[] blob, GenericParamContext gpContext) {
return Read(module, MemoryImageStream.Create(blob), gpContext);
}
///
/// Reads a DeclSecurity blob
///
/// Module that will own the returned list
/// DeclSecurity stream that will be owned by us
/// A list of s
public static ThreadSafe.IList Read(ModuleDef module, IBinaryReader signature) {
return Read(module, signature, new GenericParamContext());
}
///
/// Reads a DeclSecurity blob
///
/// Module that will own the returned list
/// DeclSecurity stream that will be owned by us
/// Generic parameter context
/// A list of s
public static ThreadSafe.IList Read(ModuleDef module, IBinaryReader signature, GenericParamContext gpContext) {
using (var reader = new DeclSecurityReader(module, signature, gpContext))
return reader.Read();
}
DeclSecurityReader(ModuleDef module, IBinaryReader reader, GenericParamContext gpContext) {
this.reader = reader;
this.module = module;
this.gpContext = gpContext;
}
ThreadSafe.IList Read() {
try {
if (reader.Position >= reader.Length)
return ThreadSafeListCreator.Create();
if (reader.ReadByte() == '.')
return ReadBinaryFormat();
reader.Position--;
return ReadXmlFormat();
}
catch {
return ThreadSafeListCreator.Create();
}
}
///
/// Reads the new (.NET 2.0+) DeclSecurity blob format
///
///
ThreadSafe.IList ReadBinaryFormat() {
int numAttrs = (int)reader.ReadCompressedUInt32();
var list = ThreadSafeListCreator.Create(numAttrs);
for (int i = 0; i < numAttrs; i++) {
var name = ReadUTF8String();
// Use CA search rules. Some tools don't write the fully qualified name.
var attrRef = TypeNameParser.ParseReflection(module, UTF8String.ToSystemStringOrEmpty(name), new CAAssemblyRefFinder(module), gpContext);
/*int blobLength = (int)*/reader.ReadCompressedUInt32();
int numNamedArgs = (int)reader.ReadCompressedUInt32();
var namedArgs = CustomAttributeReader.ReadNamedArguments(module, reader, numNamedArgs, gpContext);
if (namedArgs == null)
throw new ApplicationException("Could not read named arguments");
list.Add(new SecurityAttribute(attrRef, namedArgs));
}
return list;
}
///
/// Reads the old (.NET 1.x) DeclSecurity blob format
///
///
ThreadSafe.IList ReadXmlFormat() {
var xml = Encoding.Unicode.GetString(reader.ReadAllBytes());
var sa = SecurityAttribute.CreateFromXml(module, xml);
return ThreadSafeListCreator.Create(sa);
}
UTF8String ReadUTF8String() {
uint len = reader.ReadCompressedUInt32();
return len == 0 ? UTF8String.Empty : new UTF8String(reader.ReadBytes((int)len));
}
///
public void Dispose() {
if (reader != null)
reader.Dispose();
}
}
}
dnlib-2.1_VS2010/src/DotNet/ElementType.cs 0000664 0000000 0000000 00000012607 13250336635 0020141 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
namespace dnlib.DotNet {
///
/// See CorHdr.h/CorElementType
///
public enum ElementType : byte {
///
End = 0x00,
/// System.Void
Void = 0x01,
/// System.Boolean
Boolean = 0x02,
/// System.Char
Char = 0x03,
/// System.SByte
I1 = 0x04,
/// System.Byte
U1 = 0x05,
/// System.Int16
I2 = 0x06,
/// System.UInt16
U2 = 0x07,
/// System.Int32
I4 = 0x08,
/// System.UInt32
U4 = 0x09,
/// System.Int64
I8 = 0x0A,
/// System.UInt64
U8 = 0x0B,
/// System.Single
R4 = 0x0C,
/// System.Double
R8 = 0x0D,
/// System.String
String = 0x0E,
/// Pointer type (*)
Ptr = 0x0F,
/// ByRef type (&)
ByRef = 0x10,
/// Value type
ValueType = 0x11,
/// Reference type
Class = 0x12,
/// Type generic parameter
Var = 0x13,
/// Multidimensional array ([*], [,], [,,], ...)
Array = 0x14,
/// Generic instance type
GenericInst = 0x15,
/// Typed byref
TypedByRef = 0x16,
/// Value array (don't use)
ValueArray = 0x17,
/// System.IntPtr
I = 0x18,
/// System.UIntPtr
U = 0x19,
/// native real (don't use)
R = 0x1A,
/// Function pointer
FnPtr = 0x1B,
/// System.Object
Object = 0x1C,
/// Single-dimension, zero lower bound array ([])
SZArray = 0x1D,
/// Method generic parameter
MVar = 0x1E,
/// Required C modifier
CModReqd = 0x1F,
/// Optional C modifier
CModOpt = 0x20,
/// Used internally by the CLR (don't use)
Internal = 0x21,
/// Module (don't use)
Module = 0x3F,
/// Sentinel (method sigs only)
Sentinel = 0x41,
/// Pinned type (locals only)
Pinned = 0x45,
}
public static partial class Extensions {
///
/// Returns true if it's an integer or a floating point type
///
/// Element type
///
public static bool IsPrimitive(this ElementType etype) {
switch (etype) {
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I8:
case ElementType.U8:
case ElementType.R4:
case ElementType.R8:
case ElementType.I:
case ElementType.U:
case ElementType.R:
return true;
default:
return false;
}
}
///
/// Returns the size of the element type in bytes or -1 if it's unknown
///
/// Element type
/// Size of a pointer
///
public static int GetPrimitiveSize(this ElementType etype, int ptrSize = -1) {
switch (etype) {
case ElementType.Boolean:
case ElementType.I1:
case ElementType.U1:
return 1;
case ElementType.Char:
case ElementType.I2:
case ElementType.U2:
return 2;
case ElementType.I4:
case ElementType.U4:
case ElementType.R4:
return 4;
case ElementType.I8:
case ElementType.U8:
case ElementType.R8:
return 8;
case ElementType.Ptr:
case ElementType.FnPtr:
case ElementType.I:
case ElementType.U:
return ptrSize;
default:
return -1;
}
}
///
/// Checks whether it's a value type
///
/// this
/// true if it's a value type, false if it's not a value type or
/// if we couldn't determine whether it's a value type. Eg., it could be a generic
/// instance type.
public static bool IsValueType(this ElementType etype) {
switch (etype) {
case ElementType.Void:
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I8:
case ElementType.U8:
case ElementType.R4:
case ElementType.R8:
case ElementType.ValueType:
case ElementType.TypedByRef:
case ElementType.ValueArray:
case ElementType.I:
case ElementType.U:
case ElementType.R:
return true;
case ElementType.GenericInst:
// We don't have enough info to determine whether this is a value type
return false;
case ElementType.End:
case ElementType.String:
case ElementType.Ptr:
case ElementType.ByRef:
case ElementType.Class:
case ElementType.Var:
case ElementType.Array:
case ElementType.FnPtr:
case ElementType.Object:
case ElementType.SZArray:
case ElementType.MVar:
case ElementType.CModReqd:
case ElementType.CModOpt:
case ElementType.Internal:
case ElementType.Module:
case ElementType.Sentinel:
case ElementType.Pinned:
default:
return false;
}
}
}
}
dnlib-2.1_VS2010/src/DotNet/Emit/ 0000775 0000000 0000000 00000000000 13250336635 0016247 5 ustar 00root root 0000000 0000000 dnlib-2.1_VS2010/src/DotNet/Emit/Code.cs 0000664 0000000 0000000 00000013715 13250336635 0017457 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
namespace dnlib.DotNet.Emit {
///
/// A CIL opcode. If the high byte is 0 or if it's , it's a 1-byte opcode,
/// else it's a two-byte opcode and the highest byte is the first byte of the opcode.
///
public enum Code : ushort {
#pragma warning disable 1591 // disable XML doc warning
UNKNOWN1 = 0x0100,
UNKNOWN2 = 0x0101,
Add = 0x0058,
Add_Ovf = 0x00D6,
Add_Ovf_Un = 0x00D7,
And = 0x005F,
Arglist = 0xFE00,
Beq = 0x003B,
Beq_S = 0x002E,
Bge = 0x003C,
Bge_S = 0x002F,
Bge_Un = 0x0041,
Bge_Un_S = 0x0034,
Bgt = 0x003D,
Bgt_S = 0x0030,
Bgt_Un = 0x0042,
Bgt_Un_S = 0x0035,
Ble = 0x003E,
Ble_S = 0x0031,
Ble_Un = 0x0043,
Ble_Un_S = 0x0036,
Blt = 0x003F,
Blt_S = 0x0032,
Blt_Un = 0x0044,
Blt_Un_S = 0x0037,
Bne_Un = 0x0040,
Bne_Un_S = 0x0033,
Box = 0x008C,
Br = 0x0038,
Br_S = 0x002B,
Break = 0x0001,
Brfalse = 0x0039,
Brfalse_S = 0x002C,
Brtrue = 0x003A,
Brtrue_S = 0x002D,
Call = 0x0028,
Calli = 0x0029,
Callvirt = 0x006F,
Castclass = 0x0074,
Ceq = 0xFE01,
Cgt = 0xFE02,
Cgt_Un = 0xFE03,
Ckfinite = 0x00C3,
Clt = 0xFE04,
Clt_Un = 0xFE05,
Constrained = 0xFE16,
Conv_I = 0x00D3,
Conv_I1 = 0x0067,
Conv_I2 = 0x0068,
Conv_I4 = 0x0069,
Conv_I8 = 0x006A,
Conv_Ovf_I = 0x00D4,
Conv_Ovf_I_Un = 0x008A,
Conv_Ovf_I1 = 0x00B3,
Conv_Ovf_I1_Un = 0x0082,
Conv_Ovf_I2 = 0x00B5,
Conv_Ovf_I2_Un = 0x0083,
Conv_Ovf_I4 = 0x00B7,
Conv_Ovf_I4_Un = 0x0084,
Conv_Ovf_I8 = 0x00B9,
Conv_Ovf_I8_Un = 0x0085,
Conv_Ovf_U = 0x00D5,
Conv_Ovf_U_Un = 0x008B,
Conv_Ovf_U1 = 0x00B4,
Conv_Ovf_U1_Un = 0x0086,
Conv_Ovf_U2 = 0x00B6,
Conv_Ovf_U2_Un = 0x0087,
Conv_Ovf_U4 = 0x00B8,
Conv_Ovf_U4_Un = 0x0088,
Conv_Ovf_U8 = 0x00BA,
Conv_Ovf_U8_Un = 0x0089,
Conv_R_Un = 0x0076,
Conv_R4 = 0x006B,
Conv_R8 = 0x006C,
Conv_U = 0x00E0,
Conv_U1 = 0x00D2,
Conv_U2 = 0x00D1,
Conv_U4 = 0x006D,
Conv_U8 = 0x006E,
Cpblk = 0xFE17,
Cpobj = 0x0070,
Div = 0x005B,
Div_Un = 0x005C,
Dup = 0x0025,
Endfilter = 0xFE11,
Endfinally = 0x00DC,
Initblk = 0xFE18,
Initobj = 0xFE15,
Isinst = 0x0075,
Jmp = 0x0027,
Ldarg = 0xFE09,
Ldarg_0 = 0x0002,
Ldarg_1 = 0x0003,
Ldarg_2 = 0x0004,
Ldarg_3 = 0x0005,
Ldarg_S = 0x000E,
Ldarga = 0xFE0A,
Ldarga_S = 0x000F,
Ldc_I4 = 0x0020,
Ldc_I4_0 = 0x0016,
Ldc_I4_1 = 0x0017,
Ldc_I4_2 = 0x0018,
Ldc_I4_3 = 0x0019,
Ldc_I4_4 = 0x001A,
Ldc_I4_5 = 0x001B,
Ldc_I4_6 = 0x001C,
Ldc_I4_7 = 0x001D,
Ldc_I4_8 = 0x001E,
Ldc_I4_M1 = 0x0015,
Ldc_I4_S = 0x001F,
Ldc_I8 = 0x0021,
Ldc_R4 = 0x0022,
Ldc_R8 = 0x0023,
Ldelem = 0x00A3,
Ldelem_I = 0x0097,
Ldelem_I1 = 0x0090,
Ldelem_I2 = 0x0092,
Ldelem_I4 = 0x0094,
Ldelem_I8 = 0x0096,
Ldelem_R4 = 0x0098,
Ldelem_R8 = 0x0099,
Ldelem_Ref = 0x009A,
Ldelem_U1 = 0x0091,
Ldelem_U2 = 0x0093,
Ldelem_U4 = 0x0095,
Ldelema = 0x008F,
Ldfld = 0x007B,
Ldflda = 0x007C,
Ldftn = 0xFE06,
Ldind_I = 0x004D,
Ldind_I1 = 0x0046,
Ldind_I2 = 0x0048,
Ldind_I4 = 0x004A,
Ldind_I8 = 0x004C,
Ldind_R4 = 0x004E,
Ldind_R8 = 0x004F,
Ldind_Ref = 0x0050,
Ldind_U1 = 0x0047,
Ldind_U2 = 0x0049,
Ldind_U4 = 0x004B,
Ldlen = 0x008E,
Ldloc = 0xFE0C,
Ldloc_0 = 0x0006,
Ldloc_1 = 0x0007,
Ldloc_2 = 0x0008,
Ldloc_3 = 0x0009,
Ldloc_S = 0x0011,
Ldloca = 0xFE0D,
Ldloca_S = 0x0012,
Ldnull = 0x0014,
Ldobj = 0x0071,
Ldsfld = 0x007E,
Ldsflda = 0x007F,
Ldstr = 0x0072,
Ldtoken = 0x00D0,
Ldvirtftn = 0xFE07,
Leave = 0x00DD,
Leave_S = 0x00DE,
Localloc = 0xFE0F,
Mkrefany = 0x00C6,
Mul = 0x005A,
Mul_Ovf = 0x00D8,
Mul_Ovf_Un = 0x00D9,
Neg = 0x0065,
Newarr = 0x008D,
Newobj = 0x0073,
// No = 0xFE19, // Not supported by MS' CLI and must be parsed as an opcode without an operand
Nop = 0x0000,
Not = 0x0066,
Or = 0x0060,
Pop = 0x0026,
Prefix1 = 0x00FE,
Prefix2 = 0x00FD,
Prefix3 = 0x00FC,
Prefix4 = 0x00FB,
Prefix5 = 0x00FA,
Prefix6 = 0x00F9,
Prefix7 = 0x00F8,
Prefixref = 0x00FF,
Readonly = 0xFE1E,
Refanytype = 0xFE1D,
Refanyval = 0x00C2,
Rem = 0x005D,
Rem_Un = 0x005E,
Ret = 0x002A,
Rethrow = 0xFE1A,
Shl = 0x0062,
Shr = 0x0063,
Shr_Un = 0x0064,
Sizeof = 0xFE1C,
Starg = 0xFE0B,
Starg_S = 0x0010,
Stelem = 0x00A4,
Stelem_I = 0x009B,
Stelem_I1 = 0x009C,
Stelem_I2 = 0x009D,
Stelem_I4 = 0x009E,
Stelem_I8 = 0x009F,
Stelem_R4 = 0x00A0,
Stelem_R8 = 0x00A1,
Stelem_Ref = 0x00A2,
Stfld = 0x007D,
Stind_I = 0x00DF,
Stind_I1 = 0x0052,
Stind_I2 = 0x0053,
Stind_I4 = 0x0054,
Stind_I8 = 0x0055,
Stind_R4 = 0x0056,
Stind_R8 = 0x0057,
Stind_Ref = 0x0051,
Stloc = 0xFE0E,
Stloc_0 = 0x000A,
Stloc_1 = 0x000B,
Stloc_2 = 0x000C,
Stloc_3 = 0x000D,
Stloc_S = 0x0013,
Stobj = 0x0081,
Stsfld = 0x0080,
Sub = 0x0059,
Sub_Ovf = 0x00DA,
Sub_Ovf_Un = 0x00DB,
Switch = 0x0045,
Tailcall = 0xFE14,
Throw = 0x007A,
Unaligned = 0xFE12,
Unbox = 0x0079,
Unbox_Any = 0x00A5,
Volatile = 0xFE13,
Xor = 0x0061,
#pragma warning restore
}
public static partial class Extensions {
///
/// Converts a to an
///
/// The code
/// A or null if it's invalid
public static OpCode ToOpCode(this Code code) {
int hi = (ushort)code >> 8;
int lo = (byte)code;
if (hi == 0)
return OpCodes.OneByteOpCodes[lo];
if (hi == 0xFE)
return OpCodes.TwoByteOpCodes[lo];
if (code == Code.UNKNOWN1)
return OpCodes.UNKNOWN1;
if (code == Code.UNKNOWN2)
return OpCodes.UNKNOWN2;
return null;
}
}
}
dnlib-2.1_VS2010/src/DotNet/Emit/DynamicMethodBodyReader.cs 0000664 0000000 0000000 00000042655 13250336635 0023300 0 ustar 00root root 0000000 0000000 // dnlib: See LICENSE.txt for more info
using System;
using System.Collections.Generic;
using SR = System.Reflection;
using System.Reflection.Emit;
using System.IO;
using dnlib.DotNet.MD;
using dnlib.IO;
namespace dnlib.DotNet.Emit {
///
/// Reads code from a DynamicMethod
///
public class DynamicMethodBodyReader : MethodBodyReaderBase, ISignatureReaderHelper {
static readonly ReflectionFieldInfo rtdmOwnerFieldInfo = new ReflectionFieldInfo("m_owner");
static readonly ReflectionFieldInfo dmResolverFieldInfo = new ReflectionFieldInfo("m_resolver");
static readonly ReflectionFieldInfo rslvCodeFieldInfo = new ReflectionFieldInfo("m_code");
static readonly ReflectionFieldInfo rslvDynamicScopeFieldInfo = new ReflectionFieldInfo("m_scope");
static readonly ReflectionFieldInfo rslvMethodFieldInfo = new ReflectionFieldInfo("m_method");
static readonly ReflectionFieldInfo rslvLocalsFieldInfo = new ReflectionFieldInfo("m_localSignature");
static readonly ReflectionFieldInfo rslvMaxStackFieldInfo = new ReflectionFieldInfo("m_stackSize");
static readonly ReflectionFieldInfo rslvExceptionsFieldInfo = new ReflectionFieldInfo("m_exceptions");
static readonly ReflectionFieldInfo rslvExceptionHeaderFieldInfo = new ReflectionFieldInfo("m_exceptionHeader");
static readonly ReflectionFieldInfo scopeTokensFieldInfo = new ReflectionFieldInfo("m_tokens");
static readonly ReflectionFieldInfo gfiFieldHandleFieldInfo = new ReflectionFieldInfo("m_field", "m_fieldHandle");
static readonly ReflectionFieldInfo gfiContextFieldInfo = new ReflectionFieldInfo("m_context");
static readonly ReflectionFieldInfo gmiMethodHandleFieldInfo = new ReflectionFieldInfo("m_method", "m_methodHandle");
static readonly ReflectionFieldInfo gmiContextFieldInfo = new ReflectionFieldInfo("m_context");
static readonly ReflectionFieldInfo ehCatchAddrFieldInfo = new ReflectionFieldInfo("m_catchAddr");
static readonly ReflectionFieldInfo ehCatchClassFieldInfo = new ReflectionFieldInfo("m_catchClass");
static readonly ReflectionFieldInfo ehCatchEndAddrFieldInfo = new ReflectionFieldInfo("m_catchEndAddr");
static readonly ReflectionFieldInfo ehCurrentCatchFieldInfo = new ReflectionFieldInfo("m_currentCatch");
static readonly ReflectionFieldInfo ehTypeFieldInfo = new ReflectionFieldInfo("m_type");
static readonly ReflectionFieldInfo ehStartAddrFieldInfo = new ReflectionFieldInfo("m_startAddr");
static readonly ReflectionFieldInfo ehEndAddrFieldInfo = new ReflectionFieldInfo("m_endAddr");
static readonly ReflectionFieldInfo ehEndFinallyFieldInfo = new ReflectionFieldInfo("m_endFinally");
static readonly ReflectionFieldInfo vamMethodFieldInfo = new ReflectionFieldInfo("m_method");
static readonly ReflectionFieldInfo vamDynamicMethodFieldInfo = new ReflectionFieldInfo("m_dynamicMethod");
readonly ModuleDef module;
readonly Importer importer;
readonly GenericParamContext gpContext;
readonly MethodDef method;
readonly int codeSize;
readonly int maxStack;
readonly List