Author: toshok
Date: 2007-12-07 14:25:15 -0500 (Fri, 07 Dec 2007)
New Revision: 90958
Added:
trunk/mono-tools/gui-compare/ChangeLog
Modified:
trunk/mono-tools/gui-compare/CecilMetadata.cs
trunk/mono-tools/gui-compare/CompareContext.cs
trunk/mono-tools/gui-compare/CompareWindow.cs
trunk/mono-tools/gui-compare/MasterMetadata.cs
trunk/mono-tools/gui-compare/Masterinfo.cs
trunk/mono-tools/gui-compare/Metadata.cs
Log:
2007-12-07 Chris Toshok <[EMAIL PROTECTED]>
* Metadata.cs (CompClass): add GetNestedClass() method.
* Masterinfo.cs (XMLClass): make nested public.
* CompareWindow.cs (PerformCompare): abstract out what was in the
body of SetAssemblyPath, so we can restart a comparison whenever
we want -- when a new masterinfo is available, when the .dll has
changed, etc.
* CompareContext.cs (CompareThread): comment out call to
DumpComparison.
(CompareClassLists): abstract out the body of CompareClasses so it
can be reused for nested classes as well as toplevel. Call
CompareClassLists recursively to handle nested classes. Also, fix
an &&/|| thinko.
(CompareTypes): just call CompareClassLists.
(CompareMethods): start implementation.
(AddExtraMethod, AddMissingMethod): implement.
* MasterMetadata.cs (MasterClass.GetMethods,
MasterClass.GetConstructors): don't throw NIE. instead return an
empty list. this causes all methods to show up as extra, but it
keeps us from crashing.
(MasterClass.GetNestedClasses): implement.
* CecilMetadata.cs (CecilClass.GetConstructors): return empty
list, don't throw NIE.
(CecilClass.GetNestedClasses): implement.
Modified: trunk/mono-tools/gui-compare/CecilMetadata.cs
===================================================================
--- trunk/mono-tools/gui-compare/CecilMetadata.cs 2007-12-07 18:48:44 UTC
(rev 90957)
+++ trunk/mono-tools/gui-compare/CecilMetadata.cs 2007-12-07 19:25:15 UTC
(rev 90958)
@@ -105,9 +105,21 @@
public override List<CompMethod> GetConstructors ()
{
- return null;
+ return new List<CompMethod>();
}
+ public override List<CompClass> GetNestedClasses()
+ {
+ List<CompClass> rv = new List<CompClass>();
+ foreach (TypeDefinition td in type_def.NestedTypes) {
+ rv.Add (new CecilClass (td));
+ }
+
+ rv.Sort (delegate (CompClass x, CompClass y) { return
String.Compare (x.Name, y.Name); });
+
+ return rv;
+ }
+
TypeDefinition type_def;
}
Added: trunk/mono-tools/gui-compare/ChangeLog
===================================================================
--- trunk/mono-tools/gui-compare/ChangeLog 2007-12-07 18:48:44 UTC (rev
90957)
+++ trunk/mono-tools/gui-compare/ChangeLog 2007-12-07 19:25:15 UTC (rev
90958)
@@ -0,0 +1,30 @@
+2007-12-07 Chris Toshok <[EMAIL PROTECTED]>
+
+ * Metadata.cs (CompClass): add GetNestedClass() method.
+
+ * Masterinfo.cs (XMLClass): make nested public.
+
+ * CompareWindow.cs (PerformCompare): abstract out what was in the
+ body of SetAssemblyPath, so we can restart a comparison whenever
+ we want -- when a new masterinfo is available, when the .dll has
+ changed, etc.
+
+ * CompareContext.cs (CompareThread): comment out call to
+ DumpComparison.
+ (CompareClassLists): abstract out the body of CompareClasses so it
+ can be reused for nested classes as well as toplevel. Call
+ CompareClassLists recursively to handle nested classes. Also, fix
+ an &&/|| thinko.
+ (CompareTypes): just call CompareClassLists.
+ (CompareMethods): start implementation.
+ (AddExtraMethod, AddMissingMethod): implement.
+
+ * MasterMetadata.cs (MasterClass.GetMethods,
+ MasterClass.GetConstructors): don't throw NIE. instead return an
+ empty list. this causes all methods to show up as extra, but it
+ keeps us from crashing.
+ (MasterClass.GetNestedClasses): implement.
+
+ * CecilMetadata.cs (CecilClass.GetConstructors): return empty
+ list, don't throw NIE.
+ (CecilClass.GetNestedClasses): implement.
Modified: trunk/mono-tools/gui-compare/CompareContext.cs
===================================================================
--- trunk/mono-tools/gui-compare/CompareContext.cs 2007-12-07 18:48:44 UTC
(rev 90957)
+++ trunk/mono-tools/gui-compare/CompareContext.cs 2007-12-07 19:25:15 UTC
(rev 90958)
@@ -64,7 +64,7 @@
FinishedOnGuiThread ();
- DumpComparison (comparison, 0);
+ // DumpComparison (comparison, 0);
}
char StatusToChar (ComparisonStatus r)
@@ -97,7 +97,7 @@
int m = 0, a = 0;
- while (m < master_namespaces.Count && a <
assembly_namespaces.Count) {
+ while (m < master_namespaces.Count || a <
assembly_namespaces.Count) {
if (m == master_namespaces.Count) {
AddExtraNamespace (parent,
assembly_namespaces[a]);
a++;
@@ -135,20 +135,17 @@
}
}
- void CompareTypes (NamespaceComparison parent,
- CompNamespace master_namespace,
CompNamespace assembly_namespace)
+ void CompareClassLists (ComparisonNode parent,
+ List<CompClass> master_types,
List<CompClass> assembly_types)
{
- List<CompClass> assembly_types =
assembly_namespace.GetClasses();
- List<CompClass> master_types =
master_namespace.GetClasses();
-
int m = 0, a = 0;
- while (m < master_types.Count && a <
assembly_types.Count) {
- if (m == master_types.Count) {
+ while (m < master_types.Count || a <
assembly_types.Count) {
+ if (master_types == null || m ==
master_types.Count) {
AddExtraClass (parent,
assembly_types[a]);
a++;
continue;
}
- else if (a == assembly_types.Count) {
+ else if (assembly_types == null || a ==
assembly_types.Count) {
AddMissingClass (parent,
master_types[m]);
m++;
continue;
@@ -162,7 +159,10 @@
ClassComparison comparison = new
ClassComparison (master_types[m].Name);
parent.AddChild (comparison);
CompareMethods (comparison,
master_types[m], assembly_types[a]);
- //CompareMembers (comparison,
master_types[m], assembly_namespace [assembly_types[a]]);
+ // XXX more comparison stuff here
+ CompareClassLists (comparison,
+
master_types[m].GetNestedClasses(),
+
assembly_types[a].GetNestedClasses());
m++;
a++;
}
@@ -179,41 +179,40 @@
}
}
+ void CompareTypes (NamespaceComparison parent,
+ CompNamespace master_namespace,
CompNamespace assembly_namespace)
+ {
+ CompareClassLists (parent,
+ master_namespace.GetClasses(),
assembly_namespace.GetClasses());
+ }
+
void CompareMethods (ComparisonNode parent,
CompClass master_class, CompClass
assembly_class)
{
-#if false
- MethodDefinition[] assembly_methods = new
MethodDefinition [assembly_class.Methods.Count];
- ((ICollection)assembly_class.Methods).CopyTo
(assembly_methods, 0);
- Array.Sort (assembly_methods, new
MethodDefinitionComparer());
+ List<CompMethod> assembly_methods =
assembly_class.GetMethods();
+ List<CompMethod> master_methods =
master_class.GetMethods();
- XMLMethods [] master_methods = new XMLMethods
[master_class.methods.Length];
- master_class.methods.CopyTo (master_methods, 0);
- Array.Sort (master_methods, new XMLMethodComparer());
-
int m = 0, a = 0;
- while (m < master_methods.Length && a <
assembly_methods.Length) {
- if (m == master_methods.Length) {
+ while (m < master_methods.Count || a <
assembly_methods.Count) {
+ if (m == master_methods.Count) {
AddExtraMethod (parent,
assembly_methods[a]);
a++;
continue;
}
- else if (a == assembly_methods.Length) {
+ else if (a == assembly_methods.Count) {
AddMissingMethod (parent,
master_methods[m]);
m++;
continue;
}
- int c = String.Compare (master_methods[m].name,
assembly_methods[a].Name);
+ int c = String.Compare (master_methods[m].Name,
assembly_methods[a].Name);
if (c == 0) {
/* the names match, further
investigation is required */
- Console.WriteLine ("method {0} is in
both, doing more comparisons", master_methods[m].name);
- MethodComparison comparison = new
MethodComparison (master_methods[m].name);
+ Console.WriteLine ("method {0} is in
both, doing more comparisons", master_methods[m].Name);
+ MethodComparison comparison = new
MethodComparison (master_methods[m].Name);
parent.AddChild (comparison);
-
- // XXX compare attributes
-
+ //CompareParameters (comparison,
master_methods[m], assembly_namespace [assembly_methods[a]]);
m++;
a++;
}
@@ -228,7 +227,6 @@
a++;
}
}
-#endif
}
void AddExtraNamespace (ComparisonNode parent, CompNamespace ns)
@@ -237,7 +235,6 @@
parent.AddChild (namespace_node);
namespace_node.status = ComparisonStatus.Extra;
- Console.WriteLine ("extra namespace: {0}", ns.Name);
List<CompClass> classes = ns.GetClasses();
foreach (CompClass cls in classes)
AddExtraClass (namespace_node, cls);
@@ -249,8 +246,6 @@
parent.AddChild (namespace_node);
namespace_node.status = ComparisonStatus.Missing;
- Console.WriteLine ("missing namespace: {0}", ns.Name);
-
List<CompClass> classes = ns.GetClasses();
foreach (CompClass cls in classes)
AddMissingClass (namespace_node, cls);
@@ -270,14 +265,18 @@
comparison.status = ComparisonStatus.Missing;
}
- void AddExtraMethod (ComparisonNode parent, MethodDefinition
assembly_method)
+ void AddExtraMethod (ComparisonNode parent, CompMethod extra)
{
-// Console.WriteLine ("extra method: {0}",
assembly_method.Name);
+ ComparisonNode method_node = new MethodComparison
(extra.Name);
+ parent.AddChild (method_node);
+ method_node.status = ComparisonStatus.Extra;
}
- void AddMissingMethod (ComparisonNode parent, XMLMethods
master_method)
+ void AddMissingMethod (ComparisonNode parent, CompMethod
missing)
{
-// Console.WriteLine ("missing method: {0}",
master_method.name);
+ ComparisonNode method_node = new MethodComparison
(missing.Name);
+ parent.AddChild (method_node);
+ method_node.status = ComparisonStatus.Missing;
}
void LoadMasterinfo ()
Modified: trunk/mono-tools/gui-compare/CompareWindow.cs
===================================================================
--- trunk/mono-tools/gui-compare/CompareWindow.cs 2007-12-07 18:48:44 UTC
(rev 90957)
+++ trunk/mono-tools/gui-compare/CompareWindow.cs 2007-12-07 19:25:15 UTC
(rev 90958)
@@ -97,14 +97,20 @@
public void SetAssemblyPath (string path)
{
- string masterinfoPath = IOPath.Combine
(masterinfoDirectory, IOPath.GetFileName (IOPath.ChangeExtension (path,
"xml")));
+ assemblyPath = path;
+ PerformCompare ();
+ }
+ public void PerformCompare ()
+ {
+ string masterinfoPath = IOPath.Combine
(masterinfoDirectory, IOPath.GetFileName (IOPath.ChangeExtension (assemblyPath,
"xml")));
+
// clear our existing content
if (context != null)
context.StopCompare ();
// now generate new content asynchronously
- context = new CompareContext (masterinfoPath, path);
+ context = new CompareContext (masterinfoPath,
assemblyPath);
context.ProgressChanged += delegate (object sender,
CompareProgressChangedEventArgs e) {
/* update our progress bar */
status.Pop (0);
@@ -126,7 +132,7 @@
context.Finished += delegate (object sender, EventArgs
e) {
status.Pop (0);
status.Push (0, String.Format ("Comparison
completed at {0}", DateTime.Now));
- Title = IOPath.GetFileName (path);
+ Title = IOPath.GetFileName (assemblyPath);
PopulateTreeFromComparison (context.Comparison);
progressbar.Fraction = 0.0;
};
@@ -184,6 +190,7 @@
PopulateTreeFromComparison (citer, n);
}
+ string assemblyPath;
CompareContext context;
Gtk.VBox vbox;
Gtk.TreeView tree;
Modified: trunk/mono-tools/gui-compare/MasterMetadata.cs
===================================================================
--- trunk/mono-tools/gui-compare/MasterMetadata.cs 2007-12-07 18:48:44 UTC
(rev 90957)
+++ trunk/mono-tools/gui-compare/MasterMetadata.cs 2007-12-07 19:25:15 UTC
(rev 90958)
@@ -53,16 +53,32 @@
public MasterClass (XMLClass cls)
: base (cls.name)
{
+ xml_cls = cls;
}
public override List<CompMethod> GetMethods()
{
- throw new NotImplementedException ();
+ return new List<CompMethod>();
}
public override List<CompMethod> GetConstructors()
{
- throw new NotImplementedException ();
+ return new List<CompMethod>();
}
+
+ public override List<CompClass> GetNestedClasses()
+ {
+ List<CompClass> rv = new List<CompClass>();
+ if (xml_cls.nested != null) {
+ foreach (XMLClass nested in xml_cls.nested)
+ rv.Add (new MasterClass (nested));
+
+ rv.Sort (delegate (CompClass x, CompClass y) {
return String.Compare (x.Name, y.Name); });
+ }
+
+ return rv;
+ }
+
+ XMLClass xml_cls;
}
}
Modified: trunk/mono-tools/gui-compare/Masterinfo.cs
===================================================================
--- trunk/mono-tools/gui-compare/Masterinfo.cs 2007-12-07 18:48:44 UTC (rev
90957)
+++ trunk/mono-tools/gui-compare/Masterinfo.cs 2007-12-07 19:25:15 UTC (rev
90958)
@@ -643,7 +643,7 @@
XMLProperties properties;
XMLEvents events;
public XMLMethods methods;
- XMLClass [] nested;
+ public XMLClass [] nested;
public override void LoadData (XmlNode node)
{
Modified: trunk/mono-tools/gui-compare/Metadata.cs
===================================================================
--- trunk/mono-tools/gui-compare/Metadata.cs 2007-12-07 18:48:44 UTC (rev
90957)
+++ trunk/mono-tools/gui-compare/Metadata.cs 2007-12-07 19:25:15 UTC (rev
90958)
@@ -61,6 +61,8 @@
// public abstract List<CompProperty> GetProperties();
// public abstract List<CompField> GetFields();
// public abstract List<CompEvent> GetEvents();
+
+ public abstract List<CompClass> GetNestedClasses();
}
public abstract class CompMethod : CompAttributeContainer {
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches
