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 // Copyright (C) 2003-2008 Novell, Inc (http://www.novell.com)
   8 //
   9
  10 using System;
  11 using System.Collections;
  12 using System.Collections.Generic;
  13 using System.Globalization;
  14 using System.Linq;
  15 using System.Runtime.CompilerServices;
  16 using System.Runtime.InteropServices;
  17 using System.Security.Permissions;
  18 using System.Text;
  19 using System.Xml;
  20
  21 using Mono.Cecil;
  22 using Mono.Cecil.Cil;
  23 using System.IO;
  24
  25 namespace Mono.ApiTools {
  26
  27 #if !EXCLUDE_DRIVER
  28         class Driver
  29         {
  30                 public static int Main (string [] args)
  31                 {
  32                         bool showHelp = false;
  33                         string output = null;
  34                         List<string> asms = null;
  35                         ApiInfoConfig config = new ApiInfoConfig ();
  36
  37                         var options = new Mono.Options.OptionSet {
  38                                 { "abi",
  39                                         "Generate ABI, not API; contains only classes with instance fields which are not [NonSerialized].",
  40                                         v => config.AbiMode = v != null },
  41                                 { "f|follow-forwarders",
  42                                         "Follow type forwarders.",
  43                                         v => config.FollowForwarders = v != null },
  44                                 { "ignore-inherited-interfaces",
  45                                         "Ignore interfaces on the base type.",
  46                                         v => config.IgnoreInheritedInterfaces = v != null },
  47                                 { "ignore-resolution-errors",
  48                                         "Ignore any assemblies that cannot be found.",
  49                                         v => config.IgnoreResolutionErrors = v != null },
  50                                 { "d|L|lib|search-directory=",
  51                                         "Check for assembly references in {DIRECTORY}.",
  52                                         v => config.SearchDirectories.Add (v) },
  53                                 { "r=",
  54                                         "Read and register the file {ASSEMBLY}, and add the directory containing ASSEMBLY to the search path.",
  55                                         v => config.ResolveFiles.Add (v) },
  56                                 { "o|out|output=",
  57                                         "The output file. If not specified the output will be written to stdout.",
  58                                         v => output = v },
  59                                 { "h|?|help",
  60                                         "Show this message and exit.",
  61                                         v => showHelp = v != null },
  62                                 { "contract-api",
  63                                         "Produces contract API with all members at each level of inheritance hierarchy",
  64                                         v => config.FullApiSet = v != null },
  65                         };
  66
  67                         try {
  68                                 asms = options.Parse (args);
  69                         } catch (Mono.Options.OptionException e) {
  70                                 Console.WriteLine ("Option error: {0}", e.Message);
  71                                 asms = null;
  72                         }
  73
  74                         if (showHelp || asms == null || asms.Count == 0) {
  75                                 Console.WriteLine ("usage: mono-api-info [OPTIONS+] ASSEMBLY+");
  76                                 Console.WriteLine ();
  77                                 Console.WriteLine ("Expose IL structure of CLR assemblies as XML.");
  78                                 Console.WriteLine ();
  79                                 Console.WriteLine ("Available Options:");
  80                                 Console.WriteLine ();
  81                                 options.WriteOptionDescriptions (Console.Out);
  82                                 Console.WriteLine ();
  83                                 return showHelp ? 0 : 1;
  84                         }
  85
  86                         TextWriter outputStream = null;
  87                         try {
  88                                 if (!string.IsNullOrEmpty (output))
  89                                         outputStream = new StreamWriter (output);
  90
  91                                 ApiInfo.Generate (asms, null, outputStream ?? Console.Out, config);
  92                         } catch (Exception e) {
  93                                 Console.Error.WriteLine (e);
  94                                 return 1;
  95                         } finally {
  96                                 outputStream?.Dispose ();
  97                         }
  98                         return 0;
  99                 }
 100         }
 101 #endif
 102
 103         class State
 104         {
 105                 public bool AbiMode { get; set; } = false;
 106
 107                 public bool FollowForwarders { get; set; } = false;
 108
 109                 public bool FullApiSet { get; set; } = false;
 110
 111                 public bool IgnoreResolutionErrors { get; set; } = false;
 112
 113                 public bool IgnoreInheritedInterfaces { get; set; } = false;
 114
 115                 public List<string> SearchDirectories { get; } = new List<string> ();
 116
 117                 public List<string> ResolveFiles { get; } = new List<string> ();
 118
 119                 public List<Stream> ResolveStreams { get; } = new List<Stream> ();
 120
 121                 public TypeHelper TypeHelper { get; private set; }
 122
 123                 public void ResolveTypes ()
 124                 {
 125                         TypeHelper = new TypeHelper (IgnoreResolutionErrors, IgnoreInheritedInterfaces);
 126
 127                         if (SearchDirectories != null) {
 128                                 foreach (var v in SearchDirectories)
 129                                         TypeHelper.Resolver.AddSearchDirectory (v);
 130                         }
 131                         if (ResolveFiles != null) {
 132                                 foreach (var v in ResolveFiles)
 133                                         TypeHelper.Resolver.ResolveFile (v);
 134                         }
 135                         if (ResolveStreams != null) {
 136                                 foreach (var v in ResolveStreams)
 137                                         TypeHelper.Resolver.ResolveStream (v);
 138                         }
 139                 }
 140         }
 141
 142         public class ApiInfoConfig
 143         {
 144                 public bool AbiMode { get; set; } = false;
 145
 146                 public bool FollowForwarders { get; set; } = false;
 147
 148                 public bool FullApiSet { get; set; } = false;
 149
 150                 public bool IgnoreResolutionErrors { get; set; } = false;
 151
 152                 public bool IgnoreInheritedInterfaces { get; set; } = false;
 153
 154                 public List<string> SearchDirectories { get; set; } = new List<string> ();
 155
 156                 public List<string> ResolveFiles { get; set; } = new List<string> ();
 157
 158                 public List<Stream> ResolveStreams { get; set; } = new List<Stream> ();
 159         }
 160
 161         public static class ApiInfo
 162         {
 163                 public static void Generate (string assemblyPath, TextWriter outStream, ApiInfoConfig config = null)
 164                 {
 165                         if (assemblyPath == null)
 166                                 throw new ArgumentNullException (nameof (assemblyPath));
 167
 168                         Generate (new [] { assemblyPath }, null, outStream, config);
 169                 }
 170
 171                 public static void Generate (Stream assemblyStream, TextWriter outStream, ApiInfoConfig config = null)
 172                 {
 173                         if (assemblyStream == null)
 174                                 throw new ArgumentNullException (nameof (assemblyStream));
 175
 176                         Generate (null, new [] { assemblyStream }, outStream, config);
 177                 }
 178
 179                 public static void Generate (IEnumerable<string> assemblyPaths, TextWriter outStream, ApiInfoConfig config = null)
 180                 {
 181                         Generate (assemblyPaths, null, outStream, config);
 182                 }
 183
 184                 public static void Generate (IEnumerable<Stream> assemblyStreams, TextWriter outStream, ApiInfoConfig config = null)
 185                 {
 186                         Generate (null, assemblyStreams, outStream, config);
 187                 }
 188
 189                 public static void Generate (IEnumerable<string> assemblyPaths, IEnumerable<Stream> assemblyStreams, TextWriter outStream, ApiInfoConfig config = null)
 190                 {
 191                         if (outStream == null)
 192                                 throw new ArgumentNullException (nameof (outStream));
 193
 194                         if (config == null)
 195                                 config = new ApiInfoConfig ();
 196
 197                         var state = new State {
 198                                 AbiMode = config.AbiMode,
 199                                 FollowForwarders = config.FollowForwarders,
 200                                 FullApiSet = config.FullApiSet,
 201                                 IgnoreResolutionErrors = config.IgnoreResolutionErrors,
 202                                 IgnoreInheritedInterfaces = config.IgnoreInheritedInterfaces,
 203                         };
 204                         state.SearchDirectories.AddRange (config.SearchDirectories);
 205                         state.ResolveFiles.AddRange (config.ResolveFiles);
 206                         state.ResolveStreams.AddRange (config.ResolveStreams);
 207
 208                         Generate (assemblyPaths, assemblyStreams, outStream, state);
 209                 }
 210
 211                 internal static void Generate (IEnumerable<string> assemblyFiles, IEnumerable<Stream> assemblyStreams, TextWriter outStream, State state = null)
 212                 {
 213                         if (outStream == null)
 214                                 throw new ArgumentNullException (nameof (outStream));
 215
 216                         if (state == null)
 217                                 state = new State ();
 218
 219                         state.ResolveTypes ();
 220
 221                         string windir = Environment.GetFolderPath (Environment.SpecialFolder.Windows);
 222                         string pf = Environment.GetFolderPath (Environment.SpecialFolder.ProgramFiles);
 223                         state.TypeHelper.Resolver.AddSearchDirectory (Path.Combine (windir, @"assembly\GAC\MSDATASRC\7.0.3300.0__b03f5f7f11d50a3a"));
 224
 225                         var acoll = new AssemblyCollection (state);
 226                         if (assemblyFiles != null) {
 227                                 foreach (string arg in assemblyFiles) {
 228                                         acoll.Add (arg);
 229
 230                                         if (arg.Contains ("v3.0")) {
 231                                                 state.TypeHelper.Resolver.AddSearchDirectory (Path.Combine (windir, @"Microsoft.NET\Framework\v2.0.50727"));
 232                                         } else if (arg.Contains ("v3.5")) {
 233                                                 state.TypeHelper.Resolver.AddSearchDirectory (Path.Combine (windir, @"Microsoft.NET\Framework\v2.0.50727"));
 234                                                 state.TypeHelper.Resolver.AddSearchDirectory (Path.Combine (windir, @"Microsoft.NET\Framework\v3.0\Windows Communication Foundation"));
 235                                         } else if (arg.Contains ("v4.0")) {
 236                                                 if (arg.Contains ("Silverlight")) {
 237                                                         state.TypeHelper.Resolver.AddSearchDirectory (Path.Combine (pf, @"Microsoft Silverlight\4.0.51204.0"));
 238                                                 } else {
 239                                                         state.TypeHelper.Resolver.AddSearchDirectory (Path.Combine (windir, @"Microsoft.NET\Framework\v4.0.30319"));
 240                                                         state.TypeHelper.Resolver.AddSearchDirectory (Path.Combine (windir, @"Microsoft.NET\Framework\v4.0.30319\WPF"));
 241                                                 }
 242                                         } else {
 243                                                 state.TypeHelper.Resolver.AddSearchDirectory (Path.GetDirectoryName (arg));
 244                                         }
 245                                 }
 246                         }
 247                         if (assemblyStreams != null) {
 248                                 foreach (var arg in assemblyStreams) {
 249                                         acoll.Add (arg);
 250                                 }
 251                         }
 252
 253                         var settings = new XmlWriterSettings {
 254                                 Indent = true,
 255                         };
 256                         using (var textWriter = XmlWriter.Create (outStream, settings)) {
 257                                 var writer = new WellFormedXmlWriter (textWriter);
 258                                 writer.WriteStartDocument ();
 259                                 acoll.Writer = writer;
 260                                 acoll.DoOutput ();
 261                                 writer.WriteEndDocument ();
 262                                 writer.Flush ();
 263                         }
 264                 }
 265         }
 266
 267         class Utils {
 268                 static char[] CharsToCleanup = new char[] { '<', '>', '/' };
 269
 270                 public static string CleanupTypeName (TypeReference type)
 271                 {
 272                         return CleanupTypeName (type.FullName);
 273                 }
 274
 275                 public static string CleanupTypeName (string t)
 276                 {
 277                         if (t.IndexOfAny (CharsToCleanup) == -1)
 278                                 return t;
 279                         var sb = new StringBuilder (t.Length);
 280                         for (int i = 0; i < t.Length; i++) {
 281                                 var ch = t [i];
 282                                 switch (ch) {
 283                                 case '<':
 284                                         sb.Append ('[');
 285                                         break;
 286                                 case '>':
 287                                         sb.Append (']');
 288                                         break;
 289                                 case '/':
 290                                         sb.Append ('+');
 291                                         break;
 292                                 default:
 293                                         sb.Append (ch);
 294                                         break;
 295                                 }
 296                         }
 297                         return sb.ToString ();
 298                 }
 299         }
 300
 301         class AssemblyCollection
 302         {
 303                 XmlWriter writer;
 304                 List<AssemblyDefinition> assemblies = new List<AssemblyDefinition> ();
 305                 State state;
 306
 307                 public AssemblyCollection (State state)
 308                 {
 309                         this.state = state;
 310                 }
 311
 312                 public bool Add (string name)
 313                 {
 314                         AssemblyDefinition ass = LoadAssembly (name);
 315                         assemblies.Add (ass);
 316                         return true;
 317                 }
 318
 319                 public bool Add (Stream stream)
 320                 {
 321                         AssemblyDefinition ass = LoadAssembly (stream);
 322                         assemblies.Add (ass);
 323                         return true;
 324                 }
 325
 326                 public void DoOutput ()
 327                 {
 328                         if (writer == null)
 329                                 throw new InvalidOperationException ("Document not set");
 330
 331                         writer.WriteStartElement ("assemblies");
 332                         foreach (AssemblyDefinition a in assemblies) {
 333                                 AssemblyData data = new AssemblyData (writer, a, state);
 334                                 data.DoOutput ();
 335                         }
 336                         writer.WriteEndElement ();
 337                 }
 338
 339                 public XmlWriter Writer {
 340                         set { writer = value; }
 341                 }
 342
 343                 AssemblyDefinition LoadAssembly (string assembly)
 344                 {
 345                         if (File.Exists (assembly))
 346                                 return state.TypeHelper.Resolver.ResolveFile (assembly);
 347
 348                         return state.TypeHelper.Resolver.Resolve (AssemblyNameReference.Parse (assembly), new ReaderParameters ());
 349                 }
 350
 351                 AssemblyDefinition LoadAssembly (Stream assembly)
 352                 {
 353                         return state.TypeHelper.Resolver.ResolveStream (assembly);
 354                 }
 355         }
 356
 357         abstract class BaseData
 358         {
 359                 protected XmlWriter writer;
 360                 protected State state;
 361
 362                 protected BaseData (XmlWriter writer, State state)
 363                 {
 364                         this.writer = writer;
 365                         this.state = state;
 366                 }
 367
 368                 public abstract void DoOutput ();
 369
 370                 protected void AddAttribute (string name, string value)
 371                 {
 372                         writer.WriteAttributeString (name, value);
 373                 }
 374         }
 375
 376         class TypeForwardedToData : BaseData
 377         {
 378                 AssemblyDefinition ass;
 379
 380                 public TypeForwardedToData (XmlWriter writer, AssemblyDefinition ass, State state)
 381                         : base (writer, state)
 382                 {
 383                         this.ass = ass;
 384                 }
 385
 386                 public override void DoOutput ()
 387                 {
 388                         foreach (ExportedType type in ass.MainModule.ExportedTypes) {
 389
 390                                 if (((uint)type.Attributes & 0x200000u) == 0)
 391                                         continue;
 392
 393                                 writer.WriteStartElement ("attribute");
 394                                 AddAttribute ("name", typeof (TypeForwardedToAttribute).FullName);
 395                                 writer.WriteStartElement ("properties");
 396                                 writer.WriteStartElement ("property");
 397                                 AddAttribute ("name", "Destination");
 398                                 AddAttribute ("value", Utils.CleanupTypeName (type.FullName));
 399                                 writer.WriteEndElement (); // properties
 400                                 writer.WriteEndElement (); // properties
 401                                 writer.WriteEndElement (); // attribute
 402                         }
 403                 }
 404
 405                 public static void OutputForwarders (XmlWriter writer, AssemblyDefinition ass, State state)
 406                 {
 407                         TypeForwardedToData tftd = new TypeForwardedToData (writer, ass, state);
 408                         tftd.DoOutput ();
 409                 }
 410         }
 411
 412         class AssemblyData : BaseData
 413         {
 414                 AssemblyDefinition ass;
 415
 416                 public AssemblyData (XmlWriter writer, AssemblyDefinition ass, State state)
 417                         : base (writer, state)
 418                 {
 419                         this.ass = ass;
 420                 }
 421
 422                 public override void DoOutput ()
 423                 {
 424                         if (writer == null)
 425                                 throw new InvalidOperationException ("Document not set");
 426
 427                         writer.WriteStartElement ("assembly");
 428                         AssemblyNameDefinition aname = ass.Name;
 429                         AddAttribute ("name", aname.Name);
 430                         AddAttribute ("version", aname.Version.ToString ());
 431
 432                         AttributeData.OutputAttributes (writer, state, ass);
 433
 434                         var types = new List<TypeDefinition> ();
 435                         if (ass.MainModule.Types != null) {
 436                                 types.AddRange (ass.MainModule.Types);
 437                         }
 438
 439                         if (state.FollowForwarders && ass.MainModule.ExportedTypes != null) {
 440                                 foreach (var t in ass.MainModule.ExportedTypes) {
 441                                         var forwarded = t.Resolve ();
 442                                         if (forwarded == null) {
 443                                                 throw new Exception ("Could not resolve forwarded type " + t.FullName + " in " + ass.Name);
 444                                         }
 445                                         types.Add (forwarded);
 446                                 }
 447                         }
 448
 449                         if (types.Count == 0) {
 450                                 writer.WriteEndElement (); // assembly
 451                                 return;
 452                         }
 453
 454                         types.Sort (TypeReferenceComparer.Default);
 455
 456                         writer.WriteStartElement ("namespaces");
 457
 458                         string current_namespace = "$%&$&";
 459                         bool in_namespace = false;
 460                         foreach (TypeDefinition t in types) {
 461                                 if (string.IsNullOrEmpty (t.Namespace))
 462                                         continue;
 463
 464                                 if (!state.AbiMode && ((t.Attributes & TypeAttributes.VisibilityMask) != TypeAttributes.Public))
 465                                         continue;
 466
 467                                 if (t.DeclaringType != null)
 468                                         continue; // enforce !nested
 469
 470                                 if (t.Namespace != current_namespace) {
 471                                         current_namespace = t.Namespace;
 472                                         if (in_namespace) {
 473                                                 writer.WriteEndElement (); // classes
 474                                                 writer.WriteEndElement (); // namespace
 475                                         } else {
 476                                                 in_namespace = true;
 477                                         }
 478                                         writer.WriteStartElement ("namespace");
 479                                         AddAttribute ("name", current_namespace);
 480                                         writer.WriteStartElement ("classes");
 481                                 }
 482
 483                                 TypeData bd = new TypeData (writer, t, state);
 484                                 bd.DoOutput ();
 485
 486                         }
 487
 488                         if (in_namespace) {
 489                                 writer.WriteEndElement (); // classes
 490                                 writer.WriteEndElement (); // namespace
 491                         }
 492
 493                         writer.WriteEndElement (); // namespaces
 494
 495                         writer.WriteEndElement (); // assembly
 496                 }
 497         }
 498
 499         abstract class MemberData : BaseData
 500         {
 501                 MemberReference [] members;
 502
 503                 public MemberData (XmlWriter writer, MemberReference [] members, State state)
 504                         : base (writer, state)
 505                 {
 506                         this.members = members;
 507                 }
 508
 509                 protected virtual ICustomAttributeProvider GetAdditionalCustomAttributeProvider (MemberReference member)
 510                 {
 511                         return null;
 512                 }
 513
 514                 public override void DoOutput ()
 515                 {
 516                         writer.WriteStartElement (ParentTag);
 517
 518                         foreach (MemberReference member in members) {
 519                                 writer.WriteStartElement (Tag);
 520                                 AddAttribute ("name", GetName (member));
 521                                 if (!NoMemberAttributes)
 522                                         AddAttribute ("attrib", GetMemberAttributes (member));
 523                                 AddExtraAttributes (member);
 524
 525                                 AttributeData.OutputAttributes (writer, state, (ICustomAttributeProvider) member, GetAdditionalCustomAttributeProvider (member));
 526
 527                                 AddExtraData (member);
 528                                 writer.WriteEndElement (); // Tag
 529                         }
 530
 531                         writer.WriteEndElement (); // ParentTag
 532                 }
 533
 534                 protected virtual void AddExtraData (MemberReference memberDefenition)
 535                 {
 536                 }
 537
 538                 protected virtual void AddExtraAttributes (MemberReference memberDefinition)
 539                 {
 540                 }
 541
 542                 protected virtual string GetName (MemberReference memberDefenition)
 543                 {
 544                         return "NoNAME";
 545                 }
 546
 547                 protected virtual string GetMemberAttributes (MemberReference memberDefenition)
 548                 {
 549                         return null;
 550                 }
 551
 552                 public virtual bool NoMemberAttributes {
 553                         get { return false; }
 554                         set {}
 555                 }
 556
 557                 public virtual string ParentTag {
 558                         get { return "NoPARENTTAG"; }
 559                 }
 560
 561                 public virtual string Tag {
 562                         get { return "NoTAG"; }
 563                 }
 564
 565                 public static void OutputGenericParameters (XmlWriter writer, IGenericParameterProvider provider, State state)
 566                 {
 567                         if (provider.GenericParameters.Count == 0)
 568                                 return;
 569
 570                         var gparameters = provider.GenericParameters;
 571
 572                         writer.WriteStartElement ("generic-parameters");
 573
 574                         foreach (GenericParameter gp in gparameters) {
 575                                 writer.WriteStartElement ("generic-parameter");
 576                                 writer.WriteAttributeString ("name", gp.Name);
 577                                 writer.WriteAttributeString ("attributes", ((int) gp.Attributes).ToString ());
 578
 579                                 AttributeData.OutputAttributes (writer, state, gp);
 580
 581                                 var constraints = gp.Constraints;
 582                                 if (constraints.Count == 0) {
 583                                         writer.WriteEndElement (); // generic-parameter
 584                                         continue;
 585                                 }
 586
 587                                 writer.WriteStartElement ("generic-parameter-constraints");
 588
 589                                 foreach (GenericParameterConstraint constraint in constraints) {
 590                                         writer.WriteStartElement ("generic-parameter-constraint");
 591                                         writer.WriteAttributeString ("name", Utils.CleanupTypeName (constraint.ConstraintType));
 592                                         writer.WriteEndElement (); // generic-parameter-constraint
 593                                 }
 594
 595                                 writer.WriteEndElement (); // generic-parameter-constraints
 596
 597                                 writer.WriteEndElement (); // generic-parameter
 598                         }
 599
 600                         writer.WriteEndElement (); // generic-parameters
 601                 }
 602         }
 603
 604         class TypeData : MemberData
 605         {
 606                 TypeDefinition type;
 607
 608                 public TypeData (XmlWriter writer, TypeDefinition type, State state)
 609                         : base (writer, null, state)
 610                 {
 611                         this.type = type;
 612                 }
 613                 public override void DoOutput ()
 614                 {
 615                         if (writer == null)
 616                                 throw new InvalidOperationException ("Document not set");
 617
 618                         writer.WriteStartElement ("class");
 619                         AddAttribute ("name", type.Name);
 620                         string classType = GetClassType (type);
 621                         AddAttribute ("type", classType);
 622
 623                         if (type.BaseType != null)
 624                                 AddAttribute ("base", Utils.CleanupTypeName (type.BaseType));
 625
 626                         if (type.IsSealed)
 627                                 AddAttribute ("sealed", "true");
 628
 629                         if (type.IsAbstract)
 630                                 AddAttribute ("abstract", "true");
 631
 632                         if ( (type.Attributes & TypeAttributes.Serializable) != 0 || type.IsEnum)
 633                                 AddAttribute ("serializable", "true");
 634
 635                         string charSet = GetCharSet (type);
 636                         AddAttribute ("charset", charSet);
 637
 638                         string layout = GetLayout (type);
 639                         if (layout != null)
 640                                 AddAttribute ("layout", layout);
 641
 642                         if (type.PackingSize >= 0) {
 643                                 AddAttribute ("pack", type.PackingSize.ToString ());
 644                         }
 645
 646                         if (type.ClassSize >= 0) {
 647                                 AddAttribute ("size", type.ClassSize.ToString ());
 648                         }
 649
 650                         if (type.IsEnum) {
 651                                 var value_type = GetEnumValueField (type);
 652                                 if (value_type == null)
 653                                         throw new NotSupportedException ();
 654
 655                                 AddAttribute ("enumtype", Utils.CleanupTypeName (value_type.FieldType));
 656                         }
 657
 658                         AttributeData.OutputAttributes (writer, state, type);
 659
 660                         var ifaces =  state.TypeHelper.GetInterfaces (type).
 661                                 Where ((iface) => state.TypeHelper.IsPublic (iface)). // we're only interested in public interfaces
 662                                 OrderBy (s => s.FullName, StringComparer.Ordinal);
 663
 664                         if (ifaces.Any ()) {
 665                                 writer.WriteStartElement ("interfaces");
 666                                 foreach (TypeReference iface in ifaces) {
 667                                         writer.WriteStartElement ("interface");
 668                                         AddAttribute ("name", Utils.CleanupTypeName (iface));
 669                                         writer.WriteEndElement (); // interface
 670                                 }
 671                                 writer.WriteEndElement (); // interfaces
 672                         }
 673
 674                         MemberData.OutputGenericParameters (writer, type, state);
 675
 676                         ArrayList members = new ArrayList ();
 677
 678                         FieldDefinition [] fields = GetFields (type);
 679                         if (fields.Length > 0) {
 680                                 Array.Sort (fields, MemberReferenceComparer.Default);
 681                                 FieldData fd = new FieldData (writer, fields, state);
 682                                 members.Add (fd);
 683                         }
 684
 685                         if (!state.AbiMode) {
 686
 687                                 MethodDefinition [] ctors = GetConstructors (type);
 688                                 if (ctors.Length > 0) {
 689                                         Array.Sort (ctors, MethodDefinitionComparer.Default);
 690                                         members.Add (new ConstructorData (writer, ctors, state));
 691                                 }
 692
 693                                 PropertyDefinition[] properties = GetProperties (type, state.FullApiSet);
 694                                 if (properties.Length > 0) {
 695                                         Array.Sort (properties, PropertyDefinitionComparer.Default);
 696                                         members.Add (new PropertyData (writer, properties, state));
 697                                 }
 698
 699                                 EventDefinition [] events = GetEvents (type);
 700                                 if (events.Length > 0) {
 701                                         Array.Sort (events, MemberReferenceComparer.Default);
 702                                         members.Add (new EventData (writer, events, state));
 703                                 }
 704
 705                                 MethodDefinition [] methods = GetMethods (type, state.FullApiSet);
 706                                 if (methods.Length > 0) {
 707                                         Array.Sort (methods, MethodDefinitionComparer.Default);
 708                                         members.Add (new MethodData (writer, methods, state));
 709                                 }
 710                         }
 711
 712                         foreach (MemberData md in members)
 713                                 md.DoOutput ();
 714
 715                         var nested = type.NestedTypes;
 716                         //remove non public(familiy) and nested in second degree
 717                         for (int i = nested.Count - 1; i >= 0; i--) {
 718                                 TypeDefinition t = nested [i];
 719                                 if ((t.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic ||
 720                                         (t.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamily ||
 721                                         (t.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamORAssem) {
 722                                         // public
 723                                         if (t.DeclaringType == type)
 724                                                 continue; // not nested of nested
 725                                 }
 726
 727                                 nested.RemoveAt (i);
 728                         }
 729
 730                         if (nested.Count > 0) {
 731                                 var nestedArray = nested.ToArray ();
 732                                 Array.Sort (nestedArray, TypeReferenceComparer.Default);
 733
 734                                 writer.WriteStartElement ("classes");
 735                                 foreach (TypeDefinition t in nestedArray) {
 736                                         TypeData td = new TypeData (writer, t, state);
 737                                         td.DoOutput ();
 738                                 }
 739                                 writer.WriteEndElement (); // classes
 740                         }
 741
 742                         writer.WriteEndElement (); // class
 743                 }
 744
 745                 static FieldReference GetEnumValueField (TypeDefinition type)
 746                 {
 747                         foreach (FieldDefinition field in type.Fields)
 748                                 if (field.IsSpecialName && field.Name == "value__")
 749                                         return field;
 750
 751                         return null;
 752                 }
 753
 754                 protected override string GetMemberAttributes (MemberReference member)
 755                 {
 756                         if (member != type)
 757                                 throw new InvalidOperationException ("odd");
 758
 759                         return ((int) type.Attributes).ToString (CultureInfo.InvariantCulture);
 760                 }
 761
 762                 public static bool MustDocumentMethod (MethodDefinition method) {
 763                         // All other methods
 764                         MethodAttributes maskedAccess = method.Attributes & MethodAttributes.MemberAccessMask;
 765                         return maskedAccess == MethodAttributes.Public
 766                                 || maskedAccess == MethodAttributes.Family
 767                                 || maskedAccess == MethodAttributes.FamORAssem;
 768                 }
 769
 770                 string GetClassType (TypeDefinition t)
 771                 {
 772                         if (t.IsEnum)
 773                                 return "enum";
 774
 775                         if (t.IsValueType)
 776                                 return "struct";
 777
 778                         if (t.IsInterface)
 779                                 return "interface";
 780
 781                         if (state.TypeHelper.IsDelegate(t))
 782                                 return "delegate";
 783
 784                         if (t.IsPointer)
 785                                 return "pointer";
 786
 787                         return "class";
 788                 }
 789
 790                 static string GetCharSet (TypeDefinition type)
 791                 {
 792                         TypeAttributes maskedStringFormat = type.Attributes & TypeAttributes.StringFormatMask;
 793                         if (maskedStringFormat == TypeAttributes.AnsiClass)
 794                                 return CharSet.Ansi.ToString ();
 795
 796                         if (maskedStringFormat == TypeAttributes.AutoClass)
 797                                 return CharSet.Auto.ToString ();
 798
 799                         if (maskedStringFormat == TypeAttributes.UnicodeClass)
 800                                 return CharSet.Unicode.ToString ();
 801
 802                         return CharSet.None.ToString ();
 803                 }
 804
 805                 static string GetLayout (TypeDefinition type)
 806                 {
 807                         TypeAttributes maskedLayout = type.Attributes & TypeAttributes.LayoutMask;
 808                         if (maskedLayout == TypeAttributes.AutoLayout)
 809                                 return LayoutKind.Auto.ToString ();
 810
 811                         if (maskedLayout == TypeAttributes.ExplicitLayout)
 812                                 return LayoutKind.Explicit.ToString ();
 813
 814                         if (maskedLayout == TypeAttributes.SequentialLayout)
 815                                 return LayoutKind.Sequential.ToString ();
 816
 817                         return null;
 818                 }
 819
 820                 FieldDefinition [] GetFields (TypeDefinition type) {
 821                         ArrayList list = new ArrayList ();
 822
 823                         var fields = type.Fields;
 824                         foreach (FieldDefinition field in fields) {
 825                                 if (field.IsSpecialName)
 826                                         continue;
 827
 828                                 if (state.AbiMode && field.IsStatic)
 829                                         continue;
 830
 831                                 // we're only interested in public or protected members
 832                                 FieldAttributes maskedVisibility = (field.Attributes & FieldAttributes.FieldAccessMask);
 833                                 if (state.AbiMode && !field.IsNotSerialized) {
 834                                         list.Add (field);
 835                                 } else {
 836                                         if (maskedVisibility == FieldAttributes.Public
 837                                                 || maskedVisibility == FieldAttributes.Family
 838                                                 || maskedVisibility == FieldAttributes.FamORAssem) {
 839                                                 list.Add (field);
 840                                         }
 841                                 }
 842                         }
 843
 844                         return (FieldDefinition []) list.ToArray (typeof (FieldDefinition));
 845                 }
 846
 847
 848                 internal PropertyDefinition [] GetProperties (TypeDefinition type, bool fullAPI) {
 849                         var list = new List<PropertyDefinition> ();
 850
 851                         var t = type;
 852                         do {
 853                                 var properties = t.Properties;//type.GetProperties (flags);
 854                                 foreach (PropertyDefinition property in properties) {
 855                                         MethodDefinition getMethod = property.GetMethod;
 856                                         MethodDefinition setMethod = property.SetMethod;
 857
 858                                         bool hasGetter = (getMethod != null) && MustDocumentMethod (getMethod);
 859                                         bool hasSetter = (setMethod != null) && MustDocumentMethod (setMethod);
 860
 861                                         // if neither the getter or setter should be documented, then
 862                                         // skip the property
 863                                         if (hasGetter || hasSetter) {
 864
 865                                                 if (t != type && list.Any (l => l.Name == property.Name))
 866                                                         continue;
 867
 868                                                 list.Add (property);
 869                                         }
 870                                 }
 871
 872                                 if (!fullAPI)
 873                                         break;
 874
 875                                 if (t.IsInterface || t.IsEnum)
 876                                         break;
 877
 878                                 if (t.BaseType == null || t.BaseType.FullName == "System.Object")
 879                                         t = null;
 880                                 else
 881                                         t = state.TypeHelper.GetBaseType (t);
 882
 883                         } while (t != null);
 884
 885                         return list.ToArray ();
 886                 }
 887
 888                 private MethodDefinition[] GetMethods (TypeDefinition type, bool fullAPI)
 889                 {
 890                         var list = new List<MethodDefinition> ();
 891
 892                         var t = type;
 893                         do {
 894                                 var methods = t.Methods;//type.GetMethods (flags);
 895                                 foreach (MethodDefinition method in methods) {
 896                                         if (method.IsSpecialName && !method.Name.StartsWith ("op_", StringComparison.Ordinal))
 897                                                 continue;
 898
 899                                         // we're only interested in public or protected members
 900                                         if (!MustDocumentMethod (method))
 901                                                 continue;
 902
 903                                         if (t == type && IsFinalizer (method)) {
 904                                                 string name = method.DeclaringType.Name;
 905                                                 int arity = name.IndexOf ('`');
 906                                                 if (arity > 0)
 907                                                         name = name.Substring (0, arity);
 908
 909                                                 method.Name = "~" + name;
 910                                         }
 911
 912                                         if (t != type && list.Any (l => l.DeclaringType != method.DeclaringType && l.Name == method.Name && l.Parameters.Count == method.Parameters.Count &&
 913                                                                    l.Parameters.SequenceEqual (method.Parameters, new ParameterComparer ())))
 914                                                 continue;
 915
 916                                         list.Add (method);
 917                                 }
 918
 919                                 if (!fullAPI)
 920                                         break;
 921
 922                                 if (t.IsInterface || t.IsEnum)
 923                                         break;
 924
 925                                 if (t.BaseType == null || t.BaseType.FullName == "System.Object")
 926                                         t = null;
 927                                 else
 928                                         t = state.TypeHelper.GetBaseType (t);
 929
 930                         } while (t != null);
 931
 932                         return list.ToArray ();
 933                 }
 934
 935                 sealed class ParameterComparer : IEqualityComparer<ParameterDefinition>
 936                 {
 937                         public bool Equals (ParameterDefinition x, ParameterDefinition y)
 938                         {
 939                                 return x.ParameterType.Name == y.ParameterType.Name;
 940                         }
 941
 942                         public int GetHashCode (ParameterDefinition obj)
 943                         {
 944                                 return obj.ParameterType.Name.GetHashCode ();
 945                         }
 946                 }
 947
 948                 static bool IsFinalizer (MethodDefinition method)
 949                 {
 950                         if (method.Name != "Finalize")
 951                                 return false;
 952
 953                         if (!method.IsVirtual)
 954                                 return false;
 955
 956                         if (method.Parameters.Count != 0)
 957                                 return false;
 958
 959                         return true;
 960                 }
 961
 962                 private MethodDefinition [] GetConstructors (TypeDefinition type)
 963                 {
 964                         ArrayList list = new ArrayList ();
 965
 966                         var ctors = type.Methods.Where (m => m.IsConstructor);//type.GetConstructors (flags);
 967                         foreach (MethodDefinition constructor in ctors) {
 968                                 // we're only interested in public or protected members
 969                                 if (!MustDocumentMethod(constructor))
 970                                         continue;
 971
 972                                 list.Add (constructor);
 973                         }
 974
 975                         return (MethodDefinition []) list.ToArray (typeof (MethodDefinition));
 976                 }
 977
 978                 private EventDefinition[] GetEvents (TypeDefinition type)
 979                 {
 980                         ArrayList list = new ArrayList ();
 981
 982                         var events = type.Events;//type.GetEvents (flags);
 983                         foreach (EventDefinition eventDef in events) {
 984                                 MethodDefinition addMethod = eventDef.AddMethod;//eventInfo.GetAddMethod (true);
 985
 986                                 if (addMethod == null || !MustDocumentMethod (addMethod))
 987                                         continue;
 988
 989                                 list.Add (eventDef);
 990                         }
 991
 992                         return (EventDefinition []) list.ToArray (typeof (EventDefinition));
 993                 }
 994         }
 995
 996         class FieldData : MemberData
 997         {
 998                 public FieldData (XmlWriter writer, FieldDefinition [] members, State state)
 999                         : base (writer, members, state)
1000                 {
1001                 }
1002
1003                 protected override string GetName (MemberReference memberDefenition)
1004                 {
1005                         FieldDefinition field = (FieldDefinition) memberDefenition;
1006                         return field.Name;
1007                 }
1008
1009                 protected override string GetMemberAttributes (MemberReference memberDefenition)
1010                 {
1011                         FieldDefinition field = (FieldDefinition) memberDefenition;
1012                         return ((int) field.Attributes).ToString (CultureInfo.InvariantCulture);
1013                 }
1014
1015                 protected override void AddExtraAttributes (MemberReference memberDefinition)
1016                 {
1017                         base.AddExtraAttributes (memberDefinition);
1018
1019                         FieldDefinition field = (FieldDefinition) memberDefinition;
1020                         AddAttribute ("fieldtype", Utils.CleanupTypeName (field.FieldType));
1021
1022                         if (field.IsLiteral) {
1023                                 object value = field.Constant;//object value = field.GetValue (null);
1024                                 string stringValue = null;
1025                                 //if (value is Enum) {
1026                                 //    // FIXME: when Mono bug #60090 has been
1027                                 //    // fixed, we should just be able to use
1028                                 //    // Convert.ToString
1029                                 //    stringValue = ((Enum) value).ToString ("D", CultureInfo.InvariantCulture);
1030                                 //}
1031                                 //else {
1032                                 stringValue = Convert.ToString (value, CultureInfo.InvariantCulture);
1033                                 //}
1034
1035                                 if (stringValue != null)
1036                                         AddAttribute ("value", stringValue);
1037                         }
1038                 }
1039
1040                 public override string ParentTag {
1041                         get { return "fields"; }
1042                 }
1043
1044                 public override string Tag {
1045                         get { return "field"; }
1046                 }
1047         }
1048
1049         class PropertyData : MemberData
1050         {
1051                 public PropertyData (XmlWriter writer, PropertyDefinition [] members, State state)
1052                         : base (writer, members, state)
1053                 {
1054                 }
1055
1056                 protected override string GetName (MemberReference memberDefenition)
1057                 {
1058                         PropertyDefinition prop = (PropertyDefinition) memberDefenition;
1059                         return prop.Name;
1060                 }
1061
1062                 MethodDefinition [] GetMethods (PropertyDefinition prop, out bool haveParameters)
1063                 {
1064                         MethodDefinition _get = prop.GetMethod;
1065                         MethodDefinition _set = prop.SetMethod;
1066                         bool haveGet = (_get != null && TypeData.MustDocumentMethod(_get));
1067                         bool haveSet = (_set != null && TypeData.MustDocumentMethod(_set));
1068                         haveParameters = haveGet || (haveSet && _set.Parameters.Count > 1);
1069                         MethodDefinition [] methods;
1070
1071                         if (haveGet && haveSet) {
1072                                 methods = new MethodDefinition [] { _get, _set };
1073                         } else if (haveGet) {
1074                                 methods = new MethodDefinition [] { _get };
1075                         } else if (haveSet) {
1076                                 methods = new MethodDefinition [] { _set };
1077                         } else {
1078                                 //odd
1079                                 return null;
1080                         }
1081
1082                         return methods;
1083                 }
1084
1085                 protected override void AddExtraAttributes (MemberReference memberDefinition)
1086                 {
1087                         base.AddExtraAttributes (memberDefinition);
1088
1089                         PropertyDefinition prop = (PropertyDefinition) memberDefinition;
1090                         AddAttribute ("ptype", Utils.CleanupTypeName (prop.PropertyType));
1091
1092                         bool haveParameters;
1093                         MethodDefinition [] methods = GetMethods ((PropertyDefinition) memberDefinition, out haveParameters);
1094
1095                         if (methods != null && haveParameters) {
1096                                 string parms = Parameters.GetSignature (methods [0].Parameters);
1097                                 if (!string.IsNullOrEmpty (parms))
1098                                         AddAttribute ("params", parms);
1099                         }
1100
1101                 }
1102
1103                 protected override void AddExtraData (MemberReference memberDefenition)
1104                 {
1105                         base.AddExtraData (memberDefenition);
1106
1107                         bool haveParameters;
1108                         MethodDefinition [] methods = GetMethods ((PropertyDefinition) memberDefenition, out haveParameters);
1109
1110                         if (methods == null)
1111                                 return;
1112
1113                         MethodData data = new MethodData (writer, methods, state);
1114                         //data.NoMemberAttributes = true;
1115                         data.DoOutput ();
1116                 }
1117
1118                 protected override string GetMemberAttributes (MemberReference memberDefenition)
1119                 {
1120                         PropertyDefinition prop = (PropertyDefinition) memberDefenition;
1121                         return ((int) prop.Attributes).ToString (CultureInfo.InvariantCulture);
1122                 }
1123
1124                 public override string ParentTag {
1125                         get { return "properties"; }
1126                 }
1127
1128                 public override string Tag {
1129                         get { return "property"; }
1130                 }
1131         }
1132
1133         class EventData : MemberData
1134         {
1135                 public EventData (XmlWriter writer, EventDefinition [] members, State state)
1136                         : base (writer, members, state)
1137                 {
1138                 }
1139
1140                 protected override string GetName (MemberReference memberDefenition)
1141                 {
1142                         EventDefinition evt = (EventDefinition) memberDefenition;
1143                         return evt.Name;
1144                 }
1145
1146                 protected override string GetMemberAttributes (MemberReference memberDefenition)
1147                 {
1148                         EventDefinition evt = (EventDefinition) memberDefenition;
1149                         return ((int) evt.Attributes).ToString (CultureInfo.InvariantCulture);
1150                 }
1151
1152                 protected override void AddExtraAttributes (MemberReference memberDefinition)
1153                 {
1154                         base.AddExtraAttributes (memberDefinition);
1155
1156                         EventDefinition evt = (EventDefinition) memberDefinition;
1157                         AddAttribute ("eventtype", Utils.CleanupTypeName (evt.EventType));
1158                 }
1159
1160                 public override string ParentTag {
1161                         get { return "events"; }
1162                 }
1163
1164                 public override string Tag {
1165                         get { return "event"; }
1166                 }
1167         }
1168
1169         class MethodData : MemberData
1170         {
1171                 bool noAtts;
1172
1173                 public MethodData (XmlWriter writer, MethodDefinition [] members, State state)
1174                         : base (writer, members, state)
1175                 {
1176                 }
1177
1178                 protected override string GetName (MemberReference memberDefenition)
1179                 {
1180                         MethodDefinition method = (MethodDefinition) memberDefenition;
1181                         string name = method.Name;
1182                         string parms = Parameters.GetSignature (method.Parameters);
1183
1184                         return string.Format ("{0}({1})", name, parms);
1185                 }
1186
1187                 protected override string GetMemberAttributes (MemberReference memberDefenition)
1188                 {
1189                         MethodDefinition method = (MethodDefinition) memberDefenition;
1190                         return ((int)( method.Attributes)).ToString (CultureInfo.InvariantCulture);
1191                 }
1192
1193                 protected override ICustomAttributeProvider GetAdditionalCustomAttributeProvider (MemberReference member)
1194                 {
1195                         var mbase = (MethodDefinition) member;
1196                         return mbase.MethodReturnType;
1197                 }
1198
1199                 protected override void AddExtraAttributes (MemberReference memberDefinition)
1200                 {
1201                         base.AddExtraAttributes (memberDefinition);
1202
1203                         if (!(memberDefinition is MethodDefinition))
1204                                 return;
1205
1206                         MethodDefinition mbase = (MethodDefinition) memberDefinition;
1207
1208                         if (mbase.IsAbstract)
1209                                 AddAttribute ("abstract", "true");
1210                         if (mbase.IsVirtual)
1211                                 AddAttribute ("virtual", "true");
1212                         if (mbase.IsFinal && mbase.IsVirtual && mbase.IsReuseSlot)
1213                                 AddAttribute ("sealed", "true");
1214                         if (mbase.IsStatic)
1215                                 AddAttribute ("static", "true");
1216                         var baseMethod = state.TypeHelper.GetBaseMethodInTypeHierarchy (mbase);
1217                         if (baseMethod != null && baseMethod != mbase) {
1218                                 // This indicates whether this method is an override of another method.
1219                                 // This information is not necessarily available in the api info for any
1220                                 // particular assembly, because a method is only overriding another if
1221                                 // there is a base virtual function with the same signature, and that
1222                                 // base method can come from another assembly.
1223                                 AddAttribute ("is-override", "true");
1224                         }
1225                         string rettype = Utils.CleanupTypeName (mbase.MethodReturnType.ReturnType);
1226                         if (rettype != "System.Void" || !mbase.IsConstructor)
1227                                 AddAttribute ("returntype", (rettype));
1228 //
1229 //                      if (mbase.MethodReturnType.HasCustomAttributes)
1230 //                              AttributeData.OutputAttributes (writer, mbase.MethodReturnType);
1231                 }
1232
1233                 protected override void AddExtraData (MemberReference memberDefenition)
1234                 {
1235                         base.AddExtraData (memberDefenition);
1236
1237                         if (!(memberDefenition is MethodDefinition))
1238                                 return;
1239
1240                         MethodDefinition mbase = (MethodDefinition)memberDefenition;
1241
1242                         ParameterData parms = new ParameterData (writer, mbase.Parameters, state) {
1243                                 HasExtensionParameter = mbase.CustomAttributes.Any (l => l.AttributeType.FullName == "System.Runtime.CompilerServices.ExtensionAttribute")
1244                         };
1245
1246                         parms.DoOutput ();
1247
1248                         MemberData.OutputGenericParameters (writer, mbase, state);
1249                 }
1250
1251                 public override bool NoMemberAttributes {
1252                         get { return noAtts; }
1253                         set { noAtts = value; }
1254                 }
1255
1256                 public override string ParentTag {
1257                         get { return "methods"; }
1258                 }
1259
1260                 public override string Tag {
1261                         get { return "method"; }
1262                 }
1263         }
1264
1265         class ConstructorData : MethodData
1266         {
1267                 public ConstructorData (XmlWriter writer, MethodDefinition [] members, State state)
1268                         : base (writer, members, state)
1269                 {
1270                 }
1271
1272                 public override string ParentTag {
1273                         get { return "constructors"; }
1274                 }
1275
1276                 public override string Tag {
1277                         get { return "constructor"; }
1278                 }
1279         }
1280
1281         class ParameterData : BaseData
1282         {
1283                 private IList<ParameterDefinition> parameters;
1284
1285                 public ParameterData (XmlWriter writer, IList<ParameterDefinition> parameters, State state)
1286                         : base (writer, state)
1287                 {
1288                         this.parameters = parameters;
1289                 }
1290
1291                 public bool HasExtensionParameter { get; set; }
1292
1293                 public override void DoOutput ()
1294                 {
1295                         bool first = true;
1296                         writer.WriteStartElement ("parameters");
1297                         foreach (ParameterDefinition parameter in parameters) {
1298                                 writer.WriteStartElement ("parameter");
1299                                 AddAttribute ("name", parameter.Name);
1300                                 AddAttribute ("position", parameter.Method.Parameters.IndexOf(parameter).ToString(CultureInfo.InvariantCulture));
1301                                 AddAttribute ("attrib", ((int) parameter.Attributes).ToString());
1302
1303                                 string direction = first && HasExtensionParameter ? "this" : "in";
1304                                 first = false;
1305
1306                                 var pt = parameter.ParameterType;
1307                                 var brt = pt as ByReferenceType;
1308                                 if (brt != null) {
1309                                         direction = parameter.IsOut ? "out" : "ref";
1310                                         pt = brt.ElementType;
1311                                 }
1312
1313                                 AddAttribute ("type", Utils.CleanupTypeName (pt));
1314
1315                                 if (parameter.IsOptional) {
1316                                         AddAttribute ("optional", "true");
1317                                         if (parameter.HasConstant)
1318                                                 AddAttribute ("defaultValue", parameter.Constant == null ? "NULL" : parameter.Constant.ToString ());
1319                                 }
1320
1321                                 if (direction != "in")
1322                                         AddAttribute ("direction", direction);
1323
1324                                 AttributeData.OutputAttributes (writer, state, parameter);
1325                                 writer.WriteEndElement (); // parameter
1326                         }
1327                         writer.WriteEndElement (); // parameters
1328                 }
1329         }
1330
1331         class AttributeData
1332         {
1333                 State state;
1334
1335                 public AttributeData (State state)
1336                 {
1337                         this.state = state;
1338                 }
1339
1340                 public void DoOutput (XmlWriter writer, IList<ICustomAttributeProvider> providers)
1341                 {
1342                         if (writer == null)
1343                                 throw new InvalidOperationException ("Document not set");
1344
1345                         if (providers == null || providers.Count == 0)
1346                                 return;
1347
1348                         if (!providers.Any ((provider) => provider != null && provider.HasCustomAttributes))
1349                                 return;
1350
1351                         writer.WriteStartElement ("attributes");
1352
1353                         foreach (var provider in providers) {
1354                                 if (provider == null)
1355                                         continue;
1356
1357                                 if (!provider.HasCustomAttributes)
1358                                         continue;
1359
1360
1361                                 var ass = provider as AssemblyDefinition;
1362                                 if (ass != null && !state.FollowForwarders)
1363                                         TypeForwardedToData.OutputForwarders (writer, ass, state);
1364
1365                                 var attributes = provider.CustomAttributes.
1366                                         Where ((att) => !SkipAttribute (att)).
1367                                         OrderBy ((a) => a.Constructor.DeclaringType.FullName, StringComparer.Ordinal);
1368
1369                                 foreach (var att in attributes) {
1370                                         string attName = Utils.CleanupTypeName (att.Constructor.DeclaringType);
1371
1372                                         writer.WriteStartElement ("attribute");
1373                                         writer.WriteAttributeString ("name", attName);
1374
1375                                         var attribute_mapping = CreateAttributeMapping (att);
1376
1377                                         if (attribute_mapping != null) {
1378                                                 var mapping = attribute_mapping.Where ((attr) => attr.Key != "TypeId");
1379                                                 if (mapping.Any ()) {
1380                                                         writer.WriteStartElement ("properties");
1381                                                         foreach (var kvp in mapping) {
1382                                                                 string name = kvp.Key;
1383                                                                 object o = kvp.Value;
1384
1385                                                                 writer.WriteStartElement ("property");
1386                                                                 writer.WriteAttributeString ("name", name);
1387
1388                                                                 if (o == null) {
1389                                                                         writer.WriteAttributeString ("value", "null");
1390                                                                 } else {
1391                                                                         string value = o.ToString ();
1392                                                                         if (attName.EndsWith ("GuidAttribute", StringComparison.Ordinal))
1393                                                                                 value = value.ToUpper ();
1394                                                                         writer.WriteAttributeString ("value", value);
1395                                                                 }
1396
1397                                                                 writer.WriteEndElement (); // property
1398                                                         }
1399                                                         writer.WriteEndElement (); // properties
1400                                                 }
1401                                         }
1402                                         writer.WriteEndElement (); // attribute
1403                                 }
1404                         }
1405
1406                         writer.WriteEndElement (); // attributes
1407                 }
1408
1409                 Dictionary<string, object> CreateAttributeMapping (CustomAttribute attribute)
1410                 {
1411                         Dictionary<string, object> mapping = null;
1412
1413                         if (!state.TypeHelper.TryResolve (attribute))
1414                                 return mapping;
1415
1416                         PopulateMapping (ref mapping, attribute);
1417
1418                         var constructor = state.TypeHelper.GetMethod (attribute.Constructor);
1419                         if (constructor == null || !constructor.HasParameters)
1420                                 return mapping;
1421
1422                         PopulateMapping (ref mapping, constructor, attribute);
1423
1424                         return mapping;
1425                 }
1426
1427                 static void PopulateMapping (ref Dictionary<string, object> mapping, CustomAttribute attribute)
1428                 {
1429                         if (!attribute.HasProperties)
1430                                 return;
1431
1432                         foreach (var named_argument in attribute.Properties) {
1433                                 var name = named_argument.Name;
1434                                 var arg = named_argument.Argument;
1435
1436                                 if (arg.Value is CustomAttributeArgument)
1437                                         arg = (CustomAttributeArgument) arg.Value;
1438
1439                                 if (mapping == null)
1440                                         mapping = new Dictionary<string, object> (StringComparer.Ordinal);
1441                                 mapping.Add (name, GetArgumentValue (arg.Type, arg.Value));
1442                         }
1443                 }
1444
1445                 static Dictionary<FieldReference, int> CreateArgumentFieldMapping (MethodDefinition constructor)
1446                 {
1447                         Dictionary<FieldReference, int> field_mapping = null;
1448
1449                         int? argument = null;
1450
1451                         foreach (Instruction instruction in constructor.Body.Instructions) {
1452                                 switch (instruction.OpCode.Code) {
1453                                 case Code.Ldarg_1:
1454                                         argument = 1;
1455                                         break;
1456                                 case Code.Ldarg_2:
1457                                         argument = 2;
1458                                         break;
1459                                 case Code.Ldarg_3:
1460                                         argument = 3;
1461                                         break;
1462                                 case Code.Ldarg:
1463                                 case Code.Ldarg_S:
1464                                         argument = ((ParameterDefinition) instruction.Operand).Index + 1;
1465                                         break;
1466
1467                                 case Code.Stfld:
1468                                         FieldReference field = (FieldReference) instruction.Operand;
1469                                         if (field.DeclaringType.FullName != constructor.DeclaringType.FullName)
1470                                                 continue;
1471
1472                                         if (!argument.HasValue)
1473                                                 break;
1474
1475                                         if (field_mapping == null)
1476                                                 field_mapping = new Dictionary<FieldReference, int> ();
1477
1478                                         if (!field_mapping.ContainsKey (field))
1479                                                 field_mapping.Add (field, (int) argument - 1);
1480
1481                                         argument = null;
1482                                         break;
1483                                 }
1484                         }
1485
1486                         return field_mapping;
1487                 }
1488
1489                 static Dictionary<PropertyDefinition, FieldReference> CreatePropertyFieldMapping (TypeDefinition type)
1490                 {
1491                         Dictionary<PropertyDefinition, FieldReference> property_mapping = null;
1492
1493                         foreach (PropertyDefinition property in type.Properties) {
1494                                 if (property.GetMethod == null)
1495                                         continue;
1496                                 if (!property.GetMethod.HasBody)
1497                                         continue;
1498
1499                                 foreach (Instruction instruction in property.GetMethod.Body.Instructions) {
1500                                         if (instruction.OpCode.Code != Code.Ldfld)
1501                                                 continue;
1502
1503                                         FieldReference field = (FieldReference) instruction.Operand;
1504                                         if (field.DeclaringType.FullName != type.FullName)
1505                                                 continue;
1506
1507                                         if (property_mapping == null)
1508                                                 property_mapping = new Dictionary<PropertyDefinition, FieldReference> ();
1509                                         property_mapping.Add (property, field);
1510                                         break;
1511                                 }
1512                         }
1513
1514                         return property_mapping;
1515                 }
1516
1517                 static void PopulateMapping (ref Dictionary<string, object> mapping, MethodDefinition constructor, CustomAttribute attribute)
1518                 {
1519                         if (!constructor.HasBody)
1520                                 return;
1521
1522                         // Custom handling for attributes with arguments which cannot be easily extracted
1523                         var ca = attribute.ConstructorArguments;
1524                         switch (constructor.DeclaringType.FullName) {
1525                         case "System.Runtime.CompilerServices.DecimalConstantAttribute":
1526                                 var dca = constructor.Parameters[2].ParameterType == constructor.Module.TypeSystem.Int32 ?
1527                                         new DecimalConstantAttribute ((byte) ca[0].Value, (byte) ca[1].Value, (int) ca[2].Value, (int) ca[3].Value, (int) ca[4].Value) :
1528                                         new DecimalConstantAttribute ((byte) ca[0].Value, (byte) ca[1].Value, (uint) ca[2].Value, (uint) ca[3].Value, (uint) ca[4].Value);
1529
1530                                 if (mapping == null)
1531                                         mapping = new Dictionary<string, object> (StringComparer.Ordinal);
1532                                 mapping.Add ("Value", dca.Value);
1533                                 return;
1534                         case "System.ComponentModel.BindableAttribute":
1535                                 if (ca.Count != 1)
1536                                         break;
1537
1538                                 if (mapping == null)
1539                                         mapping = new Dictionary<string, object> (StringComparer.Ordinal);
1540
1541                                 if (constructor.Parameters[0].ParameterType == constructor.Module.TypeSystem.Boolean) {
1542                                         mapping.Add ("Bindable", ca[0].Value);
1543                                 } else if (constructor.Parameters[0].ParameterType.FullName == "System.ComponentModel.BindableSupport") {
1544                                         if ((int)ca[0].Value == 0)
1545                                                 mapping.Add ("Bindable", false);
1546                                         else if ((int)ca[0].Value == 1)
1547                                                 mapping.Add ("Bindable", true);
1548                                         else
1549                                                 throw new NotImplementedException ();
1550                                 } else {
1551                                         throw new NotImplementedException ();
1552                                 }
1553
1554                                 return;
1555                         }
1556
1557                         var field_mapping = CreateArgumentFieldMapping (constructor);
1558                         if (field_mapping != null) {
1559                                 var property_mapping = CreatePropertyFieldMapping ((TypeDefinition) constructor.DeclaringType);
1560
1561                                 if (property_mapping != null) {
1562                                         foreach (var pair in property_mapping) {
1563                                                 int argument;
1564                                                 if (!field_mapping.TryGetValue (pair.Value, out argument))
1565                                                         continue;
1566
1567                                                 var ca_arg = ca [argument];
1568                                                 if (ca_arg.Value is CustomAttributeArgument)
1569                                                         ca_arg = (CustomAttributeArgument)ca_arg.Value;
1570
1571                                                 if (mapping == null)
1572                                                         mapping = new Dictionary<string, object> (StringComparer.Ordinal);
1573                                                 mapping.Add (pair.Key.Name, GetArgumentValue (ca_arg.Type, ca_arg.Value));
1574                                         }
1575                                 }
1576                         }
1577                 }
1578
1579                 static object GetArgumentValue (TypeReference reference, object value)
1580                 {
1581                         var type = reference.Resolve ();
1582                         if (type == null)
1583                                 return value;
1584
1585                         if (type.IsEnum) {
1586                                 if (IsFlaggedEnum (type))
1587                                         return GetFlaggedEnumValue (type, value);
1588
1589                                 return GetEnumValue (type, value);
1590                         }
1591
1592                         return value;
1593                 }
1594
1595                 static bool IsFlaggedEnum (TypeDefinition type)
1596                 {
1597                         if (!type.IsEnum)
1598                                 return false;
1599
1600                         if (!type.HasCustomAttributes)
1601                                 return false;
1602
1603                         foreach (CustomAttribute attribute in type.CustomAttributes)
1604                                 if (attribute.Constructor.DeclaringType.FullName == "System.FlagsAttribute")
1605                                         return true;
1606
1607                         return false;
1608                 }
1609
1610                 static object GetFlaggedEnumValue (TypeDefinition type, object value)
1611                 {
1612                         if (value is ulong)
1613                                 return GetFlaggedEnumValue (type, (ulong)value);
1614
1615                         long flags = Convert.ToInt64 (value);
1616                         var signature = new StringBuilder ();
1617
1618                         for (int i = type.Fields.Count - 1; i >= 0; i--) {
1619                                 FieldDefinition field = type.Fields [i];
1620
1621                                 if (!field.HasConstant)
1622                                         continue;
1623
1624                                 long flag = Convert.ToInt64 (field.Constant);
1625
1626                                 if (flag == 0)
1627                                         continue;
1628
1629                                 if ((flags & flag) == flag) {
1630                                         if (signature.Length != 0)
1631                                                 signature.Append (", ");
1632
1633                                         signature.Append (field.Name);
1634                                         flags -= flag;
1635                                 }
1636                         }
1637
1638                         return signature.ToString ();
1639                 }
1640
1641                 static object GetFlaggedEnumValue (TypeDefinition type, ulong flags)
1642                 {
1643                         var signature = new StringBuilder ();
1644
1645                         for (int i = type.Fields.Count - 1; i >= 0; i--) {
1646                                 FieldDefinition field = type.Fields [i];
1647
1648                                 if (!field.HasConstant)
1649                                         continue;
1650
1651                                 ulong flag = Convert.ToUInt64 (field.Constant);
1652
1653                                 if (flag == 0)
1654                                         continue;
1655
1656                                 if ((flags & flag) == flag) {
1657                                         if (signature.Length != 0)
1658                                                 signature.Append (", ");
1659
1660                                         signature.Append (field.Name);
1661                                         flags -= flag;
1662                                 }
1663                         }
1664
1665                         return signature.ToString ();
1666                 }
1667
1668                 static object GetEnumValue (TypeDefinition type, object value)
1669                 {
1670                         foreach (FieldDefinition field in type.Fields) {
1671                                 if (!field.HasConstant)
1672                                         continue;
1673
1674                                 if (Comparer.Default.Compare (field.Constant, value) == 0)
1675                                         return field.Name;
1676                         }
1677
1678                         return value;
1679                 }
1680
1681                 bool SkipAttribute (CustomAttribute attribute)
1682                 {
1683                         if (!state.TypeHelper.IsPublic (attribute))
1684                                 return true;
1685
1686                         return attribute.Constructor.DeclaringType.Name.EndsWith ("TODOAttribute", StringComparison.Ordinal);
1687                 }
1688
1689                 public static void OutputAttributes (XmlWriter writer, State state, params ICustomAttributeProvider[] providers)
1690                 {
1691                         var data = new AttributeData (state);
1692                         data.DoOutput (writer, providers);
1693                 }
1694         }
1695
1696         static class Parameters {
1697
1698                 public static string GetSignature (IList<ParameterDefinition> infos)
1699                 {
1700                         if (infos == null || infos.Count == 0)
1701                                 return string.Empty;
1702
1703                         var signature = new StringBuilder ();
1704                         for (int i = 0; i < infos.Count; i++) {
1705
1706                                 if (i > 0)
1707                                         signature.Append (", ");
1708
1709                                 ParameterDefinition info = infos [i];
1710
1711                                 string modifier = string.Empty;
1712                                 if (info.ParameterType.IsByReference) {
1713                                         if ((info.Attributes & ParameterAttributes.In) != 0)
1714                                                 modifier = "in";
1715                                         else if ((info.Attributes & ParameterAttributes.Out) != 0)
1716                                                 modifier = "out";
1717                                 }
1718
1719                                 if (modifier.Length > 0) {
1720                                         signature.Append (modifier);
1721                                         signature.Append (" ");
1722                                 }
1723
1724                                 signature.Append (Utils.CleanupTypeName (info.ParameterType));
1725                         }
1726
1727                         return signature.ToString ();
1728                 }
1729
1730         }
1731
1732         class TypeReferenceComparer : IComparer<TypeReference>
1733         {
1734                 public static TypeReferenceComparer Default = new TypeReferenceComparer ();
1735
1736                 public int Compare (TypeReference a, TypeReference b)
1737                 {
1738                         int result = String.Compare (a.Namespace, b.Namespace, StringComparison.Ordinal);
1739                         if (result != 0)
1740                                 return result;
1741
1742                         return String.Compare (a.Name, b.Name, StringComparison.Ordinal);
1743                 }
1744         }
1745
1746         class MemberReferenceComparer : IComparer
1747         {
1748                 public static MemberReferenceComparer Default = new MemberReferenceComparer ();
1749
1750                 public int Compare (object a, object b)
1751                 {
1752                         MemberReference ma = (MemberReference) a;
1753                         MemberReference mb = (MemberReference) b;
1754                         return String.Compare (ma.Name, mb.Name, StringComparison.Ordinal);
1755                 }
1756         }
1757
1758         class PropertyDefinitionComparer : IComparer<PropertyDefinition>
1759         {
1760                 public static PropertyDefinitionComparer Default = new PropertyDefinitionComparer ();
1761
1762                 public int Compare (PropertyDefinition ma, PropertyDefinition mb)
1763                 {
1764                         int res = String.Compare (ma.Name, mb.Name, StringComparison.Ordinal);
1765                         if (res != 0)
1766                                 return res;
1767
1768                         if (!ma.HasParameters && !mb.HasParameters)
1769                                 return 0;
1770
1771                         if (!ma.HasParameters)
1772                                 return -1;
1773
1774                         if (!mb.HasParameters)
1775                                 return 1;
1776
1777                         return MethodDefinitionComparer.Compare (ma.Parameters, mb.Parameters);
1778                 }
1779         }
1780
1781         class MethodDefinitionComparer : IComparer
1782         {
1783                 public static MethodDefinitionComparer Default = new MethodDefinitionComparer ();
1784
1785                 public int Compare (object a, object b)
1786                 {
1787                         MethodDefinition ma = (MethodDefinition) a;
1788                         MethodDefinition mb = (MethodDefinition) b;
1789                         int res = String.Compare (ma.Name, mb.Name, StringComparison.Ordinal);
1790                         if (res != 0)
1791                                 return res;
1792
1793                         if (!ma.HasParameters && !mb.HasParameters)
1794                                 return 0;
1795
1796                         if (!ma.HasParameters)
1797                                 return -1;
1798
1799                         if (!mb.HasParameters)
1800                                 return 1;
1801
1802                         res = Compare (ma.Parameters, mb.Parameters);
1803                         if (res != 0)
1804                                 return res;
1805
1806                         if (ma.HasGenericParameters != mb.HasGenericParameters)
1807                                 return ma.HasGenericParameters ? -1 : 1;
1808
1809                         if (ma.HasGenericParameters && mb.HasGenericParameters) {
1810                                 res = ma.GenericParameters.Count - mb.GenericParameters.Count;
1811                                 if (res != 0)
1812                                         return res;
1813                         }
1814
1815                         // operators can differ by only return type
1816                         return string.CompareOrdinal (ma.ReturnType.FullName, mb.ReturnType.FullName);
1817                 }
1818
1819                 public static int Compare (IList<ParameterDefinition> pia, IList<ParameterDefinition> pib)
1820                 {
1821                         var res = pia.Count - pib.Count;
1822                         if (res != 0)
1823                                 return res;
1824
1825                         string siga = Parameters.GetSignature (pia);
1826                         string sigb = Parameters.GetSignature (pib);
1827                         return String.Compare (siga, sigb, StringComparison.Ordinal);
1828                 }
1829         }
1830 }
1831