mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 11:21:39 -10:00
Right now, the set of mono-api-tools only works as console apps. This PR will make them work as normal dlls so they can be consumed by other apps and libraries. They will still work as .exes, so nothing visibly changes for existing users. The motivation for this is for some build process or third party tool to take an assembly and generate an .xml doc from it. Since the writer is in-memory, the tool can then parse the .xml and do whatever it needs to. The same goes for the diff tools - if the diff happens in-memory, then the tool can process it without having to save and then load from the file system. ## Libraries - [x] mono-api-info -> `Mono.ApiTools.ApiInfo` - [x] mono-api-diff -> `Mono.ApiTools.ApiDiff` - [x] mono-api-html -> `Mono.ApiTools.ApiDiffFormatted` ## Major changes - the existing `Driver` classes are now just thin wrappers to parse the args and pass it on to the generators - the "options" are now abstracted into config classes to avoid methods with numerous parameters - the APIs have new support for reading assembly and info `Stream`s instead of just file paths - added compiler flags to control the namespace and type visibility to make the library APIs nicer - added compiler flag to remove the `Driver` class and `Mono.Options` dependencies - the mono-api-info tool has some more options to allow it to run on libraries, and ignore dependencies that it cannot find - this makes it easier to use so that the entire dependency chain does not have to be loaded just to output the current assembly API ## Compiler defines - `EXCLUDE_DRIVER` will remove the console entry point and remove the dependency of Mono.Options - `USE_MONO_API_TOOLS_NAMESPACE` will switch the namespace to `Mono.ApiTools` so that libraries can have a nice API - `USE_INTERNAL_VISIBILITY` will make any non-essential, `public` APIs turn `internal` ## Review points - are there any variables/fields that are still static? - are there any exposed types/members that need to be hidden? - are the new names for the APIs and config classes OK? - are my whitespaces according to the guidelines? - did I go horribly wrong?
1939 lines
51 KiB
C#
1939 lines
51 KiB
C#
//
|
|
// mono-api-diff.cs - Compares 2 xml files produced by mono-api-info and
|
|
// produces a file suitable to build class status pages.
|
|
//
|
|
// Authors:
|
|
// Gonzalo Paniagua Javier ([email protected])
|
|
// Marek Safar ([email protected])
|
|
//
|
|
// Maintainer:
|
|
// C.J. Adams-Collier ([email protected])
|
|
//
|
|
// (C) 2003 Novell, Inc (http://www.novell.com)
|
|
// (C) 2009,2010 Collier Technologies (http://www.colliertech.org)
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Xml;
|
|
|
|
namespace Mono.ApiTools
|
|
{
|
|
#if !EXCLUDE_DRIVER
|
|
class Driver
|
|
{
|
|
static int Main (string [] args)
|
|
{
|
|
bool showHelp = false;
|
|
string output = null;
|
|
List<string> extra = null;
|
|
|
|
var options = new Mono.Options.OptionSet {
|
|
{ "h|?|help", "Show this help", v => showHelp = true },
|
|
{ "o|out|output=", "XML diff file output (omit for stdout)", v => output = v },
|
|
};
|
|
|
|
try {
|
|
extra = options.Parse (args);
|
|
} catch (Mono.Options.OptionException e) {
|
|
Console.WriteLine ("Option error: {0}", e.Message);
|
|
extra = null;
|
|
}
|
|
|
|
if (showHelp || extra == null || extra.Count != 2) {
|
|
Console.WriteLine (@"Usage: mono-api-diff.exe [options] <assembly 1 xml> <assembly 2 xml>");
|
|
Console.WriteLine ();
|
|
Console.WriteLine ("Available options:");
|
|
options.WriteOptionDescriptions (Console.Out);
|
|
Console.WriteLine ();
|
|
return showHelp ? 0 : 1;
|
|
}
|
|
|
|
TextWriter outputStream = null;
|
|
try {
|
|
if (!string.IsNullOrEmpty (output))
|
|
outputStream = new StreamWriter (output);
|
|
|
|
ApiDiff.Generate(extra[0], extra[1], outputStream ?? Console.Out);
|
|
} catch (Exception e) {
|
|
Console.WriteLine (e);
|
|
return 1;
|
|
} finally {
|
|
outputStream?.Dispose ();
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public static class ApiDiff
|
|
{
|
|
public static void Generate (string firstInfo, string secondInfo, TextWriter outStream)
|
|
{
|
|
if (firstInfo == null)
|
|
throw new ArgumentNullException (nameof (firstInfo));
|
|
if (secondInfo == null)
|
|
throw new ArgumentNullException (nameof (secondInfo));
|
|
|
|
XMLAssembly ms = CreateXMLAssembly (firstInfo);
|
|
XMLAssembly mono = CreateXMLAssembly (secondInfo);
|
|
|
|
Generate (ms, mono, outStream);
|
|
}
|
|
|
|
public static void Generate (Stream firstInfo, Stream secondInfo, TextWriter outStream)
|
|
{
|
|
if (firstInfo == null)
|
|
throw new ArgumentNullException (nameof (firstInfo));
|
|
if (secondInfo == null)
|
|
throw new ArgumentNullException (nameof (secondInfo));
|
|
|
|
XMLAssembly ms = CreateXMLAssembly (firstInfo);
|
|
XMLAssembly mono = CreateXMLAssembly (secondInfo);
|
|
|
|
Generate (ms, mono, outStream);
|
|
}
|
|
|
|
static void Generate (XMLAssembly first, XMLAssembly second, TextWriter outStream)
|
|
{
|
|
if (first == null)
|
|
throw new ArgumentNullException (nameof (first));
|
|
if (second == null)
|
|
throw new ArgumentNullException (nameof (second));
|
|
if (outStream == null)
|
|
throw new ArgumentNullException (nameof (outStream));
|
|
|
|
XmlDocument doc = first.CompareAndGetDocument (second);
|
|
|
|
using (XmlTextWriter writer = new XmlTextWriter (outStream)) {
|
|
writer.Formatting = Formatting.Indented;
|
|
doc.WriteTo (writer);
|
|
}
|
|
}
|
|
|
|
static XMLAssembly CreateXMLAssembly (string file)
|
|
{
|
|
using (var stream = File.OpenRead(file)) {
|
|
return CreateXMLAssembly (stream);
|
|
}
|
|
}
|
|
|
|
static XMLAssembly CreateXMLAssembly (Stream stream)
|
|
{
|
|
XmlDocument doc = new XmlDocument ();
|
|
doc.Load (stream);
|
|
|
|
XmlNode node = doc.SelectSingleNode ("/assemblies/assembly");
|
|
XMLAssembly result = new XMLAssembly ();
|
|
result.LoadData (node);
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class Counters
|
|
{
|
|
public int Present;
|
|
public int PresentTotal;
|
|
public int Missing;
|
|
public int MissingTotal;
|
|
public int Todo;
|
|
public int TodoTotal;
|
|
|
|
public int Extra;
|
|
public int ExtraTotal;
|
|
public int Warning;
|
|
public int WarningTotal;
|
|
public int ErrorTotal;
|
|
|
|
public Counters ()
|
|
{
|
|
}
|
|
|
|
public void AddPartialToPartial (Counters other)
|
|
{
|
|
Present += other.Present;
|
|
Extra += other.Extra;
|
|
Missing += other.Missing;
|
|
|
|
Todo += other.Todo;
|
|
Warning += other.Warning;
|
|
AddPartialToTotal (other);
|
|
}
|
|
|
|
public void AddPartialToTotal (Counters other)
|
|
{
|
|
PresentTotal += other.Present;
|
|
ExtraTotal += other.Extra;
|
|
MissingTotal += other.Missing;
|
|
|
|
TodoTotal += other.Todo;
|
|
WarningTotal += other.Warning;
|
|
}
|
|
|
|
public void AddTotalToPartial (Counters other)
|
|
{
|
|
Present += other.PresentTotal;
|
|
Extra += other.ExtraTotal;
|
|
Missing += other.MissingTotal;
|
|
|
|
Todo += other.TodoTotal;
|
|
Warning += other.WarningTotal;
|
|
AddTotalToTotal (other);
|
|
}
|
|
|
|
public void AddTotalToTotal (Counters other)
|
|
{
|
|
PresentTotal += other.PresentTotal;
|
|
ExtraTotal += other.ExtraTotal;
|
|
MissingTotal += other.MissingTotal;
|
|
|
|
TodoTotal += other.TodoTotal;
|
|
WarningTotal += other.WarningTotal;
|
|
ErrorTotal += other.ErrorTotal;
|
|
}
|
|
|
|
public int Total {
|
|
get { return Present + Missing; }
|
|
}
|
|
|
|
public int AbsTotal {
|
|
get { return PresentTotal + MissingTotal; }
|
|
}
|
|
|
|
public int Ok {
|
|
get { return Present - Todo; }
|
|
}
|
|
|
|
public int OkTotal {
|
|
get { return PresentTotal - TodoTotal - ErrorTotal; }
|
|
}
|
|
|
|
public override string ToString ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
sw.WriteLine ("Present: {0}", Present);
|
|
sw.WriteLine ("PresentTotal: {0}", PresentTotal);
|
|
sw.WriteLine ("Missing: {0}", Missing);
|
|
sw.WriteLine ("MissingTotal: {0}", MissingTotal);
|
|
sw.WriteLine ("Todo: {0}", Todo);
|
|
sw.WriteLine ("TodoTotal: {0}", TodoTotal);
|
|
sw.WriteLine ("Extra: {0}", Extra);
|
|
sw.WriteLine ("ExtraTotal: {0}", ExtraTotal);
|
|
sw.WriteLine ("Warning: {0}", Warning);
|
|
sw.WriteLine ("WarningTotal: {0}", WarningTotal);
|
|
sw.WriteLine ("ErrorTotal: {0}", ErrorTotal);
|
|
sw.WriteLine ("--");
|
|
return sw.GetStringBuilder ().ToString ();
|
|
}
|
|
}
|
|
|
|
abstract class XMLData
|
|
{
|
|
protected XmlDocument document;
|
|
protected Counters counters;
|
|
bool haveWarnings;
|
|
|
|
public XMLData ()
|
|
{
|
|
counters = new Counters ();
|
|
}
|
|
|
|
public virtual void LoadData (XmlNode node)
|
|
{
|
|
}
|
|
|
|
protected object [] LoadRecursive (XmlNodeList nodeList, Type type)
|
|
{
|
|
ArrayList list = new ArrayList ();
|
|
foreach (XmlNode node in nodeList) {
|
|
XMLData data = (XMLData) Activator.CreateInstance (type);
|
|
data.LoadData (node);
|
|
list.Add (data);
|
|
}
|
|
|
|
return (object []) list.ToArray (type);
|
|
}
|
|
|
|
public static bool IsMeaninglessAttribute (string s)
|
|
{
|
|
if (s == null)
|
|
return false;
|
|
if (s == "System.Runtime.CompilerServices.CompilerGeneratedAttribute")
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public static bool IsMonoTODOAttribute (string s)
|
|
{
|
|
if (s == null)
|
|
return false;
|
|
if (//s.EndsWith ("MonoTODOAttribute") ||
|
|
s.EndsWith ("MonoDocumentationNoteAttribute") ||
|
|
s.EndsWith ("MonoExtensionAttribute") ||
|
|
// s.EndsWith ("MonoInternalNoteAttribute") ||
|
|
s.EndsWith ("MonoLimitationAttribute") ||
|
|
s.EndsWith ("MonoNotSupportedAttribute"))
|
|
return true;
|
|
return s.EndsWith ("TODOAttribute");
|
|
}
|
|
|
|
protected void AddAttribute (XmlNode node, string name, string value)
|
|
{
|
|
XmlAttribute attr = document.CreateAttribute (name);
|
|
attr.Value = value;
|
|
node.Attributes.Append (attr);
|
|
}
|
|
|
|
protected void AddExtra (XmlNode node)
|
|
{
|
|
//TODO: count all the subnodes?
|
|
AddAttribute (node, "presence", "extra");
|
|
AddAttribute (node, "ok", "1");
|
|
AddAttribute (node, "ok_total", "1");
|
|
AddAttribute (node, "extra", "1");
|
|
AddAttribute (node, "extra_total", "1");
|
|
}
|
|
|
|
public void AddCountersAttributes (XmlNode node)
|
|
{
|
|
if (counters.Missing > 0)
|
|
AddAttribute (node, "missing", counters.Missing.ToString ());
|
|
|
|
if (counters.Present > 0)
|
|
AddAttribute (node, "present", counters.Present.ToString ());
|
|
|
|
if (counters.Extra > 0)
|
|
AddAttribute (node, "extra", counters.Extra.ToString ());
|
|
|
|
if (counters.Ok > 0)
|
|
AddAttribute (node, "ok", counters.Ok.ToString ());
|
|
|
|
if (counters.Total > 0) {
|
|
int percent = (100 * counters.Ok / counters.Total);
|
|
AddAttribute (node, "complete", percent.ToString ());
|
|
}
|
|
|
|
if (counters.Todo > 0)
|
|
AddAttribute (node, "todo", counters.Todo.ToString ());
|
|
|
|
if (counters.Warning > 0)
|
|
AddAttribute (node, "warning", counters.Warning.ToString ());
|
|
|
|
if (counters.MissingTotal > 0)
|
|
AddAttribute (node, "missing_total", counters.MissingTotal.ToString ());
|
|
|
|
if (counters.PresentTotal > 0)
|
|
AddAttribute (node, "present_total", counters.PresentTotal.ToString ());
|
|
|
|
if (counters.ExtraTotal > 0)
|
|
AddAttribute (node, "extra_total", counters.ExtraTotal.ToString ());
|
|
|
|
if (counters.OkTotal > 0)
|
|
AddAttribute (node, "ok_total", counters.OkTotal.ToString ());
|
|
|
|
if (counters.AbsTotal > 0) {
|
|
int percent = (100 * counters.OkTotal / counters.AbsTotal);
|
|
AddAttribute (node, "complete_total", percent.ToString ());
|
|
}
|
|
|
|
if (counters.TodoTotal > 0) {
|
|
AddAttribute (node, "todo_total", counters.TodoTotal.ToString ());
|
|
//TODO: should be different on error. check error cases in corcompare.
|
|
AddAttribute (node, "error_total", counters.Todo.ToString ());
|
|
}
|
|
|
|
if (counters.WarningTotal > 0)
|
|
AddAttribute (node, "warning_total", counters.WarningTotal.ToString ());
|
|
|
|
}
|
|
|
|
protected void AddWarning (XmlNode parent, string fmt, params object [] args)
|
|
{
|
|
counters.Warning++;
|
|
haveWarnings = true;
|
|
XmlNode warnings = parent.SelectSingleNode ("warnings");
|
|
if (warnings == null) {
|
|
warnings = document.CreateElement ("warnings", null);
|
|
parent.AppendChild (warnings);
|
|
}
|
|
|
|
AddAttribute (parent, "error", "warning");
|
|
XmlNode warning = document.CreateElement ("warning", null);
|
|
AddAttribute (warning, "text", String.Format (fmt, args));
|
|
warnings.AppendChild (warning);
|
|
}
|
|
|
|
public bool HaveWarnings {
|
|
get { return haveWarnings; }
|
|
}
|
|
|
|
public Counters Counters {
|
|
get { return counters; }
|
|
}
|
|
|
|
public abstract void CompareTo (XmlDocument doc, XmlNode parent, object other);
|
|
}
|
|
|
|
abstract class XMLNameGroup : XMLData
|
|
{
|
|
protected XmlNode group;
|
|
protected Hashtable keys;
|
|
|
|
public override void LoadData (XmlNode node)
|
|
{
|
|
if (node == null)
|
|
throw new ArgumentNullException ("node");
|
|
|
|
if (node.Name != GroupName)
|
|
throw new FormatException (String.Format ("Expecting <{0}>", GroupName));
|
|
|
|
keys = new Hashtable ();
|
|
foreach (XmlNode n in node.ChildNodes) {
|
|
string name = n.Attributes ["name"].Value;
|
|
if (CheckIfAdd (name, n)) {
|
|
string key = GetNodeKey (name, n);
|
|
//keys.Add (key, name);
|
|
keys [key] = name;
|
|
LoadExtraData (key, n);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual bool CheckIfAdd (string value, XmlNode node)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected virtual void LoadExtraData (string name, XmlNode node)
|
|
{
|
|
}
|
|
|
|
public override void CompareTo (XmlDocument doc, XmlNode parent, object other)
|
|
{
|
|
this.document = doc;
|
|
if (group == null)
|
|
group = doc.CreateElement (GroupName, null);
|
|
|
|
Hashtable okeys = null;
|
|
if (other != null && ((XMLNameGroup) other).keys != null) {
|
|
okeys = ((XMLNameGroup) other).keys;
|
|
}
|
|
|
|
XmlNode node = null;
|
|
bool onull = (okeys == null);
|
|
if (keys != null) {
|
|
foreach (DictionaryEntry entry in keys) {
|
|
node = doc.CreateElement (Name, null);
|
|
group.AppendChild (node);
|
|
string key = (string) entry.Key;
|
|
string name = (string) entry.Value;
|
|
AddAttribute (node, "name", name);
|
|
|
|
if (!onull && HasKey (key, okeys)) {
|
|
CompareToInner (key, node, (XMLNameGroup) other);
|
|
okeys.Remove (key);
|
|
counters.Present++;
|
|
} else {
|
|
AddAttribute (node, "presence", "missing");
|
|
counters.Missing++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!onull && okeys.Count != 0) {
|
|
foreach (string value in okeys.Values) {
|
|
node = doc.CreateElement (Name, null);
|
|
AddAttribute (node, "name", (string) value);
|
|
AddAttribute (node, "presence", "extra");
|
|
group.AppendChild (node);
|
|
counters.Extra++;
|
|
}
|
|
}
|
|
|
|
if (group.HasChildNodes)
|
|
parent.AppendChild (group);
|
|
}
|
|
|
|
protected virtual void CompareToInner (string name, XmlNode node, XMLNameGroup other)
|
|
{
|
|
}
|
|
|
|
public virtual string GetNodeKey (string name, XmlNode node)
|
|
{
|
|
return name;
|
|
}
|
|
|
|
public virtual bool HasKey (string key, Hashtable other)
|
|
{
|
|
return other.ContainsKey (key);
|
|
}
|
|
|
|
public abstract string GroupName { get; }
|
|
public abstract string Name { get; }
|
|
}
|
|
|
|
class XMLAssembly : XMLData
|
|
{
|
|
XMLAttributes attributes;
|
|
XMLNamespace [] namespaces;
|
|
string name;
|
|
string version;
|
|
|
|
public override void LoadData (XmlNode node)
|
|
{
|
|
if (node == null)
|
|
throw new ArgumentNullException ("node");
|
|
|
|
name = node.Attributes ["name"].Value;
|
|
version = node.Attributes ["version"].Value;
|
|
XmlNode atts = node.FirstChild;
|
|
attributes = new XMLAttributes ();
|
|
if (atts.Name == "attributes") {
|
|
attributes.LoadData (atts);
|
|
atts = atts.NextSibling;
|
|
}
|
|
|
|
if (atts == null || atts.Name != "namespaces") {
|
|
#if !EXCLUDE_DRIVER
|
|
Console.Error.WriteLine (@"Warning: no namespaces found for {name}");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
namespaces = (XMLNamespace []) LoadRecursive (atts.ChildNodes, typeof (XMLNamespace));
|
|
}
|
|
|
|
public override void CompareTo (XmlDocument doc, XmlNode parent, object other)
|
|
{
|
|
XMLAssembly assembly = (XMLAssembly) other;
|
|
|
|
XmlNode childA = doc.CreateElement ("assembly", null);
|
|
AddAttribute (childA, "name", name);
|
|
AddAttribute (childA, "version", version);
|
|
if (name != assembly.name)
|
|
AddWarning (childA, "Assembly names not equal: {0}, {1}", name, assembly.name);
|
|
|
|
if (version != assembly.version)
|
|
AddWarning (childA, "Assembly version not equal: {0}, {1}", version, assembly.version);
|
|
|
|
parent.AppendChild (childA);
|
|
|
|
attributes.CompareTo (doc, childA, assembly.attributes);
|
|
counters.AddPartialToPartial (attributes.Counters);
|
|
|
|
CompareNamespaces (childA, assembly.namespaces);
|
|
if (assembly.attributes != null && assembly.attributes.IsTodo) {
|
|
counters.Todo++;
|
|
counters.TodoTotal++;
|
|
counters.ErrorTotal++;
|
|
AddAttribute (childA, "error", "todo");
|
|
if (assembly.attributes.Comment != null)
|
|
AddAttribute (childA, "comment", assembly.attributes.Comment);
|
|
}
|
|
|
|
AddCountersAttributes (childA);
|
|
}
|
|
|
|
void CompareNamespaces (XmlNode parent, XMLNamespace [] other)
|
|
{
|
|
ArrayList newNS = new ArrayList ();
|
|
XmlNode group = document.CreateElement ("namespaces", null);
|
|
parent.AppendChild (group);
|
|
|
|
Hashtable oh = CreateHash (other);
|
|
XmlNode node = null;
|
|
int count = (namespaces == null) ? 0 : namespaces.Length;
|
|
for (int i = 0; i < count; i++) {
|
|
XMLNamespace xns = namespaces [i];
|
|
|
|
node = document.CreateElement ("namespace", null);
|
|
newNS.Add (node);
|
|
AddAttribute (node, "name", xns.Name);
|
|
|
|
int idx = -1;
|
|
if (oh.ContainsKey (xns.Name))
|
|
idx = (int) oh [xns.Name];
|
|
XMLNamespace ons = idx >= 0 ? (XMLNamespace) other [idx] : null;
|
|
xns.CompareTo (document, node, ons);
|
|
if (idx >= 0)
|
|
other [idx] = null;
|
|
xns.AddCountersAttributes (node);
|
|
counters.Present++;
|
|
counters.PresentTotal++;
|
|
counters.AddPartialToTotal (xns.Counters);
|
|
}
|
|
|
|
if (other != null) {
|
|
count = other.Length;
|
|
for (int i = 0; i < count; i++) {
|
|
XMLNamespace n = other [i];
|
|
if (n == null)
|
|
continue;
|
|
|
|
node = document.CreateElement ("namespace", null);
|
|
newNS.Add (node);
|
|
AddAttribute (node, "name", n.Name);
|
|
AddExtra (node);
|
|
counters.ExtraTotal++;
|
|
}
|
|
}
|
|
|
|
XmlNode [] nodes = (XmlNode []) newNS.ToArray (typeof (XmlNode));
|
|
Array.Sort (nodes, XmlNodeComparer.Default);
|
|
foreach (XmlNode nn in nodes)
|
|
group.AppendChild (nn);
|
|
}
|
|
|
|
static Hashtable CreateHash (XMLNamespace [] other)
|
|
{
|
|
Hashtable result = new Hashtable ();
|
|
if (other != null) {
|
|
int i = 0;
|
|
foreach (XMLNamespace n in other) {
|
|
result [n.Name] = i++;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public XmlDocument CompareAndGetDocument (XMLAssembly other)
|
|
{
|
|
XmlDocument doc = new XmlDocument ();
|
|
this.document = doc;
|
|
XmlNode parent = doc.CreateElement ("assemblies", null);
|
|
doc.AppendChild (parent);
|
|
|
|
CompareTo (doc, parent, other);
|
|
|
|
XmlNode decl = doc.CreateXmlDeclaration ("1.0", null, null);
|
|
doc.InsertBefore (decl, doc.DocumentElement);
|
|
|
|
return doc;
|
|
}
|
|
}
|
|
|
|
class XMLNamespace : XMLData
|
|
{
|
|
string name;
|
|
XMLClass [] types;
|
|
|
|
public override void LoadData (XmlNode node)
|
|
{
|
|
if (node == null)
|
|
throw new ArgumentNullException ("node");
|
|
|
|
if (node.Name != "namespace")
|
|
throw new FormatException ("Expecting <namespace>");
|
|
|
|
name = node.Attributes ["name"].Value;
|
|
XmlNode classes = node.FirstChild;
|
|
if (classes == null) {
|
|
#if !EXCLUDE_DRIVER
|
|
Console.Error.WriteLine ($"Warning: no classes for {name}");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (classes.Name != "classes")
|
|
throw new FormatException ($"Expecting <classes>. Got <{classes.Name}> (namespace {name}).");
|
|
|
|
types = (XMLClass []) LoadRecursive (classes.ChildNodes, typeof (XMLClass));
|
|
}
|
|
|
|
public override void CompareTo (XmlDocument doc, XmlNode parent, object other)
|
|
{
|
|
this.document = doc;
|
|
XMLNamespace nspace = (XMLNamespace) other;
|
|
|
|
XmlNode childA = doc.CreateElement ("classes", null);
|
|
parent.AppendChild (childA);
|
|
|
|
CompareTypes (childA, nspace != null ? nspace.types : new XMLClass [0]);
|
|
}
|
|
|
|
void CompareTypes (XmlNode parent, XMLClass [] other)
|
|
{
|
|
ArrayList newNodes = new ArrayList ();
|
|
Hashtable oh = CreateHash (other);
|
|
XmlNode node = null;
|
|
int count = (types == null) ? 0 : types.Length;
|
|
for (int i = 0; i < count; i++) {
|
|
XMLClass xclass = types [i];
|
|
|
|
node = document.CreateElement ("class", null);
|
|
newNodes.Add (node);
|
|
AddAttribute (node, "name", xclass.Name);
|
|
AddAttribute (node, "type", xclass.Type);
|
|
|
|
int idx = -1;
|
|
if (oh.ContainsKey (xclass.Name))
|
|
idx = (int) oh [xclass.Name];
|
|
xclass.CompareTo (document, node, idx >= 0 ? other [idx] : new XMLClass ());
|
|
if (idx >= 0)
|
|
other [idx] = null;
|
|
counters.AddPartialToPartial (xclass.Counters);
|
|
}
|
|
|
|
if (other != null) {
|
|
count = other.Length;
|
|
for (int i = 0; i < count; i++) {
|
|
XMLClass c = other [i];
|
|
if (c == null || IsMonoTODOAttribute (c.Name))
|
|
continue;
|
|
|
|
node = document.CreateElement ("class", null);
|
|
newNodes.Add (node);
|
|
AddAttribute (node, "name", c.Name);
|
|
AddAttribute (node, "type", c.Type);
|
|
AddExtra (node);
|
|
counters.Extra++;
|
|
counters.ExtraTotal++;
|
|
}
|
|
}
|
|
|
|
XmlNode [] nodes = (XmlNode []) newNodes.ToArray (typeof (XmlNode));
|
|
Array.Sort (nodes, XmlNodeComparer.Default);
|
|
foreach (XmlNode nn in nodes)
|
|
parent.AppendChild (nn);
|
|
}
|
|
|
|
static Hashtable CreateHash (XMLClass [] other)
|
|
{
|
|
Hashtable result = new Hashtable ();
|
|
if (other != null) {
|
|
int i = 0;
|
|
foreach (XMLClass c in other) {
|
|
result [c.Name] = i++;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public string Name {
|
|
get { return name; }
|
|
}
|
|
}
|
|
|
|
class XMLClass : XMLData
|
|
{
|
|
string name;
|
|
string type;
|
|
string baseName;
|
|
bool isSealed;
|
|
bool isSerializable;
|
|
bool isAbstract;
|
|
string charSet;
|
|
string layout;
|
|
XMLAttributes attributes;
|
|
XMLInterfaces interfaces;
|
|
XMLGenericTypeConstraints genericConstraints;
|
|
XMLFields fields;
|
|
XMLConstructors constructors;
|
|
XMLProperties properties;
|
|
XMLEvents events;
|
|
XMLMethods methods;
|
|
XMLClass [] nested;
|
|
|
|
public override void LoadData (XmlNode node)
|
|
{
|
|
if (node == null)
|
|
throw new ArgumentNullException ("node");
|
|
|
|
name = node.Attributes ["name"].Value;
|
|
type = node.Attributes ["type"].Value;
|
|
XmlAttribute xatt = node.Attributes ["base"];
|
|
if (xatt != null)
|
|
baseName = xatt.Value;
|
|
|
|
xatt = node.Attributes ["sealed"];
|
|
isSealed = (xatt != null && xatt.Value == "true");
|
|
|
|
xatt = node.Attributes ["abstract"];
|
|
isAbstract = (xatt != null && xatt.Value == "true");
|
|
|
|
xatt = node.Attributes["serializable"];
|
|
isSerializable = (xatt != null && xatt.Value == "true");
|
|
|
|
xatt = node.Attributes["charset"];
|
|
if (xatt != null)
|
|
charSet = xatt.Value;
|
|
|
|
xatt = node.Attributes["layout"];
|
|
if (xatt != null)
|
|
layout = xatt.Value;
|
|
|
|
XmlNode child = node.FirstChild;
|
|
if (child == null) {
|
|
return;
|
|
}
|
|
|
|
if (child.Name == "attributes") {
|
|
attributes = new XMLAttributes ();
|
|
attributes.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
if (child != null && child.Name == "interfaces") {
|
|
interfaces = new XMLInterfaces ();
|
|
interfaces.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
if (child != null && child.Name == "generic-type-constraints") {
|
|
genericConstraints = new XMLGenericTypeConstraints ();
|
|
genericConstraints.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
if (child != null && child.Name == "fields") {
|
|
fields = new XMLFields ();
|
|
fields.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
if (child != null && child.Name == "constructors") {
|
|
constructors = new XMLConstructors ();
|
|
constructors.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
if (child != null && child.Name == "properties") {
|
|
properties = new XMLProperties ();
|
|
properties.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
if (child != null && child.Name == "events") {
|
|
events = new XMLEvents ();
|
|
events.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
if (child != null && child.Name == "methods") {
|
|
methods = new XMLMethods ();
|
|
methods.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
if (child != null && child.Name == "generic-parameters") {
|
|
// HACK: ignore this tag as it doesn't seem to
|
|
// add any value when checking for differences
|
|
return;
|
|
}
|
|
|
|
if (child == null)
|
|
return;
|
|
|
|
if (child.Name != "classes") {
|
|
throw new FormatException ($"Expecting <classes>. Got <{child.Name}> ({type} {name}).");
|
|
}
|
|
|
|
nested = (XMLClass []) LoadRecursive (child.ChildNodes, typeof (XMLClass));
|
|
}
|
|
|
|
public override void CompareTo (XmlDocument doc, XmlNode parent, object other)
|
|
{
|
|
this.document = doc;
|
|
XMLClass oclass = (XMLClass) other;
|
|
|
|
if (attributes != null || oclass.attributes != null) {
|
|
if (attributes == null)
|
|
attributes = new XMLAttributes ();
|
|
|
|
attributes.CompareTo (doc, parent, oclass.attributes);
|
|
counters.AddPartialToPartial (attributes.Counters);
|
|
if (oclass.attributes != null && oclass.attributes.IsTodo) {
|
|
counters.Todo++;
|
|
counters.TodoTotal++;
|
|
counters.ErrorTotal++;
|
|
AddAttribute (parent, "error", "todo");
|
|
if (oclass.attributes.Comment != null)
|
|
AddAttribute (parent, "comment", oclass.attributes.Comment);
|
|
}
|
|
}
|
|
|
|
if (type != oclass.type)
|
|
AddWarning (parent, "Class type is wrong: {0} != {1}", type, oclass.type);
|
|
|
|
if (baseName != oclass.baseName)
|
|
AddWarning (parent, "Base class is wrong: {0} != {1}", baseName, oclass.baseName);
|
|
|
|
if (isAbstract != oclass.isAbstract || isSealed != oclass.isSealed) {
|
|
if ((isAbstract && isSealed) || (oclass.isAbstract && oclass.isSealed))
|
|
AddWarning (parent, "Should {0}be static", (isAbstract && isSealed) ? "" : "not ");
|
|
else if (isAbstract != oclass.isAbstract)
|
|
AddWarning (parent, "Should {0}be abstract", isAbstract ? "" : "not ");
|
|
else if (isSealed != oclass.isSealed)
|
|
AddWarning (parent, "Should {0}be sealed", isSealed ? "" : "not ");
|
|
}
|
|
|
|
if (isSerializable != oclass.isSerializable)
|
|
AddWarning (parent, "Should {0}be serializable", isSerializable ? "" : "not ");
|
|
|
|
if (charSet != oclass.charSet)
|
|
AddWarning (parent, "CharSet is wrong: {0} != {1}", charSet, oclass.charSet);
|
|
|
|
if (layout != oclass.layout)
|
|
AddWarning (parent, "Layout is wrong: {0} != {1}", layout, oclass.layout);
|
|
|
|
if (interfaces != null || oclass.interfaces != null) {
|
|
if (interfaces == null)
|
|
interfaces = new XMLInterfaces ();
|
|
|
|
interfaces.CompareTo (doc, parent, oclass.interfaces);
|
|
counters.AddPartialToPartial (interfaces.Counters);
|
|
}
|
|
|
|
if (genericConstraints != null || oclass.genericConstraints != null) {
|
|
if (genericConstraints == null)
|
|
genericConstraints = new XMLGenericTypeConstraints ();
|
|
|
|
genericConstraints.CompareTo (doc, parent, oclass.genericConstraints);
|
|
counters.AddPartialToPartial (genericConstraints.Counters);
|
|
}
|
|
|
|
if (fields != null || oclass.fields != null) {
|
|
if (fields == null)
|
|
fields = new XMLFields ();
|
|
|
|
fields.CompareTo (doc, parent, oclass.fields);
|
|
counters.AddPartialToPartial (fields.Counters);
|
|
}
|
|
|
|
if (constructors != null || oclass.constructors != null) {
|
|
if (constructors == null)
|
|
constructors = new XMLConstructors ();
|
|
|
|
constructors.CompareTo (doc, parent, oclass.constructors);
|
|
counters.AddPartialToPartial (constructors.Counters);
|
|
}
|
|
|
|
if (properties != null || oclass.properties != null) {
|
|
if (properties == null)
|
|
properties = new XMLProperties ();
|
|
|
|
properties.CompareTo (doc, parent, oclass.properties);
|
|
counters.AddPartialToPartial (properties.Counters);
|
|
}
|
|
|
|
if (events != null || oclass.events != null) {
|
|
if (events == null)
|
|
events = new XMLEvents ();
|
|
|
|
events.CompareTo (doc, parent, oclass.events);
|
|
counters.AddPartialToPartial (events.Counters);
|
|
}
|
|
|
|
if (methods != null || oclass.methods != null) {
|
|
if (methods == null)
|
|
methods = new XMLMethods ();
|
|
|
|
methods.CompareTo (doc, parent, oclass.methods);
|
|
counters.AddPartialToPartial (methods.Counters);
|
|
}
|
|
|
|
if (nested != null || oclass.nested != null) {
|
|
XmlNode n = doc.CreateElement ("classes", null);
|
|
parent.AppendChild (n);
|
|
CompareTypes (n, oclass.nested);
|
|
}
|
|
|
|
AddCountersAttributes (parent);
|
|
}
|
|
|
|
void CompareTypes (XmlNode parent, XMLClass [] other)
|
|
{
|
|
ArrayList newNodes = new ArrayList ();
|
|
Hashtable oh = CreateHash (other);
|
|
XmlNode node = null;
|
|
int count = (nested == null) ? 0 : nested.Length;
|
|
for (int i = 0; i < count; i++) {
|
|
XMLClass xclass = nested [i];
|
|
|
|
node = document.CreateElement ("class", null);
|
|
newNodes.Add (node);
|
|
AddAttribute (node, "name", xclass.Name);
|
|
AddAttribute (node, "type", xclass.Type);
|
|
|
|
if (oh.ContainsKey (xclass.Name)) {
|
|
int idx = (int) oh [xclass.Name];
|
|
xclass.CompareTo (document, node, other [idx]);
|
|
other [idx] = null;
|
|
counters.AddPartialToPartial (xclass.Counters);
|
|
} else {
|
|
// TODO: Should I count here?
|
|
AddAttribute (node, "presence", "missing");
|
|
counters.Missing++;
|
|
counters.MissingTotal++;
|
|
}
|
|
}
|
|
|
|
if (other != null) {
|
|
count = other.Length;
|
|
for (int i = 0; i < count; i++) {
|
|
XMLClass c = other [i];
|
|
if (c == null || IsMonoTODOAttribute (c.Name))
|
|
continue;
|
|
|
|
node = document.CreateElement ("class", null);
|
|
newNodes.Add (node);
|
|
AddAttribute (node, "name", c.Name);
|
|
AddAttribute (node, "type", c.Type);
|
|
AddExtra (node);
|
|
counters.Extra++;
|
|
counters.ExtraTotal++;
|
|
}
|
|
}
|
|
|
|
XmlNode [] nodes = (XmlNode []) newNodes.ToArray (typeof (XmlNode));
|
|
Array.Sort (nodes, XmlNodeComparer.Default);
|
|
foreach (XmlNode nn in nodes)
|
|
parent.AppendChild (nn);
|
|
}
|
|
|
|
static Hashtable CreateHash (XMLClass [] other)
|
|
{
|
|
Hashtable result = new Hashtable ();
|
|
if (other != null) {
|
|
int i = 0;
|
|
foreach (XMLClass c in other) {
|
|
result [c.Name] = i++;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public string Name {
|
|
get { return name; }
|
|
}
|
|
|
|
public string Type {
|
|
get { return type; }
|
|
}
|
|
}
|
|
|
|
class XMLParameter : XMLData
|
|
{
|
|
string name;
|
|
string type;
|
|
string attrib;
|
|
string direction;
|
|
bool isUnsafe;
|
|
bool isOptional;
|
|
string defaultValue;
|
|
XMLAttributes attributes;
|
|
|
|
public override void LoadData (XmlNode node)
|
|
{
|
|
if (node == null)
|
|
throw new ArgumentNullException ("node");
|
|
|
|
if (node.Name != "parameter")
|
|
throw new ArgumentException ("Expecting <parameter>");
|
|
|
|
name = node.Attributes["name"].Value;
|
|
type = node.Attributes["type"].Value;
|
|
attrib = node.Attributes["attrib"].Value;
|
|
if (node.Attributes ["direction"] != null)
|
|
direction = node.Attributes["direction"].Value;
|
|
if (node.Attributes["unsafe"] != null)
|
|
isUnsafe = bool.Parse (node.Attributes["unsafe"].Value);
|
|
if (node.Attributes["optional"] != null)
|
|
isOptional = bool.Parse (node.Attributes["optional"].Value);
|
|
if (node.Attributes["defaultValue"] != null)
|
|
defaultValue = node.Attributes["defaultValue"].Value;
|
|
|
|
XmlNode child = node.FirstChild;
|
|
if (child == null)
|
|
return;
|
|
|
|
if (child.Name == "attributes") {
|
|
attributes = new XMLAttributes ();
|
|
attributes.LoadData (child);
|
|
child = child.NextSibling;
|
|
}
|
|
}
|
|
|
|
public override void CompareTo (XmlDocument doc, XmlNode parent, object other)
|
|
{
|
|
this.document = doc;
|
|
|
|
XMLParameter oparm = (XMLParameter) other;
|
|
|
|
if (name != oparm.name)
|
|
AddWarning (parent, "Parameter name is wrong: {0} != {1}", name, oparm.name);
|
|
|
|
if (type != oparm.type)
|
|
AddWarning (parent, "Parameter type is wrong: {0} != {1}", type, oparm.type);
|
|
|
|
if (attrib != oparm.attrib)
|
|
AddWarning (parent, "Parameter attributes wrong: {0} != {1}", attrib, oparm.attrib);
|
|
|
|
if (direction != oparm.direction)
|
|
AddWarning (parent, "Parameter direction wrong: {0} != {1}", direction, oparm.direction);
|
|
|
|
if (isUnsafe != oparm.isUnsafe)
|
|
AddWarning (parent, "Parameter unsafe wrong: {0} != {1}", isUnsafe, oparm.isUnsafe);
|
|
|
|
if (isOptional != oparm.isOptional)
|
|
AddWarning (parent, "Parameter optional wrong: {0} != {1}", isOptional, oparm.isOptional);
|
|
|
|
if (defaultValue != oparm.defaultValue)
|
|
AddWarning (parent, "Parameter default value wrong: {0} != {1}", (defaultValue == null) ? "(no default value)" : defaultValue, (oparm.defaultValue == null) ? "(no default value)" : oparm.defaultValue);
|
|
|
|
if (attributes != null || oparm.attributes != null) {
|
|
if (attributes == null)
|
|
attributes = new XMLAttributes ();
|
|
|
|
attributes.CompareTo (doc, parent, oparm.attributes);
|
|
counters.AddPartialToPartial (attributes.Counters);
|
|
if (oparm.attributes != null && oparm.attributes.IsTodo) {
|
|
counters.Todo++;
|
|
counters.TodoTotal++;
|
|
counters.ErrorTotal++;
|
|
AddAttribute (parent, "error", "todo");
|
|
if (oparm.attributes.Comment != null)
|
|
AddAttribute (parent, "comment", oparm.attributes.Comment);
|
|
}
|
|
}
|
|
}
|
|
|
|
public string Name {
|
|
get { return name; }
|
|
}
|
|
}
|
|
|
|
class XMLAttributeProperties: XMLNameGroup
|
|
{
|
|
static Hashtable ignored_properties;
|
|
static XMLAttributeProperties ()
|
|
{
|
|
ignored_properties = new Hashtable ();
|
|
ignored_properties.Add ("System.Reflection.AssemblyKeyFileAttribute", "KeyFile");
|
|
ignored_properties.Add ("System.Reflection.AssemblyCompanyAttribute", "Company");
|
|
ignored_properties.Add ("System.Reflection.AssemblyConfigurationAttribute", "Configuration");
|
|
ignored_properties.Add ("System.Reflection.AssemblyCopyrightAttribute", "Copyright");
|
|
ignored_properties.Add ("System.Reflection.AssemblyProductAttribute", "Product");
|
|
ignored_properties.Add ("System.Reflection.AssemblyTrademarkAttribute", "Trademark");
|
|
ignored_properties.Add ("System.Reflection.AssemblyInformationalVersionAttribute", "InformationalVersion");
|
|
|
|
ignored_properties.Add ("System.ObsoleteAttribute", "Message");
|
|
ignored_properties.Add ("System.IO.IODescriptionAttribute", "Description");
|
|
ignored_properties.Add ("System.Diagnostics.MonitoringDescriptionAttribute", "Description");
|
|
}
|
|
|
|
Hashtable properties = new Hashtable ();
|
|
string attribute;
|
|
|
|
public XMLAttributeProperties (string attribute)
|
|
{
|
|
this.attribute = attribute;
|
|
}
|
|
|
|
public override void LoadData(XmlNode node)
|
|
{
|
|
if (node == null)
|
|
throw new ArgumentNullException ("node");
|
|
|
|
if (node.ChildNodes == null)
|
|
return;
|
|
|
|
string ignored = ignored_properties [attribute] as string;
|
|
|
|
foreach (XmlNode n in node.ChildNodes) {
|
|
string name = n.Attributes ["name"].Value;
|
|
if (ignored == name)
|
|
continue;
|
|
|
|
if (n.Attributes ["null"] != null) {
|
|
properties.Add (name, null);
|
|
continue;
|
|
}
|
|
string value = n.Attributes ["value"].Value;
|
|
properties.Add (name, value);
|
|
}
|
|
}
|
|
|
|
public override void CompareTo (XmlDocument doc, XmlNode parent, object other)
|
|
{
|
|
this.document = doc;
|
|
|
|
Hashtable other_properties = ((XMLAttributeProperties)other).properties;
|
|
foreach (DictionaryEntry de in other_properties) {
|
|
object other_value = properties [de.Key];
|
|
|
|
if (de.Value == null) {
|
|
if (other_value != null)
|
|
AddWarning (parent, "Property '{0}' is 'null' and should be '{1}'", de.Key, other_value);
|
|
continue;
|
|
}
|
|
|
|
if (de.Value.Equals (other_value))
|
|
continue;
|
|
|
|
AddWarning (parent, "Property '{0}' is '{1}' and should be '{2}'",
|
|
de.Key, de.Value, other_value == null ? "null" : other_value);
|
|
}
|
|
}
|
|
|
|
public override string GroupName {
|
|
get {
|
|
return "properties";
|
|
}
|
|
}
|
|
|
|
public override string Name {
|
|
get {
|
|
return "";
|
|
}
|
|
}
|
|
}
|
|
|
|
class XMLAttributes : XMLNameGroup
|
|
{
|
|
Hashtable properties = new Hashtable ();
|
|
|
|
bool isTodo;
|
|
string comment;
|
|
|
|
protected override bool CheckIfAdd (string value, XmlNode node)
|
|
{
|
|
if (IsMonoTODOAttribute (value)) {
|
|
isTodo = true;
|
|
|
|
XmlNode pNode = node.SelectSingleNode ("properties");
|
|
if (pNode != null && pNode.ChildNodes.Count > 0 && pNode.ChildNodes [0].Attributes ["value"] != null) {
|
|
comment = pNode.ChildNodes [0].Attributes ["value"].Value;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return !IsMeaninglessAttribute (value);
|
|
}
|
|
|
|
protected override void CompareToInner (string name, XmlNode node, XMLNameGroup other)
|
|
{
|
|
XMLAttributeProperties other_prop = ((XMLAttributes)other).properties [name] as XMLAttributeProperties;
|
|
XMLAttributeProperties this_prop = properties [name] as XMLAttributeProperties;
|
|
if (other_prop == null || this_prop == null)
|
|
return;
|
|
|
|
this_prop.CompareTo (document, node, other_prop);
|
|
counters.AddPartialToPartial (this_prop.Counters);
|
|
}
|
|
|
|
public override string GetNodeKey (string name, XmlNode node)
|
|
{
|
|
string key = null;
|
|
|
|
// if multiple attributes with the same name (type) exist, then we
|
|
// cannot be sure which attributes correspond, so we must use the
|
|
// name of the attribute (type) and the name/value of its properties
|
|
// as key
|
|
|
|
XmlNodeList attributes = node.ParentNode.SelectNodes("attribute[@name='" + name + "']");
|
|
if (attributes.Count > 1) {
|
|
ArrayList keyParts = new ArrayList ();
|
|
|
|
XmlNodeList properties = node.SelectNodes ("properties/property");
|
|
foreach (XmlNode property in properties) {
|
|
XmlAttributeCollection attrs = property.Attributes;
|
|
if (attrs["value"] != null) {
|
|
keyParts.Add (attrs["name"].Value + "=" + attrs["value"].Value);
|
|
} else {
|
|
keyParts.Add (attrs["name"].Value + "=");
|
|
}
|
|
}
|
|
|
|
// sort properties by name, as order of properties in XML is
|
|
// undefined
|
|
keyParts.Sort ();
|
|
|
|
// insert name (type) of attribute
|
|
keyParts.Insert (0, name);
|
|
|
|
StringBuilder sb = new StringBuilder ();
|
|
foreach (string value in keyParts) {
|
|
sb.Append (value);
|
|
sb.Append (';');
|
|
}
|
|
key = sb.ToString ();
|
|
} else {
|
|
key = name;
|
|
}
|
|
|
|
return key;
|
|
}
|
|
|
|
protected override void LoadExtraData(string name, XmlNode node)
|
|
{
|
|
XmlNode pNode = node.SelectSingleNode ("properties");
|
|
|
|
if (IsMonoTODOAttribute (name)) {
|
|
isTodo = true;
|
|
if (pNode.ChildNodes [0].Attributes ["value"] != null) {
|
|
comment = pNode.ChildNodes [0].Attributes ["value"].Value;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (pNode != null) {
|
|
XMLAttributeProperties p = new XMLAttributeProperties (name);
|
|
p.LoadData (pNode);
|
|
|
|
properties[name] = p;
|
|
}
|
|
}
|
|
|
|
public override string GroupName {
|
|
get { return "attributes"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "attribute"; }
|
|
}
|
|
|
|
public bool IsTodo {
|
|
get { return isTodo; }
|
|
}
|
|
|
|
public string Comment {
|
|
get { return comment; }
|
|
}
|
|
}
|
|
|
|
class XMLInterfaces : XMLNameGroup
|
|
{
|
|
public override string GroupName {
|
|
get { return "interfaces"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "interface"; }
|
|
}
|
|
}
|
|
|
|
abstract class XMLGenericGroup : XMLNameGroup
|
|
{
|
|
string attributes;
|
|
|
|
protected override void LoadExtraData (string name, XmlNode node)
|
|
{
|
|
attributes = ((XmlElement) node).GetAttribute ("generic-attribute");
|
|
}
|
|
|
|
protected override void CompareToInner (string name, XmlNode parent, XMLNameGroup other)
|
|
{
|
|
base.CompareToInner (name, parent, other);
|
|
|
|
XMLGenericGroup g = (XMLGenericGroup) other;
|
|
if (attributes != g.attributes)
|
|
AddWarning (parent, "Incorrect generic attributes: '{0}' != '{1}'", attributes, g.attributes);
|
|
}
|
|
}
|
|
|
|
class XMLGenericTypeConstraints : XMLGenericGroup
|
|
{
|
|
public override string GroupName {
|
|
get { return "generic-type-constraints"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "generic-type-constraint"; }
|
|
}
|
|
}
|
|
|
|
class XMLGenericMethodConstraints : XMLGenericGroup
|
|
{
|
|
public override string GroupName {
|
|
get { return "generic-method-constraints"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "generic-method-constraint"; }
|
|
}
|
|
}
|
|
|
|
abstract class XMLMember : XMLNameGroup
|
|
{
|
|
Hashtable attributeMap;
|
|
Hashtable access = new Hashtable ();
|
|
|
|
protected override void LoadExtraData (string name, XmlNode node)
|
|
{
|
|
XmlAttribute xatt = node.Attributes ["attrib"];
|
|
if (xatt != null)
|
|
access [name] = xatt.Value;
|
|
|
|
XmlNode orig = node;
|
|
|
|
node = node.FirstChild;
|
|
while (node != null) {
|
|
if (node != null && node.Name == "attributes") {
|
|
XMLAttributes a = new XMLAttributes ();
|
|
a.LoadData (node);
|
|
if (attributeMap == null)
|
|
attributeMap = new Hashtable ();
|
|
|
|
attributeMap [name] = a;
|
|
break;
|
|
}
|
|
node = node.NextSibling;
|
|
}
|
|
|
|
base.LoadExtraData (name, orig);
|
|
}
|
|
|
|
protected override void CompareToInner (string name, XmlNode parent, XMLNameGroup other)
|
|
{
|
|
base.CompareToInner (name, parent, other);
|
|
XMLMember mb = other as XMLMember;
|
|
XMLAttributes att = null;
|
|
XMLAttributes oatt = null;
|
|
if (attributeMap != null)
|
|
att = attributeMap [name] as XMLAttributes;
|
|
|
|
if (mb != null && mb.attributeMap != null)
|
|
oatt = mb.attributeMap [name] as XMLAttributes;
|
|
|
|
if (att != null || oatt != null) {
|
|
if (att == null)
|
|
att = new XMLAttributes ();
|
|
|
|
att.CompareTo (document, parent, oatt);
|
|
counters.AddPartialToPartial(att.Counters);
|
|
if (oatt != null && oatt.IsTodo) {
|
|
counters.Todo++;
|
|
counters.ErrorTotal++;
|
|
AddAttribute (parent, "error", "todo");
|
|
if (oatt.Comment != null)
|
|
AddAttribute (parent, "comment", oatt.Comment);
|
|
}
|
|
}
|
|
|
|
XMLMember member = (XMLMember) other;
|
|
string acc = access [name] as string;
|
|
if (acc == null)
|
|
return;
|
|
|
|
string oacc = null;
|
|
if (member.access != null)
|
|
oacc = member.access [name] as string;
|
|
|
|
string accName = ConvertToString (Int32.Parse (acc));
|
|
string oaccName = "";
|
|
if (oacc != null)
|
|
oaccName = ConvertToString (Int32.Parse (oacc));
|
|
|
|
if (accName != oaccName)
|
|
AddWarning (parent, "Incorrect attributes: '{0}' != '{1}'", accName, oaccName);
|
|
}
|
|
|
|
protected virtual string ConvertToString (int att)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
class XMLFields : XMLMember
|
|
{
|
|
Hashtable fieldTypes;
|
|
Hashtable fieldValues;
|
|
|
|
protected override void LoadExtraData (string name, XmlNode node)
|
|
{
|
|
XmlAttribute xatt = node.Attributes ["fieldtype"];
|
|
if (xatt != null) {
|
|
if (fieldTypes == null)
|
|
fieldTypes = new Hashtable ();
|
|
|
|
fieldTypes [name] = xatt.Value;
|
|
}
|
|
|
|
xatt = node.Attributes ["value"];
|
|
if (xatt != null) {
|
|
if (fieldValues == null)
|
|
fieldValues = new Hashtable ();
|
|
|
|
fieldValues[name] = xatt.Value;
|
|
}
|
|
|
|
base.LoadExtraData (name, node);
|
|
}
|
|
|
|
protected override void CompareToInner (string name, XmlNode parent, XMLNameGroup other)
|
|
{
|
|
base.CompareToInner (name, parent, other);
|
|
XMLFields fields = (XMLFields) other;
|
|
if (fieldTypes != null) {
|
|
string ftype = fieldTypes [name] as string;
|
|
string oftype = null;
|
|
if (fields.fieldTypes != null)
|
|
oftype = fields.fieldTypes [name] as string;
|
|
|
|
if (ftype != oftype)
|
|
AddWarning (parent, "Field type is {0} and should be {1}", oftype, ftype);
|
|
}
|
|
if (fieldValues != null) {
|
|
string fvalue = fieldValues [name] as string;
|
|
string ofvalue = null;
|
|
if (fields.fieldValues != null)
|
|
ofvalue = fields.fieldValues [name] as string;
|
|
|
|
if (fvalue != ofvalue)
|
|
AddWarning (parent, "Field value is {0} and should be {1}", ofvalue, fvalue);
|
|
}
|
|
}
|
|
|
|
protected override string ConvertToString (int att)
|
|
{
|
|
FieldAttributes fa = (FieldAttributes) att;
|
|
return fa.ToString ();
|
|
}
|
|
|
|
public override string GroupName {
|
|
get { return "fields"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "field"; }
|
|
}
|
|
}
|
|
|
|
class XMLParameters : XMLNameGroup
|
|
{
|
|
public override void LoadData (XmlNode node)
|
|
{
|
|
if (node == null)
|
|
throw new ArgumentNullException ("node");
|
|
|
|
if (node.Name != GroupName)
|
|
throw new FormatException (String.Format ("Expecting <{0}>", GroupName));
|
|
|
|
keys = new Hashtable ();
|
|
foreach (XmlNode n in node.ChildNodes) {
|
|
string name = n.Attributes["name"].Value;
|
|
string key = GetNodeKey (name, n);
|
|
XMLParameter parm = new XMLParameter ();
|
|
parm.LoadData (n);
|
|
keys.Add (key, parm);
|
|
LoadExtraData (key, n);
|
|
}
|
|
}
|
|
|
|
public override string GroupName {
|
|
get {
|
|
return "parameters";
|
|
}
|
|
}
|
|
|
|
public override string Name {
|
|
get {
|
|
return "parameter";
|
|
}
|
|
}
|
|
|
|
public override string GetNodeKey (string name, XmlNode node)
|
|
{
|
|
return node.Attributes["position"].Value;
|
|
}
|
|
|
|
public override void CompareTo (XmlDocument doc, XmlNode parent, object other)
|
|
{
|
|
this.document = doc;
|
|
if (group == null)
|
|
group = doc.CreateElement (GroupName, null);
|
|
|
|
Hashtable okeys = null;
|
|
if (other != null && ((XMLParameters) other).keys != null) {
|
|
okeys = ((XMLParameters) other).keys;
|
|
}
|
|
|
|
XmlNode node = null;
|
|
bool onull = (okeys == null);
|
|
if (keys != null) {
|
|
foreach (DictionaryEntry entry in keys) {
|
|
node = doc.CreateElement (Name, null);
|
|
group.AppendChild (node);
|
|
string key = (string) entry.Key;
|
|
XMLParameter parm = (XMLParameter) entry.Value;
|
|
AddAttribute (node, "name", parm.Name);
|
|
|
|
if (!onull && HasKey (key, okeys)) {
|
|
parm.CompareTo (document, node, okeys[key]);
|
|
counters.AddPartialToPartial (parm.Counters);
|
|
okeys.Remove (key);
|
|
counters.Present++;
|
|
} else {
|
|
AddAttribute (node, "presence", "missing");
|
|
counters.Missing++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!onull && okeys.Count != 0) {
|
|
foreach (XMLParameter value in okeys.Values) {
|
|
node = doc.CreateElement (Name, null);
|
|
AddAttribute (node, "name", value.Name);
|
|
AddAttribute (node, "presence", "extra");
|
|
group.AppendChild (node);
|
|
counters.Extra++;
|
|
}
|
|
}
|
|
|
|
if (group.HasChildNodes)
|
|
parent.AppendChild (group);
|
|
}
|
|
}
|
|
|
|
class XMLProperties : XMLMember
|
|
{
|
|
Hashtable nameToMethod = new Hashtable ();
|
|
|
|
protected override void CompareToInner (string name, XmlNode parent, XMLNameGroup other)
|
|
{
|
|
Counters copy = counters;
|
|
counters = new Counters();
|
|
|
|
XMLProperties oprop = other as XMLProperties;
|
|
if (oprop != null) {
|
|
XMLMethods m = nameToMethod [name] as XMLMethods;
|
|
XMLMethods om = oprop.nameToMethod [name] as XMLMethods;
|
|
if (m != null || om != null) {
|
|
if (m == null)
|
|
m = new XMLMethods ();
|
|
|
|
m.CompareTo(document, parent, om);
|
|
counters.AddPartialToPartial(m.Counters);
|
|
}
|
|
}
|
|
|
|
base.CompareToInner (name, parent, other);
|
|
AddCountersAttributes(parent);
|
|
|
|
copy.AddPartialToPartial(counters);
|
|
counters = copy;
|
|
}
|
|
|
|
protected override void LoadExtraData (string name, XmlNode node)
|
|
{
|
|
XmlNode orig = node;
|
|
node = node.FirstChild;
|
|
while (node != null) {
|
|
if (node != null && node.Name == "methods") {
|
|
XMLMethods m = new XMLMethods ();
|
|
XmlNode parent = node.ParentNode;
|
|
string key = GetNodeKey (name, parent);
|
|
m.LoadData (node);
|
|
nameToMethod [key] = m;
|
|
break;
|
|
}
|
|
node = node.NextSibling;
|
|
}
|
|
|
|
base.LoadExtraData (name, orig);
|
|
}
|
|
|
|
public override string GetNodeKey (string name, XmlNode node)
|
|
{
|
|
XmlAttributeCollection atts = node.Attributes;
|
|
return String.Format ("{0}:{1}:{2}",
|
|
(atts["name"] != null ? atts["name"].Value : ""),
|
|
(atts["ptype"] != null ? atts["ptype"].Value : ""),
|
|
(atts["params"] != null ? atts["params"].Value : "")
|
|
);
|
|
}
|
|
|
|
public override string GroupName {
|
|
get { return "properties"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "property"; }
|
|
}
|
|
}
|
|
|
|
class XMLEvents : XMLMember
|
|
{
|
|
Hashtable eventTypes;
|
|
Hashtable nameToMethod = new Hashtable ();
|
|
|
|
protected override void LoadExtraData (string name, XmlNode node)
|
|
{
|
|
XmlAttribute xatt = node.Attributes ["eventtype"];
|
|
if (xatt != null) {
|
|
if (eventTypes == null)
|
|
eventTypes = new Hashtable ();
|
|
|
|
eventTypes [name] = xatt.Value;
|
|
}
|
|
|
|
XmlNode child = node.FirstChild;
|
|
while (child != null) {
|
|
if (child != null && child.Name == "methods") {
|
|
XMLMethods m = new XMLMethods ();
|
|
XmlNode parent = child.ParentNode;
|
|
string key = GetNodeKey (name, parent);
|
|
m.LoadData (child);
|
|
nameToMethod [key] = m;
|
|
break;
|
|
}
|
|
child = child.NextSibling;
|
|
}
|
|
|
|
base.LoadExtraData (name, node);
|
|
}
|
|
|
|
protected override void CompareToInner (string name, XmlNode parent, XMLNameGroup other)
|
|
{
|
|
Counters copy = counters;
|
|
counters = new Counters ();
|
|
|
|
try {
|
|
base.CompareToInner (name, parent, other);
|
|
AddCountersAttributes (parent);
|
|
if (eventTypes == null)
|
|
return;
|
|
|
|
XMLEvents evt = (XMLEvents) other;
|
|
string etype = eventTypes [name] as string;
|
|
string oetype = null;
|
|
if (evt.eventTypes != null)
|
|
oetype = evt.eventTypes [name] as string;
|
|
|
|
if (etype != oetype)
|
|
AddWarning (parent, "Event type is {0} and should be {1}", oetype, etype);
|
|
|
|
XMLMethods m = nameToMethod [name] as XMLMethods;
|
|
XMLMethods om = evt.nameToMethod [name] as XMLMethods;
|
|
if (m != null || om != null) {
|
|
if (m == null)
|
|
m = new XMLMethods ();
|
|
|
|
m.CompareTo (document, parent, om);
|
|
counters.AddPartialToPartial (m.Counters);
|
|
}
|
|
} finally {
|
|
AddCountersAttributes (parent);
|
|
copy.AddPartialToPartial (counters);
|
|
counters = copy;
|
|
}
|
|
}
|
|
|
|
protected override string ConvertToString (int att)
|
|
{
|
|
EventAttributes ea = (EventAttributes) att;
|
|
return ea.ToString ();
|
|
}
|
|
|
|
public override string GroupName {
|
|
get { return "events"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "event"; }
|
|
}
|
|
}
|
|
|
|
class XMLMethods : XMLMember
|
|
{
|
|
Hashtable returnTypes;
|
|
Hashtable parameters;
|
|
Hashtable genericConstraints;
|
|
Hashtable signatureFlags;
|
|
|
|
[Flags]
|
|
enum SignatureFlags
|
|
{
|
|
None = 0,
|
|
Abstract = 1,
|
|
Virtual = 2,
|
|
Static = 4,
|
|
Final = 8,
|
|
}
|
|
|
|
protected override void LoadExtraData (string name, XmlNode node)
|
|
{
|
|
XmlAttribute xatt = node.Attributes ["returntype"];
|
|
if (xatt != null) {
|
|
if (returnTypes == null)
|
|
returnTypes = new Hashtable ();
|
|
|
|
returnTypes [name] = xatt.Value;
|
|
}
|
|
|
|
SignatureFlags flags = SignatureFlags.None;
|
|
if (((XmlElement) node).GetAttribute ("abstract") == "true")
|
|
flags |= SignatureFlags.Abstract;
|
|
if (((XmlElement) node).GetAttribute ("static") == "true")
|
|
flags |= SignatureFlags.Static;
|
|
if (((XmlElement) node).GetAttribute ("virtual") == "true")
|
|
flags |= SignatureFlags.Virtual;
|
|
if (((XmlElement) node).GetAttribute ("final") == "true")
|
|
flags |= SignatureFlags.Final;
|
|
if (flags != SignatureFlags.None) {
|
|
if (signatureFlags == null)
|
|
signatureFlags = new Hashtable ();
|
|
signatureFlags [name] = flags;
|
|
}
|
|
|
|
XmlNode parametersNode = node.SelectSingleNode ("parameters");
|
|
if (parametersNode != null) {
|
|
if (parameters == null)
|
|
parameters = new Hashtable ();
|
|
|
|
XMLParameters parms = new XMLParameters ();
|
|
parms.LoadData (parametersNode);
|
|
|
|
parameters[name] = parms;
|
|
}
|
|
|
|
XmlNode genericNode = node.SelectSingleNode ("generic-method-constraints");
|
|
if (genericNode != null) {
|
|
if (genericConstraints == null)
|
|
genericConstraints = new Hashtable ();
|
|
XMLGenericMethodConstraints csts = new XMLGenericMethodConstraints ();
|
|
csts.LoadData (genericNode);
|
|
genericConstraints [name] = csts;
|
|
}
|
|
|
|
base.LoadExtraData (name, node);
|
|
}
|
|
|
|
public override string GetNodeKey (string name, XmlNode node)
|
|
{
|
|
// for explicit/implicit operators we need to include the return
|
|
// type in the key to allow matching; as a side-effect, differences
|
|
// in return types will be reported as extra/missing methods
|
|
//
|
|
// for regular methods we do not need to take into account the
|
|
// return type for matching methods; differences in return types
|
|
// will be reported as a warning on the method
|
|
if (name.StartsWith ("op_")) {
|
|
XmlAttribute xatt = node.Attributes ["returntype"];
|
|
string returnType = xatt != null ? xatt.Value + " " : string.Empty;
|
|
return returnType + name;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
protected override void CompareToInner (string name, XmlNode parent, XMLNameGroup other)
|
|
{
|
|
// create backup of actual counters
|
|
Counters copy = counters;
|
|
// initialize counters for current method
|
|
counters = new Counters();
|
|
|
|
try {
|
|
base.CompareToInner(name, parent, other);
|
|
XMLMethods methods = (XMLMethods) other;
|
|
|
|
SignatureFlags flags = signatureFlags != null &&
|
|
signatureFlags.ContainsKey (name) ?
|
|
(SignatureFlags) signatureFlags [name] :
|
|
SignatureFlags.None;
|
|
SignatureFlags oflags = methods.signatureFlags != null &&
|
|
methods.signatureFlags.ContainsKey (name) ?
|
|
(SignatureFlags) methods.signatureFlags [name] :
|
|
SignatureFlags.None;
|
|
|
|
if (flags!= oflags) {
|
|
if (flags == SignatureFlags.None)
|
|
AddWarning (parent, String.Format ("should not be {0}", oflags));
|
|
else if (oflags == SignatureFlags.None)
|
|
AddWarning (parent, String.Format ("should be {0}", flags));
|
|
else
|
|
AddWarning (parent, String.Format ("{0} and should be {1}", oflags, flags));
|
|
}
|
|
|
|
if (returnTypes != null) {
|
|
string rtype = returnTypes[name] as string;
|
|
string ortype = null;
|
|
if (methods.returnTypes != null)
|
|
ortype = methods.returnTypes[name] as string;
|
|
|
|
if (rtype != ortype)
|
|
AddWarning (parent, "Return type is {0} and should be {1}", ortype, rtype);
|
|
}
|
|
|
|
if (parameters != null) {
|
|
XMLParameters parms = parameters[name] as XMLParameters;
|
|
parms.CompareTo (document, parent, methods.parameters[name]);
|
|
counters.AddPartialToPartial (parms.Counters);
|
|
}
|
|
} finally {
|
|
// output counter attributes in result document
|
|
AddCountersAttributes(parent);
|
|
|
|
// add temporary counters to actual counters
|
|
copy.AddPartialToPartial(counters);
|
|
// restore backup of actual counters
|
|
counters = copy;
|
|
}
|
|
}
|
|
|
|
protected override string ConvertToString (int att)
|
|
{
|
|
MethodAttributes ma = (MethodAttributes) att;
|
|
// ignore ReservedMasks
|
|
ma &= ~ MethodAttributes.ReservedMask;
|
|
ma &= ~ MethodAttributes.VtableLayoutMask;
|
|
if ((ma & MethodAttributes.FamORAssem) != 0)
|
|
ma = (ma & ~ MethodAttributes.FamORAssem) | MethodAttributes.Family;
|
|
|
|
// ignore the HasSecurity attribute for now
|
|
if ((ma & MethodAttributes.HasSecurity) != 0)
|
|
ma = (MethodAttributes) (att - (int) MethodAttributes.HasSecurity);
|
|
|
|
// ignore the RequireSecObject attribute for now
|
|
if ((ma & MethodAttributes.RequireSecObject) != 0)
|
|
ma = (MethodAttributes) (att - (int) MethodAttributes.RequireSecObject);
|
|
|
|
// we don't care if the implementation is forwarded through PInvoke
|
|
if ((ma & MethodAttributes.PinvokeImpl) != 0)
|
|
ma = (MethodAttributes) (att - (int) MethodAttributes.PinvokeImpl);
|
|
|
|
return ma.ToString ();
|
|
}
|
|
|
|
public override string GroupName {
|
|
get { return "methods"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "method"; }
|
|
}
|
|
}
|
|
|
|
class XMLConstructors : XMLMethods
|
|
{
|
|
public override string GroupName {
|
|
get { return "constructors"; }
|
|
}
|
|
|
|
public override string Name {
|
|
get { return "constructor"; }
|
|
}
|
|
}
|
|
|
|
class XmlNodeComparer : IComparer
|
|
{
|
|
public static XmlNodeComparer Default = new XmlNodeComparer ();
|
|
|
|
public int Compare (object a, object b)
|
|
{
|
|
XmlNode na = (XmlNode) a;
|
|
XmlNode nb = (XmlNode) b;
|
|
return String.Compare (na.Attributes ["name"].Value, nb.Attributes ["name"].Value);
|
|
}
|
|
}
|
|
}
|
|
|