mcs/tools/corcompare/mono-api-info.cs

   1 //
   2 // mono-api-info.cs - Dumps public assembly information to an xml file.
   3 //
   4 // Authors:
   5 //      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   6 //
   7 // (C) 2003 Novell, Inc (http://www.novell.com)
   8 //
   9
  10 using System;
  11 using System.Collections;
  12 using System.Globalization;
  13 using System.Reflection;
  14 using System.Runtime.InteropServices;
  15 using System.Text;
  16 using System.Xml;
  17
  18 namespace Mono.AssemblyInfo
  19 {
  20         class Driver
  21         {
  22                 static int Main (string [] args)
  23                 {
  24                         if (args.Length == 0)
  25                                 return 1;
  26
  27                         AssemblyCollection acoll = new AssemblyCollection ();
  28
  29                         foreach (string fullName in args) {
  30                                 acoll.Add (fullName);
  31                         }
  32
  33                         XmlDocument doc = new XmlDocument ();
  34                         acoll.Document = doc;
  35                         acoll.DoOutput ();
  36
  37                         XmlTextWriter writer = new XmlTextWriter (Console.Out);
  38                         writer.Formatting = Formatting.Indented;
  39                         XmlNode decl = doc.CreateXmlDeclaration ("1.0", null, null);
  40                         doc.InsertBefore (decl, doc.DocumentElement);
  41                         doc.WriteTo (writer);
  42                         return 0;
  43                 }
  44         }
  45
  46         class AssemblyCollection
  47         {
  48                 XmlDocument document;
  49                 ArrayList assemblies;
  50
  51                 public AssemblyCollection ()
  52                 {
  53                         assemblies = new ArrayList ();
  54                 }
  55
  56                 public bool Add (string name)
  57                 {
  58                         Assembly ass = LoadAssembly (name);
  59                         if (ass == null)
  60                                 return false;
  61
  62                         assemblies.Add (ass);
  63                         return true;
  64                 }
  65
  66                 public void DoOutput ()
  67                 {
  68                         if (document == null)
  69                                 throw new InvalidOperationException ("Document not set");
  70
  71                         XmlNode nassemblies = document.CreateElement ("assemblies", null);
  72                         document.AppendChild (nassemblies);
  73                         foreach (Assembly a in assemblies) {
  74                                 AssemblyData data = new AssemblyData (document, nassemblies, a);
  75                                 data.DoOutput ();
  76                         }
  77                 }
  78
  79                 public XmlDocument Document {
  80                         set { document = value; }
  81                 }
  82
  83                 static Assembly LoadAssembly (string aname)
  84                 {
  85                         Assembly ass = null;
  86                         try {
  87                                 string name = aname;
  88                                 if (!name.EndsWith (".dll"))
  89                                         name += ".dll";
  90                                 ass = Assembly.LoadFrom (name);
  91                                 return ass;
  92                         } catch { }
  93
  94                         try {
  95                                 ass = Assembly.LoadWithPartialName (aname);
  96                                 return ass;
  97                         } catch { }
  98
  99                         return null;
 100                 }
 101         }
 102
 103         abstract class BaseData
 104         {
 105                 protected XmlDocument document;
 106                 protected XmlNode parent;
 107
 108                 protected BaseData (XmlDocument doc, XmlNode parent)
 109                 {
 110                         this.document = doc;
 111                         this.parent = parent;
 112                 }
 113
 114                 public abstract void DoOutput ();
 115
 116                 protected void AddAttribute (XmlNode node, string name, string value)
 117                 {
 118                         XmlAttribute attr = document.CreateAttribute (name);
 119                         attr.Value = value;
 120                         node.Attributes.Append (attr);
 121                 }
 122         }
 123
 124         class AssemblyData : BaseData
 125         {
 126                 Assembly ass;
 127
 128                 public AssemblyData (XmlDocument document, XmlNode parent, Assembly ass)
 129                         : base (document, parent)
 130                 {
 131                         this.ass = ass;
 132                 }
 133
 134                 public override void DoOutput ()
 135                 {
 136                         if (document == null)
 137                                 throw new InvalidOperationException ("Document not set");
 138
 139                         XmlNode nassembly = document.CreateElement ("assembly", null);
 140                         AssemblyName aname = ass.GetName ();
 141                         AddAttribute (nassembly, "name", aname.Name);
 142                         AddAttribute (nassembly, "version", aname.Version.ToString ());
 143                         parent.AppendChild (nassembly);
 144                         AttributeData.OutputAttributes (document, nassembly, ass.GetCustomAttributes (false));
 145                         Type [] types = ass.GetExportedTypes ();
 146                         if (types == null || types.Length == 0)
 147                                 return;
 148
 149                         Array.Sort (types, TypeComparer.Default);
 150
 151                         XmlNode nss = document.CreateElement ("namespaces", null);
 152                         nassembly.AppendChild (nss);
 153
 154                         string currentNS = "$%&$&";
 155                         XmlNode ns = null;
 156                         XmlNode classes = null;
 157                         foreach (Type t in types) {
 158                                 if (t.Namespace == null || t.Namespace == "")
 159                                         continue;
 160
 161                                 if (t.IsNotPublic)
 162                                         continue;
 163
 164                                 if (t.IsNestedPublic || t.IsNestedAssembly || t.IsNestedFamANDAssem ||
 165                                         t.IsNestedFamORAssem || t.IsNestedPrivate)
 166                                         continue;
 167
 168                                 if (t.DeclaringType != null)
 169                                         continue; // enforce !nested
 170
 171                                 if (t.Namespace != currentNS) {
 172                                         currentNS = t.Namespace;
 173                                         ns = document.CreateElement ("namespace", null);
 174                                         AddAttribute (ns, "name", currentNS);
 175                                         nss.AppendChild (ns);
 176                                         classes = document.CreateElement ("classes", null);
 177                                         ns.AppendChild (classes);
 178                                 }
 179
 180                                 TypeData bd = new TypeData (document, classes, t);
 181                                 bd.DoOutput ();
 182                         }
 183                 }
 184         }
 185
 186         abstract class MemberData : BaseData
 187         {
 188                 MemberInfo [] members;
 189
 190                 public MemberData (XmlDocument document, XmlNode parent, MemberInfo [] members)
 191                         : base (document, parent)
 192                 {
 193                         this.members = members;
 194                 }
 195
 196                 public override void DoOutput ()
 197                 {
 198                         XmlNode mclass = document.CreateElement (ParentTag, null);
 199                         parent.AppendChild (mclass);
 200
 201                         foreach (MemberInfo member in members) {
 202                                 XmlNode mnode = document.CreateElement (Tag, null);
 203                                 mclass.AppendChild (mnode);
 204                                 AddAttribute (mnode, "name", GetName (member));
 205                                 if (!NoMemberAttributes)
 206                                         AddAttribute (mnode, "attrib", GetMemberAttributes (member));
 207
 208                                 AttributeData.OutputAttributes (document, mnode,
 209                                                                 member.GetCustomAttributes (false));
 210
 211                                 AddExtraData (mnode, member);
 212                         }
 213                 }
 214
 215                 protected virtual void AddExtraData (XmlNode p, MemberInfo member)
 216                 {
 217                 }
 218
 219                 protected virtual string GetName (MemberInfo member)
 220                 {
 221                         return "NoNAME";
 222                 }
 223
 224                 protected virtual string GetMemberAttributes (MemberInfo member)
 225                 {
 226                         return null;
 227                 }
 228
 229                 public virtual bool NoMemberAttributes {
 230                         get { return false; }
 231                         set {}
 232                 }
 233
 234                 public virtual string ParentTag {
 235                         get { return "NoPARENTTAG"; }
 236                 }
 237
 238                 public virtual string Tag {
 239                         get { return "NoTAG"; }
 240                 }
 241         }
 242
 243         class TypeData : MemberData
 244         {
 245                 Type type;
 246                 const BindingFlags flags = BindingFlags.Public | BindingFlags.Static |
 247                                                 BindingFlags.Instance | BindingFlags.DeclaredOnly |
 248                                                 BindingFlags.NonPublic;
 249
 250                 public TypeData (XmlDocument document, XmlNode parent, Type type)
 251                         : base (document, parent, null)
 252                 {
 253                         this.type = type;
 254                 }
 255
 256                 public override void DoOutput ()
 257                 {
 258                         if (document == null)
 259                                 throw new InvalidOperationException ("Document not set");
 260
 261                         XmlNode nclass = document.CreateElement ("class", null);
 262                         AddAttribute (nclass, "name", type.Name);
 263                         string classType = GetClassType (type);
 264                         AddAttribute (nclass, "type", classType);
 265
 266                         if (type.BaseType != null)
 267                                 AddAttribute (nclass, "base", type.BaseType.FullName);
 268
 269                         if (type.IsSealed)
 270                                 AddAttribute (nclass, "sealed", "true");
 271
 272                         if (type.IsAbstract)
 273                                 AddAttribute (nclass, "abstract", "true");
 274
 275                         if (type.IsSerializable)
 276                                 AddAttribute (nclass, "serializable", "true");
 277
 278                         string charSet = GetCharSet (type);
 279                         AddAttribute (nclass, "charset", charSet);
 280
 281                         string layout = GetLayout (type);
 282                         if (layout != null)
 283                                 AddAttribute (nclass, "layout", layout);
 284
 285                         parent.AppendChild (nclass);
 286
 287                         AttributeData.OutputAttributes (document, nclass, type.GetCustomAttributes (false));
 288
 289                         Type [] interfaces = type.GetInterfaces ();
 290                         if (interfaces != null && interfaces.Length > 0) {
 291                                 XmlNode ifaces = document.CreateElement ("interfaces", null);
 292                                 nclass.AppendChild (ifaces);
 293                                 foreach (Type t in interfaces) {
 294                                         if (!t.IsPublic) {
 295                                                 // we're only interested in public interfaces
 296                                                 continue;
 297                                         }
 298                                         XmlNode iface = document.CreateElement ("interface", null);
 299                                         AddAttribute (iface, "name", t.FullName);
 300                                         ifaces.AppendChild (iface);
 301                                 }
 302                         }
 303
 304                         ArrayList members = new ArrayList ();
 305
 306                         FieldInfo[] fields = GetFields (type);
 307                         if (fields.Length > 0) {
 308                                 Array.Sort (fields, MemberInfoComparer.Default);
 309                                 FieldData fd = new FieldData (document, nclass, fields);
 310                                 // Special case for enum fields
 311                                 if (classType == "enum") {
 312                                         string etype = fields [0].GetType ().FullName;
 313                                         AddAttribute (nclass, "enumtype", etype);
 314                                 }
 315                                 members.Add (fd);
 316                         }
 317
 318                         ConstructorInfo [] ctors = GetConstructors (type);
 319                         if (ctors.Length > 0) {
 320                                 Array.Sort (ctors, MemberInfoComparer.Default);
 321                                 members.Add (new ConstructorData (document, nclass, ctors));
 322                         }
 323
 324                         PropertyInfo[] properties = GetProperties (type);
 325                         if (properties.Length > 0) {
 326                                 Array.Sort (properties, MemberInfoComparer.Default);
 327                                 members.Add (new PropertyData (document, nclass, properties));
 328                         }
 329
 330                         EventInfo [] events = GetEvents (type);
 331                         if (events.Length > 0) {
 332                                 Array.Sort (events, MemberInfoComparer.Default);
 333                                 members.Add (new EventData (document, nclass, events));
 334                         }
 335
 336                         MethodInfo [] methods = GetMethods (type);
 337                         if (methods.Length > 0) {
 338                                 Array.Sort (methods, MemberInfoComparer.Default);
 339                                 members.Add (new MethodData (document, nclass, methods));
 340                         }
 341
 342                         foreach (MemberData md in members)
 343                                 md.DoOutput ();
 344
 345                         Type [] nested = type.GetNestedTypes ();
 346                         if (nested != null && nested.Length > 0) {
 347                                 XmlNode classes = document.CreateElement ("classes", null);
 348                                 nclass.AppendChild (classes);
 349                                 foreach (Type t in nested) {
 350                                         TypeData td = new TypeData (document, classes, t);
 351                                         td.DoOutput ();
 352                                 }
 353                         }
 354                 }
 355
 356                 protected override string GetMemberAttributes (MemberInfo member)
 357                 {
 358                         if (member != type)
 359                                 throw new InvalidOperationException ("odd");
 360
 361                         return ((int) type.Attributes).ToString (CultureInfo.InvariantCulture);
 362                 }
 363
 364                 public static bool MustDocumentMethod(MethodBase method)
 365                 {
 366                         // All other methods
 367                         return (method.IsPublic || method.IsFamily || method.IsFamilyOrAssembly);
 368                 }
 369
 370                 static string GetClassType (Type t)
 371                 {
 372                         if (t.IsEnum)
 373                                 return "enum";
 374
 375                         if (t.IsValueType)
 376                                 return "struct";
 377
 378                         if (t.IsInterface)
 379                                 return "interface";
 380
 381                         if (typeof (Delegate).IsAssignableFrom (t))
 382                                 return "delegate";
 383
 384                         return "class";
 385                 }
 386
 387                 private static string GetCharSet (Type type)
 388                 {
 389                         if (type.IsAnsiClass)
 390                                 return CharSet.Ansi.ToString (CultureInfo.InvariantCulture);
 391
 392                         if (type.IsAutoClass)
 393                                 return CharSet.Auto.ToString (CultureInfo.InvariantCulture);
 394
 395                         if (type.IsUnicodeClass)
 396                                 return CharSet.Unicode.ToString (CultureInfo.InvariantCulture);
 397
 398                         return CharSet.None.ToString (CultureInfo.InvariantCulture);
 399                 }
 400
 401                 private static string GetLayout (Type type)
 402                 {
 403                         if (type.IsAutoLayout)
 404                                 return LayoutKind.Auto.ToString (CultureInfo.InvariantCulture);
 405
 406                         if (type.IsExplicitLayout)
 407                                 return LayoutKind.Explicit.ToString (CultureInfo.InvariantCulture);
 408
 409                         if (type.IsLayoutSequential)
 410                                 return LayoutKind.Sequential.ToString (CultureInfo.InvariantCulture);
 411
 412                         return null;
 413                 }
 414
 415                 private FieldInfo[] GetFields (Type type)
 416                 {
 417                         ArrayList list = new ArrayList ();
 418
 419                         FieldInfo[] fields = type.GetFields (flags);
 420                         foreach (FieldInfo field in fields) {
 421                                 if (field.IsSpecialName)
 422                                         continue;
 423
 424                                 // we're only interested in public or protected members
 425                                 if (!field.IsPublic && !field.IsFamily && !field.IsFamilyOrAssembly)
 426                                         continue;
 427
 428                                 list.Add (field);
 429                         }
 430
 431                         return (FieldInfo[]) list.ToArray (typeof (FieldInfo));
 432                 }
 433
 434                 private PropertyInfo[] GetProperties (Type type)
 435                 {
 436                         ArrayList list = new ArrayList ();
 437
 438                         PropertyInfo[] properties = type.GetProperties (flags);
 439                         foreach (PropertyInfo property in properties) {
 440                                 MethodInfo getMethod = null;
 441                                 MethodInfo setMethod = null;
 442
 443                                 if (property.CanRead) {
 444                                         try { getMethod = property.GetGetMethod (true); }
 445                                         catch (System.Security.SecurityException) { }
 446                                 }
 447                                 if (property.CanWrite) {
 448                                         try { setMethod = property.GetSetMethod (true); }
 449                                         catch (System.Security.SecurityException) { }
 450                                 }
 451
 452                                 bool hasGetter = (getMethod != null) && MustDocumentMethod (getMethod);
 453                                 bool hasSetter = (setMethod != null) && MustDocumentMethod (setMethod);
 454
 455                                 // if neither the getter or setter should be documented, then
 456                                 // skip the property
 457                                 if (!hasGetter && !hasSetter) {
 458                                         continue;
 459                                 }
 460
 461                                 list.Add (property);
 462                         }
 463
 464                         return (PropertyInfo[]) list.ToArray (typeof (PropertyInfo));
 465                 }
 466
 467                 private MethodInfo[] GetMethods (Type type)
 468                 {
 469                         ArrayList list = new ArrayList ();
 470
 471                         MethodInfo[] methods = type.GetMethods (flags);
 472                         foreach (MethodInfo method in methods) {
 473                                 if (method.IsSpecialName)
 474                                         continue;
 475
 476                                 // we're only interested in public or protected members
 477                                 if (!MustDocumentMethod(method))
 478                                         continue;
 479
 480                                 list.Add (method);
 481                         }
 482
 483                         return (MethodInfo[]) list.ToArray (typeof (MethodInfo));
 484                 }
 485
 486                 private ConstructorInfo[] GetConstructors (Type type)
 487                 {
 488                         ArrayList list = new ArrayList ();
 489
 490                         ConstructorInfo[] ctors = type.GetConstructors (flags);
 491                         foreach (ConstructorInfo constructor in ctors) {
 492                                 // we're only interested in public or protected members
 493                                 if (!constructor.IsPublic && !constructor.IsFamily && !constructor.IsFamilyOrAssembly)
 494                                         continue;
 495
 496                                 list.Add (constructor);
 497                         }
 498
 499                         return (ConstructorInfo[]) list.ToArray (typeof (ConstructorInfo));
 500                 }
 501
 502                 private EventInfo[] GetEvents (Type type)
 503                 {
 504                         ArrayList list = new ArrayList ();
 505
 506                         EventInfo[] events = type.GetEvents (flags);
 507                         foreach (EventInfo eventInfo in events) {
 508                                 MethodInfo addMethod = eventInfo.GetAddMethod (true);
 509
 510                                 if (addMethod == null || !MustDocumentMethod (addMethod))
 511                                         continue;
 512
 513                                 list.Add (eventInfo);
 514                         }
 515
 516                         return (EventInfo[]) list.ToArray (typeof (EventInfo));
 517                 }
 518         }
 519
 520         class FieldData : MemberData
 521         {
 522                 public FieldData (XmlDocument document, XmlNode parent, FieldInfo [] members)
 523                         : base (document, parent, members)
 524                 {
 525                 }
 526
 527                 protected override string GetName (MemberInfo member)
 528                 {
 529                         FieldInfo field = (FieldInfo) member;
 530                         return field.Name;
 531                 }
 532
 533                 protected override string GetMemberAttributes (MemberInfo member)
 534                 {
 535                         FieldInfo field = (FieldInfo) member;
 536                         return ((int) field.Attributes).ToString (CultureInfo.InvariantCulture);
 537                 }
 538
 539                 protected override void AddExtraData (XmlNode p, MemberInfo member)
 540                 {
 541                         base.AddExtraData (p, member);
 542                         FieldInfo field = (FieldInfo) member;
 543                         AddAttribute (p, "fieldtype", field.FieldType.FullName);
 544
 545                         if (field.IsLiteral) {
 546                                 object value = field.GetValue (null);
 547                                 string stringValue = null;
 548                                 if (value is Enum) {
 549                                         // FIXME: when Mono bug #60090 has been
 550                                         // fixed, we should just be able to use
 551                                         // Convert.ToString
 552                                         stringValue = ((Enum) value).ToString ("D", CultureInfo.InvariantCulture);
 553                                 } else {
 554                                         stringValue = Convert.ToString (value, CultureInfo.InvariantCulture);
 555                                 }
 556
 557                                 if (stringValue != null)
 558                                         AddAttribute (p, "value", stringValue);
 559                         }
 560                 }
 561
 562                 public override string ParentTag {
 563                         get { return "fields"; }
 564                 }
 565
 566                 public override string Tag {
 567                         get { return "field"; }
 568                 }
 569         }
 570
 571         class PropertyData : MemberData
 572         {
 573                 public PropertyData (XmlDocument document, XmlNode parent, PropertyInfo [] members)
 574                         : base (document, parent, members)
 575                 {
 576                 }
 577
 578                 protected override string GetName (MemberInfo member)
 579                 {
 580                         PropertyInfo prop = (PropertyInfo) member;
 581                         return prop.Name;
 582                 }
 583
 584                 protected override void AddExtraData (XmlNode p, MemberInfo member)
 585                 {
 586                         base.AddExtraData (p, member);
 587                         PropertyInfo prop = (PropertyInfo) member;
 588                         AddAttribute (p, "ptype", prop.PropertyType.FullName);
 589                         MethodInfo _get = prop.GetGetMethod (true);
 590                         MethodInfo _set = prop.GetSetMethod (true);
 591                         bool haveGet = (_get != null && TypeData.MustDocumentMethod(_get));
 592                         bool haveSet = (_set != null && TypeData.MustDocumentMethod(_set));
 593                         MethodInfo [] methods;
 594
 595                         if (haveGet && haveSet) {
 596                                 methods = new MethodInfo [] {_get, _set};
 597                         } else if (haveGet) {
 598                                 methods = new MethodInfo [] {_get};
 599                         } else if (haveSet) {
 600                                 methods = new MethodInfo [] {_set};
 601                         } else {
 602                                 //odd
 603                                 return;
 604                         }
 605
 606                         string parms = Parameters.GetSignature (methods [0].GetParameters ());
 607                         AddAttribute (p, "params", parms);
 608
 609                         MethodData data = new MethodData (document, p, methods);
 610                         data.NoMemberAttributes = true;
 611                         data.DoOutput ();
 612                 }
 613
 614                 protected override string GetMemberAttributes (MemberInfo member)
 615                 {
 616                         PropertyInfo prop = (PropertyInfo) member;
 617                         return ((int) prop.Attributes).ToString (CultureInfo.InvariantCulture);
 618                 }
 619
 620                 public override string ParentTag {
 621                         get { return "properties"; }
 622                 }
 623
 624                 public override string Tag {
 625                         get { return "property"; }
 626                 }
 627         }
 628
 629         class EventData : MemberData
 630         {
 631                 public EventData (XmlDocument document, XmlNode parent, EventInfo [] members)
 632                         : base (document, parent, members)
 633                 {
 634                 }
 635
 636                 protected override string GetName (MemberInfo member)
 637                 {
 638                         EventInfo evt = (EventInfo) member;
 639                         return evt.Name;
 640                 }
 641
 642                 protected override string GetMemberAttributes (MemberInfo member)
 643                 {
 644                         EventInfo evt = (EventInfo) member;
 645                         return ((int) evt.Attributes).ToString (CultureInfo.InvariantCulture);
 646                 }
 647
 648                 protected override void AddExtraData (XmlNode p, MemberInfo member)
 649                 {
 650                         base.AddExtraData (p, member);
 651                         EventInfo evt = (EventInfo) member;
 652                         AddAttribute (p, "eventtype", evt.EventHandlerType.FullName);
 653                 }
 654
 655                 public override string ParentTag {
 656                         get { return "events"; }
 657                 }
 658
 659                 public override string Tag {
 660                         get { return "event"; }
 661                 }
 662         }
 663
 664         class MethodData : MemberData
 665         {
 666                 bool noAtts;
 667
 668                 public MethodData (XmlDocument document, XmlNode parent, MethodBase [] members)
 669                         : base (document, parent, members)
 670                 {
 671                 }
 672
 673                 protected override string GetName (MemberInfo member)
 674                 {
 675                         MethodBase method = (MethodBase) member;
 676                         string name = method.Name;
 677                         string parms = Parameters.GetSignature (method.GetParameters ());
 678                         return String.Format ("{0}({1})", name, parms);
 679                 }
 680
 681                 protected override string GetMemberAttributes (MemberInfo member)
 682                 {
 683                         MethodBase method = (MethodBase) member;
 684                         return ((int) method.Attributes).ToString (CultureInfo.InvariantCulture);
 685                 }
 686
 687                 protected override void AddExtraData (XmlNode p, MemberInfo member)
 688                 {
 689                         base.AddExtraData (p, member);
 690
 691                         ParameterData parms = new ParameterData (document, p,
 692                                 ((MethodBase) member).GetParameters ());
 693                         parms.DoOutput ();
 694
 695                         if (!(member is MethodInfo))
 696                                 return;
 697
 698                         MethodInfo method = (MethodInfo) member;
 699                         AddAttribute (p, "returntype", method.ReturnType.FullName);
 700
 701                         AttributeData.OutputAttributes (document, p,
 702                                 method.ReturnTypeCustomAttributes.GetCustomAttributes (false));
 703                 }
 704
 705                 public override bool NoMemberAttributes {
 706                         get { return noAtts; }
 707                         set { noAtts = value; }
 708                 }
 709
 710                 public override string ParentTag {
 711                         get { return "methods"; }
 712                 }
 713
 714                 public override string Tag {
 715                         get { return "method"; }
 716                 }
 717         }
 718
 719         class ConstructorData : MethodData
 720         {
 721                 public ConstructorData (XmlDocument document, XmlNode parent, ConstructorInfo [] members)
 722                         : base (document, parent, members)
 723                 {
 724                 }
 725
 726                 public override string ParentTag {
 727                         get { return "constructors"; }
 728                 }
 729
 730                 public override string Tag {
 731                         get { return "constructor"; }
 732                 }
 733         }
 734
 735         class ParameterData : BaseData
 736         {
 737                 private ParameterInfo[] parameters;
 738
 739                 public ParameterData (XmlDocument document, XmlNode parent, ParameterInfo[] parameters)
 740                         : base (document, parent)
 741                 {
 742                         this.parameters = parameters;
 743                 }
 744
 745                 public override void DoOutput ()
 746                 {
 747                         XmlNode parametersNode = document.CreateElement ("parameters", null);
 748                         parent.AppendChild (parametersNode);
 749
 750                         foreach (ParameterInfo parameter in parameters) {
 751                                 XmlNode paramNode = document.CreateElement ("parameter", null);
 752                                 parametersNode.AppendChild (paramNode);
 753                                 AddAttribute (paramNode, "name", parameter.Name);
 754                                 AddAttribute (paramNode, "position", parameter.Position.ToString(CultureInfo.InvariantCulture));
 755                                 AddAttribute (paramNode, "attrib", ((int) parameter.Attributes).ToString());
 756
 757                                 string direction = "in";
 758
 759                                 if (parameter.ParameterType.IsByRef) {
 760                                         direction = parameter.IsOut ? "out" : "ref";
 761                                 }
 762
 763                                 Type t = parameter.ParameterType;
 764                                 AddAttribute (paramNode, "type", t.FullName);
 765
 766                                 if (parameter.IsOptional) {
 767                                         AddAttribute (paramNode, "optional", "true");
 768                                         if (parameter.DefaultValue != null)
 769                                                 AddAttribute (paramNode, "defaultValue", parameter.DefaultValue.ToString ());
 770                                 }
 771
 772                                 if (direction != "in")
 773                                         AddAttribute (paramNode, "direction", direction);
 774
 775                                 AttributeData.OutputAttributes (document, paramNode, parameter.GetCustomAttributes (false));
 776                         }
 777                 }
 778         }
 779
 780         class AttributeData : BaseData
 781         {
 782                 object [] atts;
 783                 string target;
 784
 785                 AttributeData (XmlDocument doc, XmlNode parent, object[] attributes, string target)
 786                         : base (doc, parent)
 787                 {
 788                         atts = attributes;
 789                         this.target = target;
 790                 }
 791
 792                 AttributeData (XmlDocument doc, XmlNode parent, object [] attributes)
 793                         : this (doc, parent, attributes, null)
 794                 {
 795                 }
 796
 797                 public override void DoOutput ()
 798                 {
 799                         if (document == null)
 800                                 throw new InvalidOperationException ("Document not set");
 801
 802                         if (atts == null || atts.Length == 0)
 803                                 return;
 804
 805                         XmlNode natts = parent.SelectSingleNode("attributes");
 806                         if (natts == null) {
 807                                 natts = document.CreateElement ("attributes", null);
 808                                 parent.AppendChild (natts);
 809                         }
 810
 811                         ArrayList typeList = new ArrayList (atts.Length);
 812                         string comment = null;
 813                         for (int i = atts.Length - 1; i >= 0; i--) {
 814                                 Type attType = atts [i].GetType ();
 815                                 if (!MustDocumentAttribute (attType))
 816                                         continue;
 817                                 typeList.Add (attType);
 818                                 if (attType.Name.EndsWith ("TODOAttribute")) {
 819                                         PropertyInfo prop = attType.GetProperty ("Comment");
 820                                         if (prop != null)
 821                                                 comment = (string) prop.GetValue (atts [i], null);
 822                                 }
 823                         }
 824
 825                         Type[] types = (Type[]) typeList.ToArray (typeof (Type));
 826                         Array.Sort (types, TypeComparer.Default);
 827                         foreach (Type t in types) {
 828                                 XmlNode node = document.CreateElement ("attribute");
 829                                 AddAttribute (node, "name", t.FullName);
 830                                 if (target != null) {
 831                                         AddAttribute (node, "target", target);
 832                                 }
 833                                 if (comment != null && t.Name.EndsWith ("TODOAttribute"))
 834                                         AddAttribute (node, "comment", comment);
 835
 836                                 natts.AppendChild (node);
 837                         }
 838                 }
 839
 840                 public static void OutputAttributes (XmlDocument doc, XmlNode parent, object[] attributes)
 841                 {
 842                         AttributeData ad = new AttributeData (doc, parent, attributes, null);
 843                         ad.DoOutput ();
 844                 }
 845
 846                 public static void OutputAttributes (XmlDocument doc, XmlNode parent, object [] attributes, string target)
 847                 {
 848                         AttributeData ad = new AttributeData (doc, parent, attributes, target);
 849                         ad.DoOutput ();
 850                 }
 851
 852                 private static bool MustDocumentAttribute (Type attributeType)
 853                 {
 854                         // only document MonoTODOAttribute and public attributes
 855                         return attributeType.Name.EndsWith ("TODOAttribute") || attributeType.IsPublic;
 856                 }
 857         }
 858
 859         class Parameters
 860         {
 861                 private Parameters () {}
 862
 863                 public static string GetSignature (ParameterInfo [] infos)
 864                 {
 865                         if (infos == null || infos.Length == 0)
 866                                 return "";
 867
 868                         StringBuilder sb = new StringBuilder ();
 869                         foreach (ParameterInfo info in infos) {
 870                                 string modifier;
 871                                 if (info.IsIn)
 872                                         modifier = "in ";
 873                                 else if (info.IsRetval)
 874                                         modifier = "ref ";
 875                                 else if (info.IsOut)
 876                                         modifier = "out ";
 877                                 else
 878                                         modifier = "";
 879
 880                                 string type_name = info.ParameterType.ToString ();
 881                                 sb.AppendFormat ("{0}{1}, ", modifier, type_name);
 882                         }
 883
 884                         sb.Length -= 2; // remove ", "
 885                         return sb.ToString ();
 886                 }
 887
 888         }
 889
 890         class TypeComparer : IComparer
 891         {
 892                 public static TypeComparer Default = new TypeComparer ();
 893
 894                 public int Compare (object a, object b)
 895                 {
 896                         Type ta = (Type) a;
 897                         Type tb = (Type) b;
 898                         int result = String.Compare (ta.Namespace, tb.Namespace);
 899                         if (result != 0)
 900                                 return result;
 901
 902                         return String.Compare (ta.Name, tb.Name);
 903                 }
 904         }
 905
 906         class MemberInfoComparer : IComparer
 907         {
 908                 public static MemberInfoComparer Default = new MemberInfoComparer ();
 909
 910                 public int Compare (object a, object b)
 911                 {
 912                         MemberInfo ma = (MemberInfo) a;
 913                         MemberInfo mb = (MemberInfo) b;
 914                         return String.Compare (ma.Name, mb.Name);
 915                 }
 916         }
 917
 918         class MethodBaseComparer : IComparer
 919         {
 920                 public static MethodBaseComparer Default = new MethodBaseComparer ();
 921
 922                 public int Compare (object a, object b)
 923                 {
 924                         MethodBase ma = (MethodBase) a;
 925                         MethodBase mb = (MethodBase) b;
 926                         int res = String.Compare (ma.Name, mb.Name);
 927                         if (res != 0)
 928                                 return res;
 929
 930                         ParameterInfo [] pia = ma.GetParameters ();
 931                         ParameterInfo [] pib = mb.GetParameters ();
 932                         if (pia.Length != pib.Length)
 933                                 return pia.Length - pib.Length;
 934
 935                         string siga = Parameters.GetSignature (pia);
 936                         string sigb = Parameters.GetSignature (pib);
 937                         return String.Compare (siga, sigb);
 938                 }
 939         }
 940 }
 941