* Added emember.cs and seealso.cs which help to flesh out the dtd

* Reworked Type.cs to support the full range of the monodoc.dtd

* Added support for the full monodoc.dtd to parser.cs

svn path=/trunk/mcs/; revision=7792

diff --git a/mcs/doctools/lib/emember.cs b/mcs/doctools/lib/emember.cs
new file mode 100644 (file)
index 0000000..68183f0
--- /dev/null
+++ b/mcs/doctools/lib/emember.cs
@@ -0,0 +1,31 @@
+// emember.cs - Mono Documentation Lib
+//
+// Author: Adam Treat <manyoso@yahoo.com>
+// (c) 2002 Adam Treat
+// Licensed under the terms of the GNU GPL
+
+using System;
+
+namespace Mono.Document.Library {
+
+       public class DocEnumMember {
+
+               string name, val;
+               
+               public DocEnumMember ()
+               {
+               }
+
+               public string Name
+               {
+                       get {return name;}
+                       set {name = value;}
+               }
+               
+               public string Value
+               {
+                       get {return val;}
+                       set {val = value;}
+               }
+       }
+}

diff --git a/mcs/doctools/lib/member.cs b/mcs/doctools/lib/member.cs
index 482cdd9f869ff4fd85a1dc20b93abf8bcd167430..1e974e5b7a06e44464d2d363c9bf9b66ee05a328 100644 (file)
--- a/mcs/doctools/lib/member.cs
+++ b/mcs/doctools/lib/member.cs
@@ -14,7 +14,7 @@ namespace Mono.Document.Library {
 
                string name, args, fullargs;
                ArrayList _params;
-               bool isCtor, isDtor, isMethod, isField, isProperty, isEvent = false;
+               bool isConstructor, isEvent, isField, isMethod, isOperator, isProperty = false;
 
                public DocMember ()
                {
@@ -63,16 +63,22 @@ namespace Mono.Document.Library {
                        get {return name+" "+args;}
                }
                
-               public bool IsCtor
+               public bool IsConstructor
                {
-                       get {return isCtor;}
-                       set {isCtor = value;}
+                       get {return isConstructor;}
+                       set {isConstructor = value;}
                }
 
-               public bool IsDtor
+               public bool IsEvent
                {
-                       get {return isDtor;}
-                       set {isDtor = value;}
+                       get {return isEvent;}
+                       set {isEvent = value;}
+               }
+
+               public bool IsField
+               {
+                       get {return isField;}
+                       set {isField = value;}
                }
 
                public bool IsMethod
@@ -81,10 +87,10 @@ namespace Mono.Document.Library {
                        set {isMethod = value;}
                }
 
-               public bool IsField
+               public bool IsOperator
                {
-                       get {return isField;}
-                       set {isField = value;}
+                       get {return isOperator;}
+                       set {isOperator = value;}
                }
 
                public bool IsProperty
@@ -92,11 +98,5 @@ namespace Mono.Document.Library {
                        get {return isProperty;}
                        set {isProperty = value;}
                }
-               
-               public bool IsEvent
-               {
-                       get {return isEvent;}
-                       set {isEvent = value;}
-               }
        }
 }

diff --git a/mcs/doctools/lib/parser.cs b/mcs/doctools/lib/parser.cs
index 61afe5c3860e665ccdedb3a8a2459a2a64cb5b3b..ed126d74c5296fa5b7d3090cdbe3a817c1c9acdc 100644 (file)
--- a/mcs/doctools/lib/parser.cs
+++ b/mcs/doctools/lib/parser.cs
@@ -44,6 +44,7 @@ namespace Mono.Document.Library {
                        get {return types;}
                }
 
+               //Type level tags
                private void ParseDoc ()
                {
                        while(xtr.Read ()) {
@@ -55,24 +56,24 @@ namespace Mono.Document.Library {
                                                        type.IsClass = true;
                                                        ParseType (type);
                                                        continue;
-                                               case "structure":
+                                               case "delegate":
                                                        type = new DocType ();
-                                                       type.IsStructure = true;
+                                                       type.IsDelegate = true;
                                                        ParseType (type);
                                                        continue;
-                                               case "interface":
+                                               case "enum":
                                                        type = new DocType ();
-                                                       type.IsInterface = true;
+                                                       type.IsEnum = true;
                                                        ParseType (type);
                                                        continue;
-                                               case "enum":
+                                               case "interface":
                                                        type = new DocType ();
-                                                       type.IsEnum = true;
+                                                       type.IsInterface = true;
                                                        ParseType (type);
                                                        continue;
-                                               case "delegate":
+                                               case "structure":
                                                        type = new DocType ();
-                                                       type.IsDelegate = true;
+                                                       type.IsStructure = true;
                                                        ParseType (type);
                                                        continue;
                                                default:
@@ -97,47 +98,48 @@ namespace Mono.Document.Library {
                        types.Add (type);
                }
 
+               //Member level tags
                private void ParseTypeBody (DocType type)
                {
                        while(xtr.Read ()) {
                                DocMember member;
                                if (
                                        xtr.Name == "class"
-                                       || xtr.Name == "structure"
-                                       || xtr.Name == "interface"
-                                       || xtr.Name == "enum"
                                        || xtr.Name == "delegate"
+                                       || xtr.Name == "enum"
+                                       || xtr.Name == "interface"
+                                       || xtr.Name == "structure"
                                ) return;
                                switch (xtr.Name) {
                                        case "constructor":
                                                member = new DocMember();
-                                               member.IsCtor = true;
-                                               type.AddCtor (ParseMember (member));
+                                               member.IsConstructor = true;
+                                               type.AddConstructor (ParseMember (member));
                                                continue;
-                                       case "method":
+                                       case "event":
                                                member = new DocMember();
-                                               member.IsMethod = true;
-                                               type.AddMethod (ParseMember (member));
+                                               member.IsEvent = true;
+                                               type.AddEvent (ParseMember (member));
                                                continue;
                                        case "field":
                                                member = new DocMember();
                                                member.IsField = true;
                                                type.AddField (ParseMember (member));
                                                continue;
-                                       case "property":
+                                       case "method":
                                                member = new DocMember();
-                                               member.IsProperty = true;
-                                               type.AddProperty (ParseMember (member));
+                                               member.IsMethod = true;
+                                               type.AddMethod (ParseMember (member));
                                                continue;
-                                       case "dtor":
+                                       case "operator":
                                                member = new DocMember();
-                                               member.IsDtor = true;
-                                               type.AddDtor (ParseMember (member));
+                                               member.IsOperator = true;
+                                               type.AddOperator (ParseMember (member));
                                                continue;
-                                       case "event":
+                                       case "property":
                                                member = new DocMember();
-                                               member.IsEvent = true;
-                                               type.AddEvent (ParseMember (member));
+                                               member.IsProperty = true;
+                                               type.AddProperty (ParseMember (member));
                                                continue;
                                        case "summary":
                                                if (xtr.NodeType != XmlNodeType.EndElement && xtr.Depth == 2) {
@@ -155,6 +157,30 @@ namespace Mono.Document.Library {
                                                        }
                                                }
                                                continue;
+                                       case "seealso":
+                                               if (xtr.NodeType != XmlNodeType.EndElement && xtr.Depth == 2) {
+                                                       xtr.Read ();
+                                                       if (document != null) {
+                                                               //document.AddSeeAlso (xtr.Value);
+                                                       }
+                                               }
+                                               continue;
+                                       case "param":
+                                               if (xtr.NodeType != XmlNodeType.EndElement && xtr.Depth == 2) {
+                                                       xtr.Read ();
+                                                       if (document != null) {
+                                                               //document.AddParam (xtr.Value);
+                                                       }
+                                               }
+                                               continue;
+                                       case "member":
+                                               if (xtr.NodeType != XmlNodeType.EndElement && xtr.Depth == 2) {
+                                                       xtr.Read ();
+                                                       if (document != null) {
+                                                               //document.AddEnumMember (xtr.Value);
+                                                       }
+                                               }
+                                               continue;
                                        default:
                                                continue;
                                }

diff --git a/mcs/doctools/lib/seealso.cs b/mcs/doctools/lib/seealso.cs
new file mode 100644 (file)
index 0000000..bf9fe23
--- /dev/null
+++ b/mcs/doctools/lib/seealso.cs
@@ -0,0 +1,32 @@
+// seealso.cs - Mono Documentation Lib
+//
+// Author: Adam Treat <manyoso@yahoo.com>
+// (c) 2002 Adam Treat
+// Licensed under the terms of the GNU GPL
+
+using System;
+
+namespace Mono.Document.Library {
+
+       public class DocSeeAlso {
+
+               string name, cref;
+               
+               public DocSeeAlso ()
+               {
+               }
+
+               public string Name
+               {
+                       get {return name;}
+                       set {name = value;}
+               }
+               
+               public string Cref
+               {
+                       get {return cref;}
+                       set {cref = value;}
+               }
+
+       }
+}

diff --git a/mcs/doctools/lib/type.cs b/mcs/doctools/lib/type.cs
index 75a2a7660edfc91278f209b075d79932f7bef264..fb7256b97a829b38936781385115176a50e2144e 100644 (file)
--- a/mcs/doctools/lib/type.cs
+++ b/mcs/doctools/lib/type.cs
@@ -12,18 +12,26 @@ namespace Mono.Document.Library {
        public class DocType : IComparable {
 
                string name, _namespace, fileroot, language, summary, remarks;
-               bool isClass, isInterface, isEnum, isStructure, isDelegate, isNested = false;
-               ArrayList enums, ctors, dtors, methods, properties, fields, events;
+               bool isClass, isDelegate, isEnum, isInterface, isStructure, isNested = false;
+               ArrayList classes, delegates, enums, interfaces, structures, constructors,
+               events, fields, methods, operators, properties, seealsos, _params, members;
 
                public DocType ()
                {
+                       classes = new ArrayList ();
+                       delegates = new ArrayList ();
                        enums = new ArrayList ();
-                       ctors = new ArrayList ();
-                       dtors = new ArrayList ();
+                       interfaces  = new ArrayList ();
+                       structures = new ArrayList ();
+                       constructors = new ArrayList ();
+                       events = new ArrayList ();
+                       fields = new ArrayList ();
                        methods = new ArrayList ();
+                       operators = new ArrayList ();
                        properties = new ArrayList ();
-                       fields = new ArrayList ();
-                       events = new ArrayList ();
+                       seealsos = new ArrayList ();
+                       _params = new ArrayList ();
+                       members = new ArrayList ();
                }
 
                public int CompareTo (Object value)
@@ -46,13 +54,13 @@ namespace Mono.Document.Library {
                {
                        if (type.IsClass)
                                return 5;
-                       else if (type.IsStructure)
+                       else if (type.IsDelegate)
                                return 4;
-                       else if (type.IsInterface)
-                               return 3;
                        else if (type.IsEnum)
+                               return 3;
+                       else if (type.IsInterface)
                                return 2;
-                       else if (type.IsDelegate)
+                       else if (type.IsStructure)
                                return 1;
                        else
                                return 0;
@@ -60,43 +68,110 @@ namespace Mono.Document.Library {
 
                public void Sort ()
                {
+                       classes.Sort ();
+                       delegates.Sort ();
                        enums.Sort ();
-                       ctors.Sort ();
-                       dtors.Sort ();
+                       interfaces.Sort ();
+                       structures.Sort ();
+                       constructors.Sort ();
+                       events.Sort ();
+                       fields.Sort ();
                        methods.Sort ();
+                       operators.Sort ();
                        properties.Sort ();
-                       fields.Sort ();
-                       events.Sort ();
+               }
+               
+               public void AddClass (DocType type)
+               {
+                       classes.Add (type);
                }
 
-               public void AddCtor (DocMember member)
+               public void AddDelegate (DocType type)
+               {
+                       delegates.Add (type);
+               }
+
+               public void AddEnum (DocType type)
+               {
+                       enums.Add (type);
+               }
+
+               public void AddInterface (DocType type)
+               {
+                       interfaces.Add (type);
+               }
+
+               public void AddStructure (DocType type)
+               {
+                       structures.Add (type);
+               }
+
+               public void AddConstructor (DocMember member)
+               {
+                       constructors.Add (member);
+               }
+
+               public void AddEvent (DocMember member)
                {
-                       ctors.Add (member);
+                       events.Add (member);
                }
 
-               public void AddDtor (DocMember member)
+               public void AddField (DocMember member)
                {
-                       dtors.Add (member);
+                       fields.Add (member);
                }
 
                public void AddMethod (DocMember member)
                {
                        methods.Add (member);
                }
-               
+
+               public void AddOperator (DocMember member)
+               {
+                       operators.Add (member);
+               }
+
                public void AddProperty (DocMember member)
                {
                        properties.Add (member);
                }
 
-               public void AddField (DocMember member)
+               public void AddSeeAlso (DocSeeAlso see)
                {
-                       fields.Add (member);
+                       seealsos.Add (see);
                }
-               
-               public void AddEvent (DocMember member)
+
+               public void AddParam (DocParam param)
                {
-                       events.Add (member);
+                       _params.Add (param);
+               }
+
+               public void AddEnumMember (DocEnumMember member)
+               {
+                       members.Add (member);
+               }
+
+               //Meta Information
+               public bool IsNested
+               {
+                       get {return isNested;}
+                       set {isNested = value;}
+               }
+
+               public string Type
+               {
+                       get {
+                               if (IsClass)
+                                       return "class";
+                               else if (IsDelegate)
+                                       return "delegate";
+                               else if (IsEnum)
+                                       return "enum";
+                               else if (IsInterface)
+                                       return "interface";
+                               else
+                                       return "structure";
+                       }
                }
 
                public string Name
@@ -155,56 +230,45 @@ namespace Mono.Document.Library {
                        set {remarks = value;}
                }
 
-               public bool IsInterface
-               {
-                       get {return isInterface;}
-                       set {isInterface = value;}
-               }
-
                public bool IsClass
                {
                        get {return isClass;}
                        set {isClass = value;}
                }
 
-               public bool IsStructure
+               public bool IsDelegate
                {
-                       get {return isStructure;}
-                       set {isStructure = value;}
+                       get {return isDelegate;}
+                       set {isDelegate = value;}
                }
-               
+
                public bool IsEnum
                {
                        get {return isEnum;}
                        set {isEnum = value;}
                }
 
-               public bool IsDelegate
+               public bool IsInterface
                {
-                       get {return isDelegate;}
-                       set {isDelegate = value;}
+                       get {return isInterface;}
+                       set {isInterface = value;}
+               }
+
+               public bool IsStructure
+               {
+                       get {return isStructure;}
+                       set {isStructure = value;}
                }
                
-               public bool IsNested
+               //Type level lists
+               public ArrayList Classes
                {
-                       get {return isNested;}
-                       set {isNested = value;}
+                       get {return classes;}
                }
 
-               public string Type
+               public ArrayList Delegates
                {
-                       get {
-                               if (IsClass)
-                                       return "class";
-                               else if (IsStructure)
-                                       return "structure";
-                               else if (IsInterface)
-                                       return "interface";
-                               else if (IsEnum)
-                                       return "emum";
-                               else
-                                       return "delegate";
-                       }
+                       get {return delegates;}
                }
 
                public ArrayList Enums
@@ -212,34 +276,60 @@ namespace Mono.Document.Library {
                        get {return enums;}
                }
 
-               public ArrayList Ctors
+               public ArrayList Interfaces
                {
-                       get {return ctors;}
+                       get {return interfaces;}
                }
 
-               public ArrayList Dtors
+               public ArrayList Structures
                {
-                       get {return dtors;}
+                       get {return structures;}
                }
-               
+
+               //Member level lists
+               public ArrayList Constructors
+               {
+                       get {return constructors;}
+               }
+
+               public ArrayList Events
+               {
+                       get {return events;}
+               }
+
+               public ArrayList Fields
+               {
+                       get {return fields;}
+               }
+
                public ArrayList Methods
                {
                        get {return methods;}
                }
-               
+
+               public ArrayList Operators
+               {
+                       get {return operators;}
+               }
+
                public ArrayList Properties
                {
                        get {return properties;}
                }
                
-               public ArrayList Fields
+               public ArrayList SeeAlsos
                {
-                       get {return fields;}
+                       get {return seealsos;}
                }
                
-               public ArrayList Events
+               public ArrayList Params
                {
-                       get {return events;}
+                       get {return _params;}
+               }
+               
+               public ArrayList EnumMembers
+               {
+                       get {return members;}
                }
        }
 }