public IAssembly FindAssembly(string assemblyFile)
{
if (File.Exists(assemblyFile))
{
//Mono.Cecil.AssemblyDefinition ad = Mono.Cecil.AssemblyDefinition.ReadAssembly(assemblyFile);
//string fullName = ad.Name.FullName;
string fullName;
if (PathUtils.IsNetModule(assemblyFile))
{
fullName = assemblyFile;
}
else
{
AssemblyName an = AssemblyName.GetAssemblyName(assemblyFile);
fullName = an.FullName;
}
for (int i = 0; i < this.Assemblies.Count; i++)
{
IAssembly a = this.Assemblies[i];
if (a.Location.Equals(assemblyFile, StringComparison.OrdinalIgnoreCase) ||
fullName.Equals(a.ToString()))
{
return(a);
}
}
}
return(null);
}
public static void Main()
{
IServiceProvider serviceProvider = new ApplicationManager(null);
IAssemblyManager assemblyManager = (IAssemblyManager)serviceProvider.GetService(typeof(IAssemblyManager));
IAssembly assembly = assemblyManager.LoadFile(typeof(CodeModelExample).Module.FullyQualifiedName);
Console.WriteLine("Assembly: " + assembly.ToString());
foreach (IModule module in assembly.Modules)
{
Console.WriteLine("Module: " + module.Name);
foreach (ITypeDeclaration typeDeclaration in module.Types)
{
Console.WriteLine("Type: " + typeDeclaration.Namespace + "." + typeDeclaration.Name);
foreach (IMethodDeclaration methodDeclaration in typeDeclaration.Methods)
{
Console.WriteLine("Method: " + methodDeclaration);
IMethodBody methodBody = methodDeclaration.Body as IMethodBody;
if (methodBody != null)
{
foreach (IInstruction instruction in methodBody.Instructions)
{
Console.Write("L" + instruction.Offset.ToString("X4", CultureInfo.InvariantCulture));
Console.Write(": ");
Console.Write(InstructionTable.GetInstructionName(instruction.Code));
if (instruction.Value != null)
{
Console.Write(" ");
if (instruction.Value is string)
{
Console.Write("\"");
}
Console.Write(instruction.Value.ToString());
if (instruction.Value is string)
{
Console.Write("\"");
}
}
Console.WriteLine();
}
}
}
}
}
assemblyManager.Unload(assembly);
}
public override void VisitAssembly(IAssembly value)
{
if (_configuration["ShowNamespaceBody"] == "true")
{
base.VisitAssembly(value);
}
else
{
_formatter.Write("# Assembly ");
_formatter.WriteDeclaration(value.Name);
_formatter.WriteProperty("Name", value.ToString());
_formatter.WriteProperty("Location", value.Location);
}
}
private IncludeStatus GetIncludeStatus(IAssembly assembly)
{
ThinAssembly modelAssembly;
if (!_rootAssemblies.TryGetValue(assembly, out modelAssembly))
{
if (_depot.ContainsAssembly(assembly))
{
return(_closureStatus);
}
throw new Exception("could not find IncludeStatus for assembly " + assembly.ToString());
}
return(modelAssembly.IncludeStatus);
}
private IncludeStatus GetIncludeStatus(IAssembly assembly)
{
ThinAssembly modelAssembly;
if (!_rootAssemblies.TryGetValue(assembly, out modelAssembly))
{
if (_depot.ContainsAssembly(assembly))
return _closureStatus;
throw new Exception("could not find IncludeStatus for assembly " + assembly.ToString());
}
return modelAssembly.IncludeStatus;
}
internal static string BuildTypeNameInternal(this IType target, bool shortFormGeneric = false, bool numericTypeParams = false, TypeParameterDisplayMode typeParameterDisplayMode = TypeParameterDisplayMode.SystemStandard)
{
switch (target.ElementClassification)
{
case TypeElementClassification.None:
if (target is IGenericParameter)
{
if (numericTypeParams)
{
var genericParameter = (IGenericParameter)target;
if (genericParameter.Parent is IType)
{
return(string.Format("!{0}", genericParameter.Position));
}
else
{
return(string.Format("!!{0}", genericParameter.Position));
}
}
else
{
return(((IGenericParameter)(target)).Name);
}
}
string targetName = target.Name;
var genericTarget = target as IGenericType;
if (typeParameterDisplayMode == TypeParameterDisplayMode.SystemStandard && genericTarget != null && genericTarget.IsGenericConstruct)
{
int count = 0;
if (genericTarget.ElementClassification == TypeElementClassification.None)
{
if ((count = genericTarget.TypeParameters.Count) > 0)
{
targetName += '`' + count.ToString();
}
}
else if (genericTarget.ElementClassification == TypeElementClassification.GenericTypeDefinition)
{
var genericElementType = genericTarget.ElementType as IGenericType;
if (genericElementType != null)
{
if ((count = genericElementType.TypeParameters.Count) > 0)
{
targetName += '`' + count.ToString();
}
}
else
{
targetName += "`?";
}
}
}
if (target.Parent != null && !(target.Parent is INamespaceDeclaration ||
target.Parent is IAssembly))
{
return(string.Format("{0}+{1}", target.Parent.BuildVariedName(shortFormGeneric, numericTypeParams, typeParameterDisplayMode), targetName));
}
else if (!string.IsNullOrEmpty(target.NamespaceName))
{
return(string.Format("{0}.{1}", target.NamespaceName, targetName));
}
else
{
return(targetName);
}
case TypeElementClassification.Array:
if (target is IArrayType)
{
var arrayVariant = target as IArrayType;
if (arrayVariant.Flags == ArrayFlags.Vector)
{
return(string.Format("{0}[]", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
}
else if ((arrayVariant.Flags & ArrayFlags.DimensionLengths) == ArrayFlags.DimensionLengths || (arrayVariant.Flags & ArrayFlags.DimensionLowerBounds) == ArrayFlags.DimensionLowerBounds)
{
var lengths = arrayVariant.Lengths;
var lowerBounds = arrayVariant.LowerBounds;
int lengthCount = 0,
lowerBoundCount = 0;
if (lengths != null)
{
lengthCount = lengths.Count;
}
if (lowerBounds != null)
{
lowerBoundCount = lowerBounds.Count;
}
StringBuilder sb = new StringBuilder();
bool first = true;
for (int i = 0; i < arrayVariant.ArrayRank; i++)
{
if (first)
{
first = false;
}
else
{
sb.Append(",");
}
bool addedDots;
if (addedDots = (i < lowerBoundCount))
{
sb.AppendFormat("{0}...", lowerBounds[i]);
}
if (i < lengthCount)
{
if (addedDots)
{
sb.Append(lowerBounds[i] + lengths[i] - 1);
}
else
{
sb.AppendFormat("0...{0}", lengths[i] - 1);
}
}
}
return(string.Format("{0}[{1}]", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams), sb.ToString()));
}
else
{
return(string.Format("{0}[{1}]", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams), ','.Repeat(arrayVariant.ArrayRank - 1)));
}
}
else
{
return(string.Format("{0}[?,...]", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
}
case TypeElementClassification.Nullable:
return(string.Format("{0}?", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
case TypeElementClassification.Pointer:
return(string.Format("{0}*", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
case TypeElementClassification.Reference:
return(string.Format("{0}&", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
case TypeElementClassification.GenericTypeDefinition:
if (target is IGenericType)
{
/*Apply the rules across the generic parameters. With an alternate route for numeric identity. */
return(string.Format("{0}{2}{1}{3}", target.ElementType.BuildTypeName(typeParameterDisplayMode: typeParameterDisplayMode), string.Join(",",
((IGenericType)(target)).GenericParameters.OnAll(genericReplacement =>
{
if (shortFormGeneric)
{
if (genericReplacement.IsGenericTypeParameter)
{
if (numericTypeParams)
{
var genericParameterReplacement = (IGenericParameter)genericReplacement;
if (genericParameterReplacement.Parent is IType)
{
return string.Format("!{0}", genericParameterReplacement.Position);
}
else
{
return string.Format("!!{0}", genericParameterReplacement.Position);
}
}
else
{
return genericReplacement.Name;
}
}
else
{
return genericReplacement.BuildTypeName(shortFormGeneric, true);
}
}
else if (genericReplacement.IsGenericTypeParameter)
{
if (numericTypeParams && typeParameterDisplayMode != TypeParameterDisplayMode.CommentStandard)
{
var genericParameterReplacement = (IGenericParameter)genericReplacement;
if (genericParameterReplacement.Parent is IType)
{
return string.Format("[!{0}]", genericParameterReplacement.Position);
}
else
{
return string.Format("[!!{0}]", genericParameterReplacement.Position);
}
}
else
{
return string.Format("[{0}]", genericReplacement.Name);
}
}
else if (genericReplacement.Assembly == null)
{
return genericReplacement.FullName;
}
else if (typeParameterDisplayMode == TypeParameterDisplayMode.CommentStandard)
{
return genericReplacement.BuildTypeName(shortFormGeneric, numericTypeParams, typeParameterDisplayMode);
}
else
{
try
{
IAssembly replacementAssembly = genericReplacement.Assembly;
return string.Format("[{0}, {1}]", genericReplacement.FullName, replacementAssembly.ToString());
}
//For Symbol types.
catch (NotSupportedException)
{
return string.Format("{0}", genericReplacement.FullName);
}
}
}).ToArray()), GetGenericOpenGlyph(typeParameterDisplayMode), GetGenericCloseGlyph(typeParameterDisplayMode)));
}
else /* If they report they're generic, but do not implement the proper interface, we're somewhat out of luck. */
{
return(string.Format("{0}{1}[?],...{2}", target.ElementType.BuildTypeName(true, numericTypeParams, typeParameterDisplayMode), GetGenericOpenGlyph(typeParameterDisplayMode), GetGenericCloseGlyph(typeParameterDisplayMode)));
}
}
return(null);
}
public void WriteAssembly(IAssembly value)
{
this.formatter.Write("// JS Assembly");
this.formatter.Write(" ");
this.formatter.WriteDeclaration(value.Name);
if (value.Version != null)
{
this.formatter.Write(", ");
this.formatter.Write("Version");
this.formatter.Write(" ");
this.formatter.Write(value.Version.ToString());
}
this.formatter.WriteLine();
if ((this.configuration["ShowCustomAttributes"] == "true") && (value.Attributes.Count != 0))
{
this.formatter.WriteLine();
this.WriteCustomAttributeList(value, this.formatter);
this.formatter.WriteLine();
}
this.formatter.WriteProperty("Location", value.Location);
this.formatter.WriteProperty("Name", value.ToString());
switch (value.Type)
{
case AssemblyType.Application:
this.formatter.WriteProperty("Type", "Windows Application");
break;
case AssemblyType.Console:
this.formatter.WriteProperty("Type", "Console Application");
break;
case AssemblyType.Library:
this.formatter.WriteProperty("Type", "Library");
break;
}
}
