2 // doc.cs: Support for XML documentation comment.
5 // Atsushi Enomoto <atsushi@ximian.com>
7 // Licensed under the terms of the GNU GPL
9 // (C) 2004 Novell, Inc.
13 using System.Collections;
14 using System.Collections.Specialized;
16 using System.Reflection;
17 using System.Reflection.Emit;
18 using System.Runtime.CompilerServices;
19 using System.Runtime.InteropServices;
20 using System.Security;
21 using System.Security.Permissions;
25 using Mono.CompilerServices.SymbolWriter;
27 namespace Mono.CSharp {
30 // Support class for XML documentation.
32 public static class DocUtil
37 // Generates xml doc comments (if any), and if required,
38 // handle warning report.
40 internal static void GenerateTypeDocComment (TypeContainer t,
43 GenerateDocComment (t, ds);
45 if (t.DefaultStaticConstructor != null)
46 t.DefaultStaticConstructor.GenerateDocComment (t);
48 if (t.InstanceConstructors != null)
49 foreach (Constructor c in t.InstanceConstructors)
50 c.GenerateDocComment (t);
53 foreach (TypeContainer tc in t.Types)
54 tc.GenerateDocComment (t);
56 if (t.Parts != null) {
57 IDictionary comments = RootContext.Documentation.PartialComments;
58 foreach (ClassPart cp in t.Parts) {
59 if (cp.DocComment == null)
66 foreach (Enum en in t.Enums)
67 en.GenerateDocComment (t);
69 if (t.Constants != null)
70 foreach (Const c in t.Constants)
71 c.GenerateDocComment (t);
74 foreach (Field f in t.Fields)
75 f.GenerateDocComment (t);
78 foreach (Event e in t.Events)
79 e.GenerateDocComment (t);
81 if (t.Indexers != null)
82 foreach (Indexer ix in t.Indexers)
83 ix.GenerateDocComment (t);
85 if (t.Properties != null)
86 foreach (Property p in t.Properties)
87 p.GenerateDocComment (t);
89 if (t.Methods != null)
90 foreach (Method m in t.Methods)
91 m.GenerateDocComment (t);
93 if (t.Operators != null)
94 foreach (Operator o in t.Operators)
95 o.GenerateDocComment (t);
99 private static readonly string lineHead =
100 Environment.NewLine + " ";
102 private static XmlNode GetDocCommentNode (MemberCore mc,
105 // FIXME: It could be even optimizable as not
106 // to use XmlDocument. But anyways the nodes
107 // are not kept in memory.
108 XmlDocument doc = RootContext.Documentation.XmlDocumentation;
110 XmlElement el = doc.CreateElement ("member");
111 el.SetAttribute ("name", name);
112 string normalized = mc.DocComment;
113 el.InnerXml = normalized;
114 // csc keeps lines as written in the sources
115 // and inserts formatting indentation (which
116 // is different from XmlTextWriter.Formatting
117 // one), but when a start tag contains an
118 // endline, it joins the next line. We don't
119 // have to follow such a hacky behavior.
121 normalized.Split ('\n');
123 for (int i = 0; i < split.Length; i++) {
124 string s = split [i].TrimEnd ();
128 el.InnerXml = lineHead + String.Join (
129 lineHead, split, 0, j);
131 } catch (XmlException ex) {
132 Report.Warning (1570, 1, mc.Location, "XML comment on '{0}' has non-well-formed XML ({1}).", name, ex.Message);
133 XmlComment com = doc.CreateComment (String.Format ("FIXME: Invalid documentation markup was found for member {0}", name));
139 // Generates xml doc comments (if any), and if required,
140 // handle warning report.
142 internal static void GenerateDocComment (MemberCore mc,
145 if (mc.DocComment != null) {
146 string name = mc.GetDocCommentName (ds);
148 XmlNode n = GetDocCommentNode (mc, name);
150 XmlElement el = n as XmlElement;
152 mc.OnGenerateDocComment (ds, el);
154 // FIXME: it could be done with XmlReader
155 foreach (XmlElement inc in n.SelectNodes (".//include"))
156 HandleInclude (mc, inc);
158 // FIXME: it could be done with XmlReader
159 DeclSpace dsTarget = mc as DeclSpace;
160 if (dsTarget == null)
163 foreach (XmlElement see in n.SelectNodes (".//see"))
164 HandleSee (mc, dsTarget, see);
165 foreach (XmlElement seealso in n.SelectNodes (".//seealso"))
166 HandleSeeAlso (mc, dsTarget, seealso);
167 foreach (XmlElement see in n.SelectNodes (".//exception"))
168 HandleException (mc, dsTarget, see);
171 n.WriteTo (RootContext.Documentation.XmlCommentOutput);
173 else if (mc.IsExposedFromAssembly (ds)) {
174 Constructor c = mc as Constructor;
175 if (c == null || !c.IsDefault ())
176 Report.Warning (1591, 4, mc.Location,
177 "Missing XML comment for publicly visible type or member '{0}'", mc.GetSignatureForError ());
182 // Processes "include" element. Check included file and
183 // embed the document content inside this documentation node.
185 private static void HandleInclude (MemberCore mc, XmlElement el)
187 string file = el.GetAttribute ("file");
188 string path = el.GetAttribute ("path");
190 Report.Warning (1590, 1, mc.Location, "Invalid XML 'include' element; Missing 'file' attribute.");
191 el.ParentNode.InsertBefore (el.OwnerDocument.CreateComment (" Include tag is invalid "), el);
193 else if (path == "") {
194 Report.Warning (1590, 1, mc.Location, "Invalid XML 'include' element; Missing 'path' attribute.");
195 el.ParentNode.InsertBefore (el.OwnerDocument.CreateComment (" Include tag is invalid "), el);
198 XmlDocument doc = RootContext.Documentation.StoredDocuments [file] as XmlDocument;
201 doc = new XmlDocument ();
203 RootContext.Documentation.StoredDocuments.Add (file, doc);
204 } catch (Exception) {
205 el.ParentNode.InsertBefore (el.OwnerDocument.CreateComment (String.Format (" Badly formed XML in at comment file '{0}': cannot be included ", file)), el);
206 Report.Warning (1592, 1, mc.Location, "Badly formed XML in included comments file -- '{0}'", file);
209 bool keepIncludeNode = false;
212 XmlNodeList nl = doc.SelectNodes (path);
214 el.ParentNode.InsertBefore (el.OwnerDocument.CreateComment (" No matching elements were found for the include tag embedded here. "), el);
216 keepIncludeNode = true;
218 foreach (XmlNode n in nl)
219 el.ParentNode.InsertBefore (el.OwnerDocument.ImportNode (n, true), el);
220 } catch (Exception ex) {
221 el.ParentNode.InsertBefore (el.OwnerDocument.CreateComment (" Failed to insert some or all of included XML "), el);
222 Report.Warning (1589, 1, mc.Location, "Unable to include XML fragment '{0}' of file {1} -- {2}.", path, file, ex.Message);
225 if (!keepIncludeNode)
226 el.ParentNode.RemoveChild (el);
231 // Handles <see> elements.
233 private static void HandleSee (MemberCore mc,
234 DeclSpace ds, XmlElement see)
236 HandleXrefCommon (mc, ds, see);
240 // Handles <seealso> elements.
242 private static void HandleSeeAlso (MemberCore mc,
243 DeclSpace ds, XmlElement seealso)
245 HandleXrefCommon (mc, ds, seealso);
249 // Handles <exception> elements.
251 private static void HandleException (MemberCore mc,
252 DeclSpace ds, XmlElement seealso)
254 HandleXrefCommon (mc, ds, seealso);
257 static readonly char [] wsChars =
258 new char [] {' ', '\t', '\n', '\r'};
261 // returns a full runtime type name from a name which might
262 // be C# specific type name.
264 private static Type FindDocumentedType (MemberCore mc, string name, DeclSpace ds, string cref)
266 bool isArray = false;
267 string identifier = name;
268 if (name [name.Length - 1] == ']') {
269 string tmp = name.Substring (0, name.Length - 1).Trim (wsChars);
270 if (tmp [tmp.Length - 1] == '[') {
271 identifier = tmp.Substring (0, tmp.Length - 1).Trim (wsChars);
275 Type t = FindDocumentedTypeNonArray (mc, identifier, ds, cref);
276 if (t != null && isArray)
277 t = Array.CreateInstance (t, 0).GetType ();
281 private static Type FindDocumentedTypeNonArray (MemberCore mc,
282 string identifier, DeclSpace ds, string cref)
284 switch (identifier) {
288 return typeof (uint);
290 return typeof (short);
292 return typeof (ushort);
294 return typeof (long);
296 return typeof (ulong);
298 return typeof (float);
300 return typeof (double);
302 return typeof (char);
304 return typeof (decimal);
306 return typeof (byte);
308 return typeof (sbyte);
310 return typeof (object);
312 return typeof (bool);
314 return typeof (string);
316 return typeof (void);
318 FullNamedExpression e = ds.LookupType (identifier, mc.Location, false);
320 if (!(e is TypeExpr))
322 return ((TypeExpr) e).ResolveType (ds.EmitContext);
324 int index = identifier.LastIndexOf ('.');
328 Type parent = FindDocumentedType (mc, identifier.Substring (0, index), ds, cref);
331 // no need to detect warning 419 here
332 return FindDocumentedMember (mc, parent,
333 identifier.Substring (index + 1),
335 ds, out warn, cref) as Type;
339 // Returns a MemberInfo that is referenced in XML documentation
340 // (by "see" or "seealso" elements).
342 private static MemberInfo FindDocumentedMember (MemberCore mc,
343 Type type, string memberName, Type [] paramList,
344 DeclSpace ds, out int warningType, string cref)
347 MethodSignature msig = new MethodSignature (memberName, null, paramList);
348 MemberInfo [] mis = type.FindMembers (
350 BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance,
351 MethodSignature.method_signature_filter,
353 if (mis.Length > 0) {
354 if (IsAmbiguous (mis))
359 if (paramList.Length == 0) {
360 // search for fields/events etc.
361 mis = type.FindMembers (
363 BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance,
368 if (IsAmbiguous (mis))
373 // search for operators (whose parameters exactly
374 // matches with the list) and possibly report CS1581.
376 string returnTypeName = null;
377 if (memberName.StartsWith ("implicit operator ")) {
378 oper = "op_Implicit";
379 returnTypeName = memberName.Substring (18).Trim (wsChars);
381 else if (memberName.StartsWith ("explicit operator ")) {
382 oper = "op_Explicit";
383 returnTypeName = memberName.Substring (18).Trim (wsChars);
385 else if (memberName.StartsWith ("operator ")) {
386 oper = memberName.Substring (9).Trim (wsChars);
388 // either unary or binary
390 oper = paramList.Length == 2 ?
391 Binary.oper_names [(int) Binary.Operator.Addition] :
392 Unary.oper_names [(int) Unary.Operator.UnaryPlus];
395 oper = paramList.Length == 2 ?
396 Binary.oper_names [(int) Binary.Operator.Subtraction] :
397 Unary.oper_names [(int) Unary.Operator.UnaryNegation];
401 oper = Unary.oper_names [(int) Unary.Operator.LogicalNot]; break;
403 oper = Unary.oper_names [(int) Unary.Operator.OnesComplement]; break;
406 oper = "op_Increment"; break;
408 oper = "op_Decrement"; break;
410 oper = "op_True"; break;
412 oper = "op_False"; break;
415 oper = Binary.oper_names [(int) Binary.Operator.Multiply]; break;
417 oper = Binary.oper_names [(int) Binary.Operator.Division]; break;
419 oper = Binary.oper_names [(int) Binary.Operator.Modulus]; break;
421 oper = Binary.oper_names [(int) Binary.Operator.BitwiseAnd]; break;
423 oper = Binary.oper_names [(int) Binary.Operator.BitwiseOr]; break;
425 oper = Binary.oper_names [(int) Binary.Operator.ExclusiveOr]; break;
427 oper = Binary.oper_names [(int) Binary.Operator.LeftShift]; break;
429 oper = Binary.oper_names [(int) Binary.Operator.RightShift]; break;
431 oper = Binary.oper_names [(int) Binary.Operator.Equality]; break;
433 oper = Binary.oper_names [(int) Binary.Operator.Inequality]; break;
435 oper = Binary.oper_names [(int) Binary.Operator.LessThan]; break;
437 oper = Binary.oper_names [(int) Binary.Operator.GreaterThan]; break;
439 oper = Binary.oper_names [(int) Binary.Operator.LessThanOrEqual]; break;
441 oper = Binary.oper_names [(int) Binary.Operator.GreaterThanOrEqual]; break;
444 Report.Warning (1020, 1, mc.Location, "Overloadable {0} operator is expected", paramList.Length == 2 ? "binary" : "unary");
445 Report.Warning (1584, 1, mc.Location, "XML comment on '{0}' has syntactically incorrect attribute '{1}'", mc.GetSignatureForError (), cref);
449 // here we still don't consider return type (to
450 // detect CS1581 or CS1002+CS1584).
451 msig = new MethodSignature (oper, null, paramList);
452 mis = type.FindMembers (
454 BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static,
455 MethodSignature.method_signature_filter,
458 return null; // CS1574
459 MemberInfo mi = mis [0];
460 Type expected = mi is MethodInfo ?
461 ((MethodInfo) mi).ReturnType :
463 ((PropertyInfo) mi).PropertyType :
465 if (returnTypeName != null) {
466 Type returnType = FindDocumentedType (mc, returnTypeName, ds, cref);
467 if (returnType == null || returnType != expected) {
469 Report.Warning (1581, 1, mc.Location, "Invalid return type in XML comment cref attribute '{0}'", cref);
476 private static bool IsAmbiguous (MemberInfo [] members)
478 if (members.Length < 2)
480 if (members.Length > 2)
482 if (members [0] is EventInfo && members [1] is FieldInfo)
484 if (members [1] is EventInfo && members [0] is FieldInfo)
489 private static Type [] emptyParamList = new Type [0];
492 // Processes "see" or "seealso" elements.
493 // Checks cref attribute.
495 private static void HandleXrefCommon (MemberCore mc,
496 DeclSpace ds, XmlElement xref)
498 string cref = xref.GetAttribute ("cref").Trim (wsChars);
499 // when, XmlReader, "if (cref == null)"
500 if (!xref.HasAttribute ("cref"))
502 if (cref.Length == 0)
503 Report.Warning (1001, 1, mc.Location, "Identifier expected");
504 // ... and continue until CS1584.
506 string signature; // "x:" are stripped
507 string name; // method invokation "(...)" are removed
508 string parameters; // method parameter list
510 // strip 'T:' 'M:' 'F:' 'P:' 'E:' etc.
511 // Here, MS ignores its member kind. No idea why.
512 if (cref.Length > 2 && cref [1] == ':')
513 signature = cref.Substring (2).Trim (wsChars);
517 int parensPos = signature.IndexOf ('(');
518 if (parensPos > 0 && signature [signature.Length - 1] == ')') {
519 name = signature.Substring (0, parensPos).Trim (wsChars);
520 parameters = signature.Substring (parensPos + 1, signature.Length - parensPos - 2);
524 parameters = String.Empty;
526 Normalize (mc, ref name);
528 string identifier = name;
530 if (name.Length > 0 && name [name.Length - 1] == ']') {
531 string tmp = name.Substring (0, name.Length - 1).Trim (wsChars);
532 if (tmp [tmp.Length - 1] == '[')
533 identifier = tmp.Substring (0, tmp.Length - 1).Trim (wsChars);
536 // Check if identifier is valid.
537 // This check is not necessary to mark as error, but
538 // csc specially reports CS1584 for wrong identifiers.
539 string [] nameElems = identifier.Split ('.');
540 for (int i = 0; i < nameElems.Length; i++) {
541 string nameElem = nameElems [i];
542 if (nameElem.EndsWith ("[]"))
543 nameElem = nameElem.Substring (
544 nameElem.Length - 2);
546 Normalize (mc, ref nameElem);
547 if (!Tokenizer.IsValidIdentifier (nameElem)
548 && nameElem.IndexOf ("operator") < 0) {
549 Report.Warning (1584, 1, mc.Location, "XML comment on '{0}' has syntactically incorrect attribute '{1}'", mc.GetSignatureForError (), cref);
550 xref.SetAttribute ("cref", "!:" + signature);
555 // check if parameters are valid
556 Type [] parameterTypes = Type.EmptyTypes;
557 if (parameters.Length > 0) {
558 string [] paramList = parameters.Split (',');
559 ArrayList plist = new ArrayList ();
560 for (int i = 0; i < paramList.Length; i++) {
561 string paramTypeName = paramList [i].Trim (wsChars);
562 Normalize (mc, ref paramTypeName);
563 Type paramType = FindDocumentedType (mc, paramTypeName, ds, cref);
564 if (paramType == null) {
565 Report.Warning (1580, 1, mc.Location, "Invalid type for parameter '{0}' in XML comment cref attribute '{1}'", i + 1, cref);
568 plist.Add (paramType);
570 parameterTypes = plist.ToArray (typeof (Type)) as Type [];
571 StringBuilder sb = new StringBuilder ();
573 for (int i = 0; i < parameterTypes.Length; i++) {
574 Type t = parameterTypes [i];
577 sb.Append (t.FullName.Replace ('+', '.'));
580 parameters = sb.ToString ();
583 Type type = FindDocumentedType (mc, name, ds, cref);
585 // delegate must not be referenced with args
586 && (!type.IsSubclassOf (typeof (System.Delegate))
587 || parameterTypes.Length == 0)) {
588 xref.SetAttribute ("cref", "T:" + type.FullName.Replace ("+", "."));
592 // don't use identifier here. System[] is not alloed.
593 if (Namespace.IsNamespace (name)) {
594 xref.SetAttribute ("cref", "N:" + name);
595 return; // a namespace
598 int period = name.LastIndexOf ('.');
600 string typeName = name.Substring (0, period);
601 string memberName = name.Substring (period + 1);
602 Normalize (mc, ref memberName);
603 type = FindDocumentedType (mc, typeName, ds, cref);
606 MemberInfo mi = FindDocumentedMember (mc, type, memberName, parameterTypes, ds, out warnResult, cref);
607 if (warnResult == 419)
608 Report419 (mc, memberName);
609 else if (warnResult > 0)
612 xref.SetAttribute ("cref", GetMemberDocHead (mi.MemberType) + type.FullName.Replace ("+", ".") + "." + memberName + parameters);
613 return; // a member of a type
619 MemberInfo mi = FindDocumentedMember (mc, ds.TypeBuilder, name, parameterTypes, ds, out warnResult, cref);
620 if (warnResult == 419)
621 Report419 (mc, name);
622 else if (warnResult > 0)
625 xref.SetAttribute ("cref", GetMemberDocHead (mi.MemberType) + ds.TypeBuilder.FullName.Replace ("+", ".") + "." + name);
626 return; // local member name
630 Report.Warning (1574, 1, mc.Location, "XML comment on '{0}' has cref attribute '{1}' that could not be resolved in '{2}'.", mc.GetSignatureForError (), cref, ds.GetSignatureForError ());
632 xref.SetAttribute ("cref", "!:" + name);
635 static void Report419 (MemberCore mc, string memberName)
637 Report.Warning (419, 3, mc.Location, "Ambiguous member specification in cref attribute: '{0}'. Check overloaded members and supply exact parameters.", memberName);
641 // Get a prefix from member type for XML documentation (used
642 // to formalize cref target name).
644 static string GetMemberDocHead (MemberTypes type)
647 case MemberTypes.Constructor:
648 case MemberTypes.Method:
650 case MemberTypes.Event:
652 case MemberTypes.Field:
654 case MemberTypes.NestedType:
655 case MemberTypes.TypeInfo:
657 case MemberTypes.Property:
666 // Returns a string that represents the signature for this
667 // member which should be used in XML documentation.
669 public static string GetMethodDocCommentName (MethodCore mc, DeclSpace ds)
671 Parameter [] plist = mc.Parameters.FixedParameters;
672 Parameter parr = mc.Parameters.ArrayParameter;
673 string paramSpec = String.Empty;
675 StringBuilder psb = new StringBuilder ();
676 foreach (Parameter p in plist) {
677 psb.Append (psb.Length != 0 ? "," : "(");
678 psb.Append (p.ParameterType.FullName.Replace ("+", "."));
680 paramSpec = psb.ToString ();
683 paramSpec += String.Concat (
684 paramSpec == String.Empty ? "(" : ",",
685 parr.ParameterType.FullName.Replace ("+", "."));
687 if (paramSpec.Length > 0)
690 string name = mc is Constructor ? "#ctor" : mc.Name;
691 string suffix = String.Empty;
692 Operator op = mc as Operator;
694 switch (op.OperatorType) {
695 case Operator.OpType.Implicit:
696 case Operator.OpType.Explicit:
697 suffix = "~" + op.OperatorMethodBuilder.ReturnType.FullName.Replace ('+', '.');
701 return String.Concat (mc.DocCommentHeader, ds.Name, ".", name, paramSpec, suffix);
705 // Raised (and passed an XmlElement that contains the comment)
706 // when GenerateDocComment is writing documentation expectedly.
708 // FIXME: with a few effort, it could be done with XmlReader,
709 // that means removal of DOM use.
711 internal static void OnMethodGenerateDocComment (
712 MethodCore mc, DeclSpace ds, XmlElement el)
714 Hashtable paramTags = new Hashtable ();
715 foreach (XmlElement pelem in el.SelectNodes ("param")) {
717 string xname = pelem.GetAttribute ("name");
719 continue; // really? but MS looks doing so
720 if (xname != "" && mc.Parameters.GetParameterByName (xname, out i) == null)
721 Report.Warning (1572, 2, mc.Location, "XML comment on '{0}' has a 'param' tag for '{1}', but there is no such parameter.", mc.Name, xname);
722 else if (paramTags [xname] != null)
723 Report.Warning (1571, 2, mc.Location, "XML comment on '{0}' has a duplicate param tag for '{1}'", mc.Name, xname);
724 paramTags [xname] = xname;
726 Parameter [] plist = mc.Parameters.FixedParameters;
728 foreach (Parameter p in plist) {
729 if (paramTags.Count > 0 && paramTags [p.Name] == null)
730 Report.Warning (1573, 4, mc.Location, "Parameter '{0}' has no matching param tag in the XML comment for '{1}' (but other parameters do)", mc.Name, p.Name);
736 public static void GenerateEnumDocComment (Enum e, DeclSpace ds)
738 GenerateDocComment (e, ds);
739 foreach (string name in e.ordered_enums) {
740 MemberCore mc = e.GetDefinition (name);
741 GenerateDocComment (mc, e);
745 private static void Normalize (MemberCore mc, ref string name)
747 if (name.Length > 0 && name [0] == '@')
748 name = name.Substring (1);
749 else if (Tokenizer.IsKeyword (name) && !IsTypeName (name))
750 Report.Warning (1041, 1, mc.Location, String.Format ("Identifier expected, '{0}' is a keyword", name));
753 private static bool IsTypeName (string name)
779 // Implements XML documentation generation.
781 public class Documentation
783 public Documentation (string xml_output_filename)
785 docfilename = xml_output_filename;
786 XmlDocumentation = new XmlDocument ();
787 XmlDocumentation.PreserveWhitespace = false;
790 private string docfilename;
793 // Used to create element which helps well-formedness checking.
795 public XmlDocument XmlDocumentation;
798 // The output for XML documentation.
800 public XmlWriter XmlCommentOutput;
803 // Stores XmlDocuments that are included in XML documentation.
804 // Keys are included filenames, values are XmlDocuments.
806 public Hashtable StoredDocuments = new Hashtable ();
809 // Stores comments on partial types (should handle uniquely).
810 // Keys are PartialContainers, values are comment strings
811 // (didn't use StringBuilder; usually we have just 2 or more).
813 public IDictionary PartialComments = new ListDictionary ();
816 // Outputs XML documentation comment from tokenized comments.
818 public bool OutputDocComment (string asmfilename)
820 XmlTextWriter w = null;
822 w = new XmlTextWriter (docfilename, null);
824 w.Formatting = Formatting.Indented;
825 w.WriteStartDocument ();
826 w.WriteStartElement ("doc");
827 w.WriteStartElement ("assembly");
828 w.WriteStartElement ("name");
829 w.WriteString (Path.ChangeExtension (asmfilename, null));
830 w.WriteEndElement (); // name
831 w.WriteEndElement (); // assembly
832 w.WriteStartElement ("members");
833 XmlCommentOutput = w;
834 GenerateDocComment ();
835 w.WriteFullEndElement (); // members
836 w.WriteEndElement ();
837 w.WriteWhitespace (Environment.NewLine);
838 w.WriteEndDocument ();
840 } catch (Exception ex) {
841 Report.Error (1569, "Error generating XML documentation file '{0}' ('{1}')", docfilename, ex.Message);
850 // Fixes full type name of each documented types/members up.
852 public void GenerateDocComment ()
854 TypeContainer root = RootContext.Tree.Types;
855 if (root.Interfaces != null)
856 foreach (Interface i in root.Interfaces)
857 DocUtil.GenerateTypeDocComment (i, null);
859 if (root.Types != null)
860 foreach (TypeContainer tc in root.Types)
861 DocUtil.GenerateTypeDocComment (tc, null);
863 if (root.Parts != null) {
864 IDictionary comments = PartialComments;
865 foreach (ClassPart cp in root.Parts) {
866 if (cp.DocComment == null)
872 if (root.Delegates != null)
873 foreach (Delegate d in root.Delegates)
874 DocUtil.GenerateDocComment (d, null);
876 if (root.Enums != null)
877 foreach (Enum e in root.Enums)
878 DocUtil.GenerateEnumDocComment (e, null);
880 IDictionary table = new ListDictionary ();
881 foreach (ClassPart cp in PartialComments.Keys) {
882 table [cp.PartialContainer] += cp.DocComment;
884 foreach (PartialContainer pc in table.Keys) {
885 pc.DocComment = table [pc] as string;
886 DocUtil.GenerateDocComment (pc, null);