modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/Windows/RefGraph/refgraph8.sg

1140 lines
34 KiB
Plaintext
Raw Normal View History

RDK 2.0
2008-11-17 18:29:00 -05:00
// ----------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ----------------------------------------------------------------------------
using System;
using System.IO;
using System.Xml;
using System.Compiler;
using System.Collections;
using Microsoft.SpecSharp.Collections;
public class Test{
public static bool oneLine = false;
public static bool staticsOnly = false;
public static bool verbose = false;
public static bool outputXml = false;
public static bool outputLogicalModulesOnly = false;
public static int Main(string[] args){
string[]! nargs = (string[]!)args;
bool needHelp = false;
bool firstModuleOverridesStdLib = false;
RefGraph rg = new RefGraph();
// Process flags first
foreach (string! file in nargs) {
if (file[0] == '/' || file[0] == '-') {
switch (file[1]) {
case '?':
case 'h':
case 'H':
needHelp = true;
break;
case 'l':
case 'L':
oneLine = true;
assert outputXml == false;
break;
case 'm':
case 'M':
outputLogicalModulesOnly = true;
break;
case 'n':
case 'N':
firstModuleOverridesStdLib = true;
break;
case 's':
case 'S':
staticsOnly = true;
break;
case 'v':
case 'V':
verbose = true;
break;
case 'x':
case 'X':
outputXml = true;
assert oneLine == false;
break;
default:
needHelp = true;
break;
}
}
}
if (needHelp) {
Usage();
return 0;
}
// Now process files
foreach (string! file in nargs) {
if (file[0] != '/' && file[0] != '-') {
string fullpath = Path.GetFullPath(file);
if (firstModuleOverridesStdLib) {
string dir = Path.GetDirectoryName(fullpath);
SystemTypes.Initialize(false, false);
SystemTypes.Clear();
TargetPlatform.SetToV1_1(dir);
SystemAssemblyLocation.Location = fullpath;
SystemCompilerRuntimeAssemblyLocation.Location =
Path.Combine(dir, "System.Compiler.Runtime.dll");
SystemTypes.Initialize(true, true);
// So we don't try to override it again (once is enough)
firstModuleOverridesStdLib = false;
}
if (verbose) {
Console.WriteLine("Scanning: " + file);
}
Module m = Module.GetModule(file, true, true, true);
rg.Visit(m);
rg.FixNamespaceKeys();
}
}
if (Console.Out != null) {
if (outputXml) {
XmlDocument doc;
doc = rg.DumpAllDependenciesToXml();
assert doc != null;
doc.Save(Console.Out as TextWriter);
}
else {
rg.Dump(Console.Out);
}
}
return 0;
}
public static void Usage()
{
Console.Write(
"Usage:\n" +
" refgraph [options] <assemblies>\n" +
"Options:\n" +
" /l -- Format one-line output for findstr or grep.\n" +
" /m -- Output template for assigning logical modules to\n" +
" type declarations.\n" +
" /n -- Uses the first assembly as stdlib instead of using\n" +
" the standard library (mscorlib.dll).\n" +
" /s -- Only consider static references (non instance based).\n" +
" /v -- Output diagnostic messages.\n" +
" /x -- Output type dependencies as xml.\n" +
" /? -- Display this help screen.\n" +
"Summary:\n" +
" Dumps the graph of cross references for each type.\n"
);
}
}
interface IDump {
void Dump(TextWriter! tr);
}
enum DeclKind
{
Assembly,
Namespace,
Type,
Method,
Field
}
[Flags]
enum DepKind
{
baseClass = 1,
iface = 2,
sig = 4,
code = 8,
attr = 16,
};
class Dep
{
public Decl! decl;
public DepKind kind;
public Dep(Decl! decl, DepKind kind)
{
this.decl = decl;
this.kind = kind;
}
[Microsoft.Contracts.Confined]
public override string! ToString() {
string blah = decl + " (" + KindString() + ")";
assert blah != null;
return blah;
}
public string! KindString() {
if (kind == DepKind.baseClass)
return "base";
else
return (string!) kind.ToString();
}
public XmlElement! CreateXmlElement(XmlDocument! doc)
{
XmlElement elem = doc.CreateElement("Dep");
assert elem != null;
Decl.DumpXmlRef(decl, "DepDeclId", elem);
elem.SetAttribute("Kind", KindString());
return elem;
}
}
// A decl can be a namespace, type, method, or field
class Decl
{
// Name of the namespace, type, method, or field
string! fullName;
string! shortName;
public int key;
public bool hasFullInfo = false;
public bool alreadyOutput = false;
public static int largestKey = 0;
// Only used by members
public bool isStatic = false;
// Only used by members
string access = null;
// Scope of this decl. For example, the scope of a method
// or field decl is the enclosing type. The scope of a class
// decl is a namespace or nested class decl.
public Decl lexicalScope = null;
public Decl containingAssembly = null;
// Decls this decl depends on. For a method, the decls are
// the return and parameter types. For a field, the decl is
// the field type. For a class, the decl is the base type
// and interface types. A namespace decl has no dependencies.
public ArrayList/*<Dep>*/ dependencies = new ArrayList/*<Dep>*/();
// The kind of decl this is: namespace, type, method, or field
public DeclKind kind;
public Decl(string! fullName, string! shortName, int key, DeclKind kind)
{
this.fullName = fullName;
this.shortName = shortName;
this.key = key;
this.kind = kind;
if (key > largestKey)
largestKey = key;
}
[Microsoft.Contracts.Confined]
public override bool Equals(object rhs) {
Decl declRhs = rhs as Decl;
if (declRhs == null)
return false;
return Equals(declRhs);
}
[Microsoft.Contracts.Confined]
public bool Equals(Decl rhs) {
if (rhs == null)
return false;
return this.key == rhs.key;
}
[Microsoft.Contracts.Confined]
public override string! ToString()
{
string blah = shortName + " (" + kind.ToString() + ")" + (hasFullInfo ? " FULL" : "");
assert blah != null;
return blah;
}
public void Dump(TextWriter! o, int indent)
{
Indent(o, indent);
o.WriteLine(ToString());
Indent(o, indent+1);
o.Write("Scope: ");
if (lexicalScope == null)
o.WriteLine("(null)");
else {
assert lexicalScope != null;
o.WriteLine(lexicalScope);
}
if (containingAssembly != null) {
Indent(o, indent+1);
o.WriteLine("Assembly: " + containingAssembly);
}
assert dependencies != null;
for (int i = 0; i < dependencies.Count; ++i) {
Dep dep = dependencies[i] as Dep;
assert dep != null;
Indent(o, indent+1);
o.WriteLine("Dependency: " + dep);
}
}
public static void Indent(TextWriter! o, int indent)
{
for (int i = 0; i < indent; ++i) {
o.Write(" ");
}
}
public XmlElement! CreateXmlElement(XmlDocument! doc)
{
XmlElement elem = doc.CreateElement("Decl");
assert elem != null;
elem.SetAttribute("FullName", fullName);
elem.SetAttribute("Name", shortName);
elem.SetAttribute("Kind", kind.ToString());
elem.SetAttribute("Id", key.ToString());
if (Test.outputLogicalModulesOnly) {
elem.SetAttribute("LogicalModule", "");
return elem;
}
elem.SetAttribute("HasFullInfo", hasFullInfo.ToString());
DumpXmlRef(lexicalScope, "ScopeDeclId", elem);
if (containingAssembly != null) {
DumpXmlRef(containingAssembly, "AssemblyDeclId", elem);
}
if (access != null) {
elem.SetAttribute("IsStatic", isStatic.ToString());
elem.SetAttribute("Access", access);
}
assert dependencies != null;
for (int i = 0; i < dependencies.Count; ++i) {
Dep dep = dependencies[i] as Dep;
assert dep != null;
XmlElement depElem = dep.CreateXmlElement(doc);
elem.AppendChild(depElem);
}
return elem;
}
public static void DumpXmlRef(Decl decl, string! name, XmlElement! element)
{
if (decl == null)
element.SetAttribute(name, "");
else
element.SetAttribute(name, decl.key.ToString());
}
public void AddDependency(Decl! decl, DepKind depKind) {
assert dependencies != null;
for (int i = 0; i < dependencies.Count; ++i) {
Dep dep = dependencies[i] as Dep;
assert dep != null;
if (dep.decl.Equals(decl)) {
dep.kind |= depKind;
return;
}
}
dependencies.Add(new Dep(decl, depKind));
}
public void AddAttributeDecls(AttributeList attributes, Hashtable! decls, Hashtable! ns_decls)
{
assert dependencies != null;
//return; // REMOVE ME!! Attributes should be considered part of the signature
// Add the attribute dependencies
if (attributes != null) {
foreach (AttributeNode! attribute in attributes) {
if (attribute.Type != null) {
AddDependency( GetOrCreateTypeDecl( attribute.Type, decls, ns_decls, false),
DepKind.attr );
}
}
}
}
public static Decl GetOrCreateAssemblyDecl( AssemblyNode! assembly,
Hashtable! decls,
bool hasFullInfo)
{
Decl declAssembly = decls[assembly.UniqueKey] as Decl;
if (declAssembly != null) {
assert declAssembly.kind == DeclKind.Assembly;
if (!declAssembly.hasFullInfo && hasFullInfo)
declAssembly.hasFullInfo = true;
return declAssembly;
}
assert assembly.Name != null;
declAssembly = new Decl(assembly.Name, assembly.Name, assembly.UniqueKey, DeclKind.Assembly);
decls[assembly.UniqueKey] = declAssembly;
return declAssembly;
}
public static Decl GetOrCreateNamespaceDecl(System.Compiler.Identifier! namespaceId,
Hashtable! decls,
bool hasFullInfo)
{
Decl declNamespace = decls[namespaceId.UniqueIdKey] as Decl;
if (declNamespace != null) {
assert declNamespace.kind == DeclKind.Namespace;
if (!declNamespace.hasFullInfo && hasFullInfo)
declNamespace.hasFullInfo = true;
return declNamespace;
}
string name = namespaceId.Name;
if (name == string.Empty)
name = "<Global>";
declNamespace = new Decl(name, name, namespaceId.UniqueIdKey, DeclKind.Namespace);
decls[namespaceId.UniqueIdKey] = declNamespace;
return declNamespace;
}
public static Decl! GetOrCreateTypeDecl(TypeNode! typeNode,
Hashtable! decls,
Hashtable! ns_decls,
bool hasFullInfo)
{
Decl declType = decls[typeNode.UniqueKey] as Decl;
if (declType != null) {
assert declType.kind == DeclKind.Type;
if (!declType.hasFullInfo && hasFullInfo)
declType.hasFullInfo = true;
return declType;
}
assert typeNode.FullName != null;
string fullName = RefGraph.GetFullNameWithoutQualifiers(typeNode.FullName);
assert fullName != null;
string shortName = typeNode.Name.Name;
assert shortName != null;
declType = new Decl(fullName, shortName, typeNode.UniqueKey, DeclKind.Type);
decls[typeNode.UniqueKey] = declType;
declType.hasFullInfo = hasFullInfo;
assert declType.dependencies != null;
if (typeNode.DeclaringModule != null) {
assert typeNode.DeclaringModule.ContainingAssembly != null;
// Set the assembly
declType.containingAssembly = GetOrCreateAssemblyDecl(typeNode.DeclaringModule.ContainingAssembly, decls, hasFullInfo);
}
// Set the scope to be the nesting class
if (typeNode.DeclaringType != null) {
declType.lexicalScope = GetOrCreateTypeDecl(typeNode.DeclaringType, decls, ns_decls, hasFullInfo);
}
// Set the namespace scope
else if (typeNode.Namespace != null) {
declType.lexicalScope = GetOrCreateNamespaceDecl(typeNode.Namespace, ns_decls, hasFullInfo);
assert declType.lexicalScope != null;
declType.lexicalScope.containingAssembly = declType.containingAssembly;
}
// Add the base type dependency
if (typeNode.BaseType != null) {
declType.AddDependency( GetOrCreateTypeDecl(typeNode.BaseType, decls, ns_decls, false), DepKind.baseClass );
}
// Add the base interface dependencies
if (typeNode.Interfaces != null) {
System.Compiler.InterfaceList.Enumerator enum1 = typeNode.Interfaces.GetEnumerator();
while (enum1.MoveNext()) {
Interface! iface = enum1.Current;
declType.AddDependency( GetOrCreateTypeDecl(iface, decls, ns_decls, false), DepKind.iface );
}
}
// Add the attribute dependencies
declType.AddAttributeDecls(typeNode.Attributes, decls, ns_decls);
return declType;
}
public static Decl! GetOrCreateMethodDecl(Method! method, Hashtable! decls, Hashtable! ns_decls)
{
Decl declMethod = decls[method.UniqueKey] as Decl;
if (declMethod != null) {
assert declMethod.kind == DeclKind.Method;
return declMethod;
}
string shortMethodName = method.GetUnmangledNameWithoutTypeParameters(true);
assert shortMethodName != null;
assert method.DeclaringType != null;
assert method.DeclaringType.FullName != null;
string fullName =
method.DeclaringType.Name.Name + "." +
method.GetUnmangledNameWithoutTypeParameters(false);
assert fullName != null;
if (!fullName.EndsWith(")"))
fullName += "()";
assert fullName != null;
declMethod = new Decl(fullName, shortMethodName, method.UniqueKey, DeclKind.Method);
decls[method.UniqueKey] = declMethod;
declMethod.isStatic = method.IsStatic;
if (method.IsPrivate) {
declMethod.access = "private";
}
else if (method.IsFamily ||
method.IsFamilyAndAssembly) {
declMethod.access = "protected";
}
else if (method.IsPublic ||
method.IsAssembly ||
method.IsFamilyOrAssembly ||
method.IsVisibleOutsideAssembly) {
declMethod.access = "public";
}
else if (method.IsCompilerControlled) {
// For some reason, a method like
//
// public struct DebugService {
// [CLSCompliant(false)]
// public static unsafe void PrintBegin(out char * buffer, out int length) { ... }
//
// should have IsPublic set to 'true' but it doesn't. However, it only
// appears to happen with members which are "compiler controlled" (does
// this mean 'unsafe'?)
declMethod.access = "public";
}
else {
assert System.Console.Error != null;
System.Console.Error.WriteLine("Member has unknown access: " + fullName);
declMethod.access = "public";
}
assert declMethod.dependencies != null;
if (method.ReturnType != null) {
declMethod.AddDependency( GetOrCreateTypeDecl(method.ReturnType, decls, ns_decls, false), DepKind.sig );
}
if (method.Parameters != null) {
System.Compiler.ParameterList.Enumerator enum1 = method.Parameters.GetEnumerator();
while (enum1.MoveNext()) {
Parameter! parameter = enum1.Current;
assert parameter.Type != null;
declMethod.AddDependency( GetOrCreateTypeDecl(parameter.Type, decls, ns_decls, false), DepKind.sig );
declMethod.AddAttributeDecls( parameter.Attributes, decls, ns_decls );
}
}
if (method.DeclaringType != null) {
declMethod.lexicalScope = GetOrCreateTypeDecl(method.DeclaringType, decls, ns_decls, false);
}
declMethod.AddAttributeDecls(method.Attributes, decls, ns_decls);
return declMethod;
}
public static Decl! GetOrCreateFieldDecl(Field! field, Hashtable! decls, Hashtable! ns_decls)
{
Decl declField = decls[field.UniqueKey] as Decl;
if (declField != null) {
assert declField.kind == DeclKind.Field;
return declField;
}
assert field.Name != null;
assert field.Name.Name != null;
assert field.DeclaringType != null;
assert field.DeclaringType.FullName != null;
string fullName = field.DeclaringType.Name.Name + "." + field.Name.Name;
assert fullName != null;
declField = new Decl(fullName, field.Name.Name, field.UniqueKey, DeclKind.Field);
decls[field.UniqueKey] = declField;
declField.isStatic = field.IsStatic;
if (field.IsPrivate) {
declField.access = "private";
}
else if (field.IsFamily ||
field.IsFamilyAndAssembly) {
declField.access = "protected";
}
else if (field.IsPublic ||
field.IsAssembly ||
field.IsFamilyOrAssembly) {
declField.access = "public";
}
else if (field.IsCompilerControlled) {
declField.access = "public";
}
else {
assert System.Console.Error != null;
System.Console.Error.WriteLine("Member has unknown access: " + fullName);
declField.access = "public";
}
assert declField.dependencies != null;
if (field.Type != null) {
declField.AddDependency( GetOrCreateTypeDecl(field.Type, decls, ns_decls, false), DepKind.sig );
}
if (field.DeclaringType != null) {
declField.lexicalScope = GetOrCreateTypeDecl(field.DeclaringType, decls, ns_decls, false);
}
declField.AddAttributeDecls(field.Attributes, decls, ns_decls);
return declField;
}
}
class RefGraph : StandardVisitor, IDump
{
Hashtable!/*<Decl>*/ decls = new Hashtable();
Hashtable!/*<Decl>*/ ns_decls = new Hashtable();
Set<TypeNode> types = new Set<TypeNode>();
/// types referenced in signatures of the type
TrivialHashtable!/*<Set<TypeNode>>*/ inSignatures = new TrivialHashtable();
/// types referenced in code of the type
TrivialHashtable!/*<Set<TypeNode>>*/ inCode = new TrivialHashtable();
Set<TypeNode> currentSet;
Statement currentStatement;
Method currentMethod = null;
public override Node Visit(Node node) {
Statement stmt = node as Statement;
if (stmt != null && stmt.SourceContext.Document != null) {
this.currentStatement = stmt;
}
return base.Visit(node);
}
public override TypeNode VisitTypeNode(TypeNode typeNode) {
if (typeNode == null) return null;
// Add this type (and its namespace, base class, and base ifaces)
// to the the map of decls
//assert this.decls[typeNode.UniqueKey] == null;
Decl.GetOrCreateTypeDecl(typeNode, decls, ns_decls, true);
Set<TypeNode> oldSet = this.currentSet;
Set<TypeNode> inSigSet= new Set<TypeNode>();
this.currentSet = inSigSet;
base.VisitTypeNode(typeNode);
this.inSignatures[typeNode.UniqueKey] = this.currentSet;
types.Add(typeNode);
this.currentSet = oldSet;
return typeNode;
}
public override TypeNode VisitTypeReference(TypeNode typeNode) {
if (typeNode == null) return null;
Decl.GetOrCreateTypeDecl(typeNode, decls, ns_decls, false);
this.currentSet.Add(typeNode);
return typeNode;
}
public override Field VisitField(Field field) {
if (field == null) return null;
//assert decls[field.UniqueKey] == null;
Decl declField = Decl.GetOrCreateFieldDecl(field, decls, ns_decls);
declField.hasFullInfo = true;
// Note: The field initializer has already been placed into
// the constructor.
return field;
}
public override Method VisitMethod(Method method) {
if (method == null) return null;
//assert decls[method.UniqueKey] == null;
Decl declMethod = Decl.GetOrCreateMethodDecl(method, decls, ns_decls);
declMethod.hasFullInfo = true;
this.VisitParameterList(method.Parameters);
if (!Test.staticsOnly) {
this.VisitTypeReference(method.ReturnType);
}
Set<TypeNode> savedSet = this.currentSet;
TypeNode declType = method.DeclaringType;
if (declType != null) {
this.currentSet = this.InCodeSet(declType);
assert this.currentMethod == null;
this.currentMethod = method;
this.Visit(method.Body);
assert this.currentMethod == method;
this.currentMethod = null;
this.SetInCodeSet(declType, this.currentSet);
}
this.currentSet = savedSet;
return method;
}
public override Expression VisitBinaryExpression(BinaryExpression binexpr) {
if (binexpr == null) return null;
TypeNode cast_type = null;
TypeNode from_type = null;
switch (binexpr.NodeType) {
case NodeType.Castclass:
cast_type = (TypeNode!) ((Literal!) binexpr.Operand2).Value;
from_type = (!)((!)binexpr.Operand1).Type;
if (Test.verbose) {
assert this.currentStatement != null;
WriteSourceContext(this.currentStatement);
Console.WriteLine("down cast: '{0}' -> '{1}'", from_type.FullName,
cast_type.FullName);
}
break;
case NodeType.Unbox:
cast_type = (TypeNode!) ((Literal!) binexpr.Operand2).Value;
from_type = (!)((!)binexpr.Operand1).Type;
if (Test.verbose) {
assert this.currentStatement != null;
WriteSourceContext(this.currentStatement);
Console.WriteLine("unbox: '{0}' -> '{1}'", from_type.FullName,
cast_type.FullName);
}
break;
}
if (cast_type != null) {
assert from_type != null;
assert this.currentMethod != null;
Decl declMember = this.decls[this.currentMethod.UniqueKey] as Decl;
assert declMember != null;
declMember.AddDependency(Decl.GetOrCreateTypeDecl(cast_type, decls, ns_decls, false), DepKind.code);
declMember.AddDependency(Decl.GetOrCreateTypeDecl(from_type, decls, ns_decls, false), DepKind.code);
}
return binexpr;
}
private void WriteSourceContext(Node! node) {
Document d = node.SourceContext.Document;
if (d != null) {
Console.Write("{0}:{1} ", d.Name,
node.SourceContext.StartLine);
}
}
public override Expression VisitParameter(Parameter parameter) {
if (!Test.staticsOnly) {
return base.VisitParameter(parameter);
}
return parameter;
}
public override Expression VisitMemberBinding(MemberBinding mb) {
if (mb == null) return mb;
base.VisitMemberBinding(mb);
Member bm = mb.BoundMember;
if (bm != null) {
if (currentMethod != null) {
Decl methodDecl = this.decls[currentMethod.UniqueKey] as Decl;
assert methodDecl != null;
Decl memberDecl = null;
if (bm is Field) {
Field field = bm as Field;
assert field != null;
memberDecl = Decl.GetOrCreateFieldDecl(field, decls, ns_decls);
}
else if (bm is Method) {
Method method = bm as Method;
assert method != null;
memberDecl = Decl.GetOrCreateMethodDecl(method, decls, ns_decls);
}
assert memberDecl != null;
methodDecl.AddDependency(memberDecl, DepKind.code);
}
if (!Test.staticsOnly || bm.IsStatic) {
this.VisitTypeReference(bm.DeclaringType);
}
}
return mb;
}
Set<TypeNode> InSigSet(TypeNode! tn) {
object o = this.inSignatures[tn.UniqueKey];
if (o == null) return new Set<TypeNode>();
return (Set<TypeNode>)o;
}
Set<TypeNode> InCodeSet(TypeNode! tn) {
object o = this.inCode[tn.UniqueKey];
if (o == null) return new Set<TypeNode>();
return (Set<TypeNode>)o;
}
void SetInCodeSet(TypeNode! tn, Set<TypeNode> data) {
this.inCode[tn.UniqueKey] = data;
}
public void FixNamespaceKeys() {
assert this.ns_decls.Values != null;
foreach (object val in this.ns_decls.Values) {
Decl decl = val as Decl;
assert decl != null;
if (decl.kind == DeclKind.Namespace) {
decl.key += Decl.largestKey;
}
}
}
public void Dump(TextWriter! wr) {
assert !Test.outputXml;
foreach (TypeNode! tn in this.types) {
if (Test.oneLine) {
wr.WriteLine();
wr.WriteLine("{0}: Type: {0}", tn.FullName);
TypeNode bt = tn.BaseType;
if (bt != null) {
wr.WriteLine("{0}: Base type: {1}",
tn.FullName,
bt.FullName);
}
InterfaceList il = tn.Interfaces;
if (il != null) {
for (int i = 0; i < il.Count; i++) {
Interface intf = il[i];
if (intf != null) {
Console.WriteLine("{0}: Interface: {1}",
tn.FullName,
intf.FullName);
}
}
}
Set<TypeNode> s = InSigSet(tn);
foreach (TypeNode! stn in s) {
wr.WriteLine("{0}: Referenced from signature: {1}",
tn.FullName,
stn.FullName);
}
Set<TypeNode> cs = InCodeSet(tn);
foreach (TypeNode! stn in cs) {
wr.WriteLine("{0}: Referenced from code: {1}",
tn.FullName,
stn.FullName);
}
}
else {
wr.WriteLine("\n\nType: {0}", tn.FullName);
wr.WriteLine("----------------------");
TypeNode bt = tn.BaseType;
if (bt != null) {
wr.WriteLine("\n Base type: {0}", bt.FullName);
}
InterfaceList il = tn.Interfaces;
if (il != null) {
wr.WriteLine("\n Interfaces");
for (int i = 0; i < il.Count; i++) {
Interface intf = il[i];
if (intf != null) {
Console.WriteLine(" {0}", intf.FullName);
}
}
}
Set<TypeNode> s = InSigSet(tn);
wr.WriteLine("\n Referenced from signatures");
foreach (TypeNode! stn in s) {
wr.WriteLine(" {0}", stn.FullName);
}
Set<TypeNode> cs = InCodeSet(tn);
wr.WriteLine("\n Referenced from code");
foreach (TypeNode! stn in cs) {
wr.WriteLine(" {0}", stn.FullName);
}
}
}
}
public XmlDocument DumpAllDependenciesToXml() {
XmlDocument doc = new XmlDocument();
assert doc != null;
XmlElement rootElement = doc.CreateElement("MemberDependencies");
assert rootElement != null;
doc.AppendChild(rootElement);
assert this.decls.Values != null;
foreach (object val in this.decls.Values) {
Decl decl = val as Decl;
assert decl != null;
Output(doc, rootElement, decl);
}
return doc;
}
public void Output(XmlDocument! doc, XmlElement! parentElement, Decl !decl) {
if (decl.alreadyOutput)
return;
decl.alreadyOutput = true;
if (Test.outputLogicalModulesOnly &&
(decl.kind == DeclKind.Assembly || decl.kind == DeclKind.Namespace)) {
return;
}
// First output containing assembly
if (decl.containingAssembly != null)
Output(doc, parentElement, decl.containingAssembly);
// Then output lexical scope assembly
if (decl.lexicalScope != null)
Output(doc, parentElement, decl.lexicalScope);
// Then output all the dependencies
for (int i = 0; decl.dependencies != null && i < decl.dependencies.Count; ++i) {
Dep dep = decl.dependencies[i] as Dep;
assert dep != null;
assert dep.decl != null;
Output(doc, parentElement, dep.decl);
}
XmlElement elem = decl.CreateXmlElement(doc);
parentElement.AppendChild(elem);
}
static string GetFullyQualifiedTypeName(TypeNode! node)
{
if (node.DeclaringModule != null) {
assert node.DeclaringModule.ContainingAssembly != null;
assert node.FullName != null;
return GetFullNameWithoutQualifiers(node.FullName) + "," +
node.DeclaringModule.ContainingAssembly.Name;
}
else {
return GetFullNameWithoutQualifiers((string!) node.FullName);
}
}
public static string GetFullNameWithoutQualifiers(string! name)
{
int firstSpace = name.IndexOf(' ');
if (firstSpace > 0) {
return name.Substring(firstSpace + 1);
}
else {
return name;
}
}
static void AddDependency(Hashtable! mapTypeDependency2Kind, TypeNode! node, string! kind)
{
string! fqTypeName = (string!) GetFullyQualifiedTypeName(node);
string curKind = mapTypeDependency2Kind[fqTypeName] as string;
if (curKind == null || curKind == string.Empty) {
curKind = kind;
}
else if (curKind.IndexOf(kind) != -1) {
return; // Already recorded this kind of dependency
}
else {
curKind += ", " + kind;
}
mapTypeDependency2Kind[fqTypeName] = curKind;
}
}