public static IEnumerable <MethodDef> GetVisibleExtensionMethods(this MetadataTables tables)
{
MetadataRecord eaCtor = GetExtensionAttributeCtor(tables);
if (!eaCtor.IsNull)
{
foreach (CustomAttributeDef ca in tables.CustomAttributes)
{
if (ca.Constructor.Equals(eaCtor) && ca.Parent.IsMethodDef)
{
MethodDef mdef = ca.Parent.MethodDef;
var mattrs = mdef.Attributes;
if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public && (mattrs & MethodAttributes.Static) != 0)
{
var declType = mdef.FindDeclaringType();
var tattrs = declType.Attributes;
if (((tattrs & TypeAttributes.VisibilityMask) == TypeAttributes.Public ||
(tattrs & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic) &&
(tattrs & TypeAttributes.Abstract) != 0 &&
(tattrs & TypeAttributes.Sealed) != 0)
{
yield return(mdef);
}
}
}
}
}
}
// Gets the metadata to be exported to a file.
private DataSet AcquireMetadata()
{
using (AdoDataConnection adoDatabase = new AdoDataConnection("systemSettings"))
{
IDbConnection dbConnection = adoDatabase.Connection;
DataSet metadata = new DataSet();
// Initialize active node ID
Guid nodeID = Guid.Parse(dbConnection.ExecuteScalar($"SELECT NodeID FROM IaonActionAdapter WHERE ID = {ID}").ToString());
// Copy key metadata tables
foreach (string tableExpression in MetadataTables.Split(';'))
{
if (string.IsNullOrWhiteSpace(tableExpression))
{
continue;
}
// Query the table or view information from the database
DataTable table = dbConnection.RetrieveData(adoDatabase.AdapterType, tableExpression);
// Remove any expression from table name
Match regexMatch = Regex.Match(tableExpression, @"FROM \w+");
table.TableName = regexMatch.Value.Split(' ')[1];
// Add a copy of the results to the dataset for metadata exchange
metadata.Tables.Add(table.Copy());
}
return(metadata);
}
}
protected string GetInfo(int v, MetadataTables table, string desc)
{
int ad = this.ptr;
StringBuilder sb = new StringBuilder();
if (this.IndexManager.IsInt32(table))
{
sb.AppendFormat("{0:X8}", v);
ptr += 4;
}
else
{
sb.AppendFormat("{0:X4}", v);
ptr += 2;
}
if (v != 0)
{
ArrayList list = this.IndexManager.Tables[(int)table];
if (0 < v && v <= list.Count)
{
sb.AppendFormat(" ({0})", (list[v - 1] as TableBase).GetTitle());
}
else
{
sb.AppendFormat(" ({0} {1:X} null)", table, v);
}
}
while (sb.Length < 16)
{
sb.Append(' ');
}
return(string.Format("{0:X8}:{1} {2}\r\n", ad, sb, desc));
}
public TableBase CreateTable(MetadataTables table)
{
TableBase ret = MetadataTableCreator.Create(table);
ret.IndexManager = this;
return(ret);
}
private static void DumpMembers(MetadataTables tables)
{
foreach (TypeDef typeDef in tables.TypeDefs)
{
DumpMembers(typeDef);
}
}
public TypeNestings(MetadataTables tables)
{
ContractUtils.Requires(tables != null);
_tables = tables;
_mapping = new Dictionary <MetadataToken, List <MetadataToken> >();
Populate();
}
private static void EnumerateMembers(MetadataTables tables)
{
foreach (TypeDef typeDef in tables.TypeDefs)
{
foreach (FieldDef fieldDef in typeDef.Fields)
{
Counter_Fields++;
}
foreach (MethodDef methodDef in typeDef.Methods)
{
Counter_Methods++;
}
foreach (PropertyDef propertyDef in typeDef.Properties)
{
Counter_Properties++;
}
foreach (EventDef eventDef in typeDef.Events)
{
Counter_Events++;
}
}
}
protected string GetInfo(int v, CodedIndices index, string desc)
{
int ad = this.ptr;
StringBuilder sb = new StringBuilder();
if (this.IndexManager.IsInt32(index))
{
sb.AppendFormat("{0:X8}", v);
ptr += 4;
}
else
{
sb.AppendFormat("{0:X4}", v);
ptr += 2;
}
if (v != 0)
{
MetadataTables tp = this.IndexManager.GetIndexType(index, v);
int idx = this.IndexManager.GetIndex(index, v);
ArrayList list = this.IndexManager.Tables[(int)tp];
if (0 < idx && idx <= list.Count)
{
sb.AppendFormat(" ({0})", (list[idx - 1] as TableBase).GetTitle());
}
else
{
sb.AppendFormat(" ({0} {1:X} null)", tp, idx);
}
}
while (sb.Length < 16)
{
sb.Append(' ');
}
return(string.Format("{0:X8}:{1} {2}\r\n", ad, sb, desc));
}
public TableBase GetTable(MetadataTables t, int v)
{
if (v == 0)
{
return(null);
}
return(this.Tables[(int)t][v - 1] as TableBase);
}
private static void DumpExtensionMethods(MetadataTables tables)
{
_output.WriteLine("Extension methods:");
foreach (MethodDef em in tables.GetVisibleExtensionMethods())
{
TypeDef td = em.FindDeclaringType();
_output.WriteLine("{0}.{1}::{2}", td.Namespace, td.Name, em.Name);
}
}
/// <summary>
/// Obtains an entry in the specified table at the specified index
/// </summary>
/// <param name="table">The table to get the metadata for</param>
/// <param name="index">The index in the table</param>
/// <returns>The MetadataTableRow or null if not found</returns>
public MetadataRow GetEntryFor(MetadataTables table, uint index)
{
MetadataRow o = null;
if (index <= _tables[table].Length)
{
o = _tables[table][index - 1];
}
return(o);
}
public byte GetSizeOfIndex(MetadataTables forTable)
{
byte sizeOfIndex = 2;
if (_rowsInTables.Keys.Contains(forTable) && _rowsInTables[forTable] > ushort.MaxValue)
{
sizeOfIndex = 4;
}
return(sizeOfIndex);
}
private static void EnumerateExtensionMethods(MetadataTables tables)
{
foreach (MethodDef em in tables.GetVisibleExtensionMethods())
{
if (tables.Module != null)
{
var mb = tables.Module.ResolveMethod(em.Record.Token.Value);
}
Counter_ExtensionMethods++;
}
}
private static void ModuleEnumerated(MetadataTables tables)
{
#if CCI
if (tables != null)
{
int mapSize = tables.GetRowCount(0x12) + tables.GetRowCount(0x15);
Counter_MaxMapTablesSize = Math.Max(Counter_MaxMapTablesSize, mapSize);
Counter_TotalMapTablesSize += mapSize;
}
#endif
Counter_Files++;
}
public static void DumpModule(MetadataTables tables)
{
ModuleDef md = tables.ModuleDef;
_output.WriteLine("Module:");
_output.WriteLine(" {0} {1}", md.Name, md.Mvid);
AssemblyDef adef = tables.AssemblyDef;
if (!adef.Record.IsNull)
{
_output.WriteLine("AssemblyDef:");
_output.WriteLine(" {0} {1} {2} {3} {4} {5}",
adef.Name, adef.Version, adef.Culture, adef.NameFlags, adef.HashAlgorithm, BitConverter.ToString(adef.GetPublicKey())
);
}
if (tables.AssemblyRefs.GetCount() > 0)
{
_output.WriteLine("AssemblyRefs:");
foreach (AssemblyRef a in tables.AssemblyRefs)
{
_output.WriteLine(" {0} {1} {2} {3} {4} {5}",
a.Name, a.Version, a.Culture, a.NameFlags, BitConverter.ToString(a.GetHashValue()), BitConverter.ToString(a.GetPublicKeyOrToken())
);
}
}
if (tables.Files.GetCount() > 0)
{
_output.WriteLine("Files:");
foreach (FileDef fd in tables.Files)
{
_output.WriteLine(" {0} {1} {2}",
fd.Name, fd.Attributes, BitConverter.ToString(fd.GetHashValue())
);
}
}
if (tables.ManifestResources.GetCount() > 0)
{
_output.WriteLine("ManifestResources:");
foreach (ManifestResourceDef resource in tables.ManifestResources)
{
_output.WriteLine(" {0} {1} {2} 0x{3:X8}",
resource.Name, resource.Attributes, ImplementationToString(resource.Implementation), resource.Offset
);
}
}
_output.WriteLine(new String('-', 50));
}
public void Add(MetadataTables tables)
{
ContractUtils.Requires(tables != null);
foreach (TypeDef typeDef in tables.TypeDefs)
{
if (typeDef.IsGlobal || typeDef.Attributes.IsNested())
{
continue;
}
MetadataNamePart prefix = typeDef.Namespace.GetExtent();
NamespaceTreeNode ns = null;
while (true)
{
NamespaceTreeNode existing;
if (_names.TryGetValue(prefix, out existing))
{
if (ns == null)
{
existing.AddType(typeDef);
}
else
{
existing.AddNamespace(ns);
}
break;
}
ContractUtils.Assert(prefix.Length > 0);
int lastDot = prefix.LastIndexOf((byte)'.', prefix.Length - 1, prefix.Length);
MetadataNamePart name = (lastDot >= 0) ? prefix.GetPart(lastDot + 1) : prefix;
NamespaceTreeNode newNs = new NamespaceTreeNode(name);
if (ns == null)
{
newNs.AddType(typeDef);
}
else
{
newNs.AddNamespace(ns);
}
ns = newNs;
_names.Add(prefix, ns);
prefix = (lastDot >= 0) ? prefix.GetPart(0, lastDot) : MetadataNamePart.Empty;
}
}
}
private static void DumpMemMappedAssemblies()
{
var tree = new NamespaceTree();
foreach (var file in Directory.GetFiles(Path.GetDirectoryName(typeof(object).Assembly.Location), "*.dll"))
{
try {
tree.Add(MetadataTables.OpenFile(file));
_output.WriteLine(file);
} catch {
}
}
DumpNamespaceTree(tree.Root);
Statistics(tree, true);
}
public static TypeNestings GetTypeNesting(this MetadataTables tables)
{
if (TypeNestings == null)
{
TypeNestings = new Dictionary <MetadataTables, TypeNestings>();
}
lock (TypeNestings) {
if (TypeNestings.TryGetValue(tables, out TypeNestings nestings))
{
nestings = new TypeNestings(tables);
}
return(nestings);
}
}
public static MetadataRecord GetExtensionAttributeCtor(this MetadataTables tables)
{
AssemblyDef adef = tables.AssemblyDef;
if (!adef.Record.IsNull)
{
foreach (CustomAttributeDef ca in adef.CustomAttributes)
{
if (IsExtensionAttribute(ca))
{
return(ca.Constructor);
}
}
}
// TODO: other modules can contain extension methods too
return(default(MetadataRecord));
}
private static void DumpNestedTypes(MetadataTables tables)
{
_output.WriteLine("Type nesting: ");
TypeNestings nesting = new TypeNestings(tables);
_output.WriteLine("Total pairs: {0}",
(from e in nesting.GetEnclosingTypes()
from n in nesting.GetNestedTypes(e)
select 1).Sum()
);
DumpNestedTypes(nesting, 0,
// top-level:
from TypeDef typeDef in nesting.GetEnclosingTypes()
where !typeDef.Attributes.IsNested()
select typeDef
);
}
public bool IsInt32(MetadataTables table)
{
return(this.TableRows[(int)table] > max16);
}
public static TableBase Create(MetadataTables tbl)
{
switch (tbl)
{
case MetadataTables.Assembly:
return new AssemblyTable();
case MetadataTables.AssemblyOS:
return new AssemblyOSTable();
case MetadataTables.AssemblyProcessor:
return new AssemblyProcessorTable();
case MetadataTables.AssemblyRef:
return new AssemblyRefTable();
case MetadataTables.AssemblyRefOS:
return new AssemblyRefOSTable();
case MetadataTables.AssemblyRefProcessor:
return new AssemblyRefProcessorTable();
case MetadataTables.ClassLayout:
return new ClassLayoutTable();
case MetadataTables.Constant:
return new ConstantTable();
case MetadataTables.CustomAttribute:
return new CustomAttributeTable();
case MetadataTables.DeclSecurity:
return new DeclSecurityTable();
case MetadataTables.EventMap:
return new EventMapTable();
case MetadataTables.Event:
return new EventTable();
case MetadataTables.ExportedType:
return new ExportedTypeTable();
case MetadataTables.Field:
return new FieldTable();
case MetadataTables.FieldLayout:
return new FieldLayoutTable();
case MetadataTables.FieldMarshal:
return new FieldMarshalTable();
case MetadataTables.FieldRVA:
return new FieldRVATable();
case MetadataTables.File:
return new FileTable();
case MetadataTables.ImplMap:
return new ImplMapTable();
case MetadataTables.InterfaceImpl:
return new InterfaceImplTable();
case MetadataTables.ManifestResource:
return new ManifestResourceTable();
case MetadataTables.MemberRef:
return new MemberRefTable();
case MetadataTables.MethodDef:
return new MethodDefTable();
case MetadataTables.MethodImpl:
return new MethodImplTable();
case MetadataTables.MethodSemantics:
return new MethodSemanticsTable();
case MetadataTables.Module:
return new ModuleTable();
case MetadataTables.ModuleRef:
return new ModuleRefTable();
case MetadataTables.NestedClass:
return new NestedClassTable();
case MetadataTables.Param:
return new ParamTable();
case MetadataTables.Property:
return new PropertyTable();
case MetadataTables.PropertyMap:
return new PropertyMapTable();
case MetadataTables.StandAloneSig:
return new StandAloneSigTable();
case MetadataTables.TypeDef:
return new TypeDefTable();
case MetadataTables.TypeRef:
return new TypeRefTable();
case MetadataTables.TypeSpec:
return new TypeSpecTable();
}
return null;
}
private static string MdTablesToString(MetadataTables tables)
{
return(tables.Module != null ? tables.Module.Assembly + ":" + tables.Module : tables.Path);
}
public TableBase GetTable(MetadataTables t, int v)
{
if (v == 0) return null;
return this.Tables[(int) t][v - 1] as TableBase;
}
public bool IsInt32(MetadataTables table)
{
return this.TableRows[(int) table] > max16;
}
public TableBase CreateTable(MetadataTables table)
{
TableBase ret = MetadataTableCreator.Create(table);
ret.IndexManager = this;
return ret;
}
internal static MetadataRecord Null(MetadataTables tables)
{
return(new MetadataRecord(new MetadataToken(0), tables));
}
internal MetadataRecord(MetadataToken token, MetadataTables tables)
{
Contract.Assert(tables != null);
m_token = token;
m_tables = tables;
}
/// <summary>
/// Initialises a already determined instance of a CodedIndex class.
/// </summary>
/// <param name="table">The table the coded index is for</param>
/// <param name="index">The index in the table</param>
public CodedIndex(MetadataTables table, UInt32 index)
{
_table = table;
_index = index;
}
internal MetadataStream(PeCoffFile file, uint address)
{
_owningFile = file;
byte[] contents = file.FileContents;
Offset offset = (int)address;
offset.Shift(4); // reserved1 = BitConverter.ToUInt32(contents, offset.Shift(4));
offset.Shift(1); // majorVersion = contents[offset.Shift(1)];
offset.Shift(1); // minorVersion = contents[offset.Shift(1)];
_heapOffsetSizes = (HeapOffsetSizes)contents.GetValue(offset.Shift(1));
offset.Shift(1); // reserved2 = contents[offset.Shift(1)];
ulong valid = BitConverter.ToUInt64(contents, offset.Shift(8));
offset.Shift(8); // sorted = BitConverter.ToUInt64(contents, offset.Shift(8));
// Now we need to read the number of rows present in the available tables, we have
// had to add the unused tables to the MEtadatTables as mscorlib seems to use one. Not
// sure which though.
Dictionary <MetadataTables, int> rowsInPresentTables = new Dictionary <MetadataTables, int>();
Array values = Enum.GetValues(typeof(MetadataTables));
for (int i = 0; i < values.Length - 1; i++)
{
MetadataTables current = (MetadataTables)values.GetValue(i);
ulong mask = (ulong)1 << (int)current;
if ((mask & valid) == mask)
{
rowsInPresentTables.Add(current, BitConverter.ToInt32(contents, offset.Shift(4)));
}
}
// build index helper classes for metadata row creation
ICodedIndexResolver resolver = new CodedIndexResolver(rowsInPresentTables);
IIndexDetails indexDetails = new IndexDetails(rowsInPresentTables,
SizeOfStringIndexes,
SizeOfBlobIndexes,
SizeOfGuidIndexes
);
// Following the array of row size we get the actual metadata tables
_tables = new MetadataTablesDictionary(rowsInPresentTables.Count);
for (int i = 0; i < values.Length; i++)
{
MetadataTables current = (MetadataTables)values.GetValue(i);
if (!rowsInPresentTables.ContainsKey(current))
{
continue;
}
int numRows = rowsInPresentTables[current];
MetadataRow[] rows = new MetadataRow[numRows];
switch (current)
{
case MetadataTables.Module:
for (int j = 0; j < numRows; j++)
{
rows[j] = new ModuleMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.TypeRef:
for (int j = 0; j < numRows; j++)
{
rows[j] = new TypeRefMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.TypeDef:
for (int j = 0; j < numRows; j++)
{
rows[j] = new TypeDefMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.Field:
for (int j = 0; j < numRows; j++)
{
rows[j] = new FieldMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.MethodDef:
for (int j = 0; j < numRows; j++)
{
rows[j] = new MethodMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.Param:
for (int j = 0; j < numRows; j++)
{
rows[j] = new ParamMetadataTableRow(contents, offset, SizeOfStringIndexes);
}
break;
case MetadataTables.InterfaceImpl:
for (int j = 0; j < numRows; j++)
{
rows[j] = new InterfaceImplMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.MemberRef:
for (int j = 0; j < numRows; j++)
{
rows[j] = new MemberRefMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.Constant:
for (int j = 0; j < numRows; j++)
{
rows[j] = new ConstantMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.CustomAttribute:
for (int j = 0; j < numRows; j++)
{
rows[j] = new CustomAttributeMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.FieldMarshal:
for (int j = 0; j < numRows; j++)
{
rows[j] = new FieldMarshalMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.DeclSecurity:
for (int j = 0; j < numRows; j++)
{
rows[j] = new DeclSecurityMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.ClassLayout:
for (int j = 0; j < numRows; j++)
{
rows[j] = new ClassLayoutMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.FieldLayout:
for (int j = 0; j < numRows; j++)
{
rows[j] = new FieldLayoutMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.StandAloneSig:
for (int j = 0; j < numRows; j++)
{
rows[j] = new StandAloneSigMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.EventMap:
for (int j = 0; j < numRows; j++)
{
rows[j] = new EventMapMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.Event:
for (int j = 0; j < numRows; j++)
{
rows[j] = new EventMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.PropertyMap:
for (int j = 0; j < numRows; j++)
{
rows[j] = new PropertyMapMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.Property:
for (int j = 0; j < numRows; j++)
{
rows[j] = new PropertyMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.MethodSemantics:
for (int j = 0; j < numRows; j++)
{
rows[j] = new MethodSemanticsMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.MethodImpl:
for (int j = 0; j < numRows; j++)
{
rows[j] = new MethodImplMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.ModuleRef:
for (int j = 0; j < numRows; j++)
{
rows[j] = new ModuleRefMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.TypeSpec:
for (int j = 0; j < numRows; j++)
{
rows[j] = new TypeSpecMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.ImplMap:
for (int j = 0; j < numRows; j++)
{
rows[j] = new ImplMapMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.FieldRVA:
for (int j = 0; j < numRows; j++)
{
rows[j] = new FieldRVAMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.Assembly:
for (int j = 0; j < numRows; j++)
{
rows[j] = new AssemblyMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.AssemblyProcessor:
for (int j = 0; j < numRows; j++)
{
rows[j] = new AssemblyProcessorMetadataTableRow(contents, offset);
}
break;
case MetadataTables.AssemblyOS:
for (int j = 0; j < numRows; j++)
{
rows[j] = new AssemblyOSMetadataTableRow(contents, offset);
}
break;
case MetadataTables.AssemblyRef:
for (int j = 0; j < numRows; j++)
{
rows[j] = new AssemblyRefMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.AssemblyRefProcessor:
for (int j = 0; j < numRows; j++)
{
rows[j] = new AssemblyRefProcessorMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.AssemblyRefOS:
for (int j = 0; j < numRows; j++)
{
rows[j] = new AssemblyRefOSMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.File:
for (int j = 0; j < numRows; j++)
{
rows[j] = new FileMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.ExportedType:
for (int j = 0; j < numRows; j++)
{
rows[j] = new ExportedTypeMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.ManifestResource:
for (int j = 0; j < numRows; j++)
{
rows[j] = new ManifestResourceMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.NestedClass:
for (int j = 0; j < numRows; j++)
{
rows[j] = new NestedClassMetadataTableRow(contents, offset, indexDetails);
}
break;
case MetadataTables.GenericParam:
for (int j = 0; j < numRows; j++)
{
rows[j] = new GenericParamMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.MethodSpec:
for (int j = 0; j < numRows; j++)
{
rows[j] = new MethodSpecMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
case MetadataTables.GenericParamConstraint:
for (int j = 0; j < numRows; j++)
{
rows[j] = new GenericParamConstraintMetadataTableRow(contents, offset, resolver, indexDetails);
}
break;
}
_tables.SetMetadataTable(current, rows);
}
}
static void Main(string[] args)
{
//Detailed = true;
//DumpMembers(typeof(Tests.Class1<,,,,>));
//DumpMembers(typeof(System.Security.Policy.NetCodeGroup), true);
List <string> argList = new List <string>(args);
if (argList.Remove("/?"))
{
Console.WriteLine("Usage: Metadata.exe [options] [assembly list|*]");
Console.WriteLine();
Console.WriteLine("options:");
Console.WriteLine(" /ref use reflection; implies /load");
Console.WriteLine(" /load load assemblies");
Console.WriteLine(" /ep compares enumerating properties and events vs. methods and fields");
Console.WriteLine(" /t test all APIs, no output, catch any expected exception");
Console.WriteLine(" /f simple fuzzing test");
Console.WriteLine(" /d [options] dump");
Console.WriteLine(" n ... namespace tree (default)");
Console.WriteLine(" p ... PE file headers");
Console.WriteLine(" o ... module metadata");
Console.WriteLine(" s ... statistics");
Console.WriteLine(" e ... extension methods");
Console.WriteLine(" t ... nested types");
Console.WriteLine(" m ... members");
Console.WriteLine(" d ... member details");
Console.WriteLine(" /expect <path> compares /d output with a content of a file");
Console.WriteLine();
Console.WriteLine("assembly list");
Console.WriteLine(" -empty- current mscorlib.dll, System.Core.dll, System.dll");
Console.WriteLine(" * about 100 assemblies from the current .NET Framework");
Console.WriteLine(" file1 file2 ... specified files");
return;
}
// options:
bool test = argList.Remove("/t");
bool fuzz = argList.Remove("/f");
bool useReflection = argList.Remove("/ref");
bool loadAssemblies = argList.Remove("/load");
bool enumProperties = argList.Remove("/ep");
if (fuzz && (test || enumProperties || useReflection))
{
Console.Error.WriteLine("Can't use /f with /t, /ref or /ep");
return;
}
if (test && useReflection)
{
Console.Error.WriteLine("Can't use /ref with /t");
return;
}
if (enumProperties && useReflection)
{
Console.Error.WriteLine("Can't use /ref with /ep");
return;
}
if (useReflection)
{
loadAssemblies = true;
}
string dumpOptions;
int dumpIdx = argList.IndexOf("/d");
if (dumpIdx >= 0)
{
if (dumpIdx + 1 < argList.Count)
{
dumpOptions = argList[dumpIdx + 1];
argList.RemoveAt(dumpIdx + 1);
}
else
{
dumpOptions = "n";
}
argList.RemoveAt(dumpIdx);
}
else
{
dumpOptions = null;
}
string expectedOutputFile;
int expectedIdx = argList.IndexOf("/expect");
if (expectedIdx >= 0)
{
if (expectedIdx + 1 < argList.Count)
{
expectedOutputFile = argList[expectedIdx + 1];
argList.RemoveAt(expectedIdx + 1);
}
else
{
Console.Error.WriteLine("/expected requires a file");
return;
}
argList.RemoveAt(expectedIdx);
}
else
{
expectedOutputFile = null;
}
bool allFwAssemblies = argList.Remove("*");
// assemblies:
IEnumerable <string> assemblyFiles = argList;
if (allFwAssemblies)
{
string fwDir = Path.GetDirectoryName(typeof(object).Assembly.Location);
assemblyFiles = assemblyFiles.Concat(
from fileName in AssemblyList.FwAssemblies
select Path.Combine(fwDir, fileName)
);
}
else if (argList.Count == 0)
{
argList.Add(typeof(object).Assembly.Location);
argList.Add(typeof(Expression).Assembly.Location);
argList.Add(typeof(Regex).Assembly.Location);
}
// tables:
List <MetadataTables> tables;
IEnumerable <Assembly> assemblies;
if (loadAssemblies)
{
assemblies = LoadAssemblies(assemblyFiles);
if (useReflection)
{
tables = null;
}
else
{
Stopwatch swTableLoad = new Stopwatch();
swTableLoad.Start();
tables = new List <MetadataTables>(from assembly in assemblies
from module in assembly.GetModules(false)
select module.GetMetadataTables());
swTableLoad.Stop();
_output.WriteLine("{0} modules loaded in {1}ms", tables.Count, swTableLoad.ElapsedMilliseconds);
}
}
else
{
assemblies = null;
Stopwatch swTableLoad = new Stopwatch();
tables = new List <MetadataTables>();
foreach (var file in assemblyFiles)
{
try {
swTableLoad.Start();
tables.Add(MetadataTables.OpenFile(file));
swTableLoad.Stop();
} catch (FileNotFoundException) {
_output.WriteLine("File {0} doesn't exist.", file);
} catch (BadImageFormatException) {
_output.WriteLine("{0} is not a valid PE file", file);
}
}
if (dumpOptions == null)
{
_output.WriteLine("Metadata tables ({0}) loaded in {1}ms", tables.Count, swTableLoad.ElapsedMilliseconds);
}
}
if (fuzz)
{
FuzzTables(tables);
return;
}
if (test)
{
Test(tables);
return;
}
if (dumpOptions != null)
{
string tempDumpFile = "dump.txt";
bool success = false;
if (expectedOutputFile != null)
{
_output = new StreamWriter(tempDumpFile, false, new UTF8Encoding(true, false), 0x400);
}
try {
try {
DumpTables(
tables,
dumpPE: dumpOptions.IndexOf('p') >= 0,
dumpModule: dumpOptions.IndexOf('o') >= 0,
dumpStatistics: dumpOptions.IndexOf('s') >= 0,
dumpNamespaces: dumpOptions.IndexOf('n') >= 0,
dumpExtensionMethods: dumpOptions.IndexOf('e') >= 0,
dumpNestedTypes: dumpOptions.IndexOf('t') >= 0,
dumpMembers: dumpOptions.IndexOf('m') >= 0,
dumpMemberDetails: dumpOptions.IndexOf('d') >= 0
);
} finally {
if (expectedOutputFile != null)
{
_output.Close();
}
}
if (expectedOutputFile != null)
{
// TODO: extract zip and compare
}
success = true;
} finally {
if (success && _output != null)
{
File.Delete(tempDumpFile);
}
}
return;
}
if (enumProperties)
{
Measure(() => EnumerateProperties(tables));
return;
}
if (assemblies != null)
{
if (useReflection)
{
Measure(() => ReflectionEnumerate(assemblies));
}
else
{
Measure(() => Enumerate(tables));
}
}
else
{
Measure(() => Enumerate(tables));
}
if (Counter_Files > 0)
{
_output.WriteLine("Enumerated {0} extension methods and {1} types.", Counter_ExtensionMethods, Counter_Types);
_output.WriteLine("PropertyMap and EventMap sizes: max {0}, avg {1} per file.", Counter_MaxMapTablesSize, Counter_TotalMapTablesSize / Counter_Files);
}
}
protected int ReadIndex(MetadataTables table)
{
return(this.IndexManager.IsInt32(table) ? this.ReadInt32():
this.ReadInt16());
}
