diff -r 932c358ece3e -r d8fccb2cd802 Orb/Doxygen/src/entry.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Orb/Doxygen/src/entry.h	Fri Apr 23 20:47:58 2010 +0100
@@ -0,0 +1,448 @@
+/******************************************************************************
+ *
+ * 
+ *
+ * Copyright (C) 1997-2008 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+#ifndef ENTRY_H
+#define ENTRY_H
+
+#include "qtbc.h"
+#include <qlist.h>
+
+#include <qgstring.h>
+
+struct SectionInfo;
+class QFile;
+class EntryNav;
+class FileDef;
+class FileStorage;
+class StorageIntf;
+
+enum Protection { Public, Protected, Private, Package } ;
+enum Specifier { Normal, Virtual, Pure } ;
+enum MethodTypes { Method, Signal, Slot, DCOP, Property, Event };
+enum RelatesType { Simple, Duplicate, MemberOf };
+enum Relationship { Member, Related, Foreign };
+
+struct ListItemInfo
+{
+  QCString type;
+  int itemId;
+};
+
+/*! \brief This class stores information about an inheritance relation
+ */ 
+struct BaseInfo 
+{
+  /*! Creates an object representing an inheritance relation */
+  BaseInfo(const char *n,Protection p,Specifier v) : 
+    name(n),prot(p),virt(v) {}
+  QCString   name; //!< the name of the base class
+  Protection prot; //!< inheritance type
+  Specifier  virt; //!< virtualness
+};
+
+/*! \brief This class contains the information about the argument of a
+ *         function or template
+ *
+ */
+struct Argument
+{
+  /*! Construct a new argument. */
+  Argument() {}
+  /*! Copy an argument (does a deep copy of all strings). */
+  Argument(const Argument &a) 
+  { 
+    attrib=a.attrib.copy();
+    type=a.type.copy(); 
+    name=a.name.copy(); 
+    defval=a.defval.copy(); 
+    docs=a.docs.copy();
+    array=a.array.copy();
+  }
+  /*! Assignment of an argument (does a deep copy of all strings). */
+  Argument &operator=(const Argument &a)
+  {
+    if (this!=&a)
+    {
+      attrib=a.attrib.copy();
+      type=a.type.copy(); 
+      name=a.name.copy(); 
+      defval=a.defval.copy(); 
+      docs=a.docs.copy();
+      array=a.array.copy();
+    }
+    return *this;
+  }
+  /*! return TRUE if this argument is documentation and the argument has a
+   *  non empty name.
+   */
+  bool hasDocumentation() const 
+  { 
+    return !name.isEmpty() && !docs.isEmpty(); 
+  }
+  
+  QCString attrib;   /*!< Argument's attribute (IDL only) */
+  QCString type;     /*!< Argument's type */
+  QCString canType;  /*!< Cached value of canonical type (after type resolution). Empty initially. */
+  QCString name;     /*!< Argument's name (may be empty) */
+  QCString array;    /*!< Argument's array specifier (may be empty) */
+  QCString defval;   /*!< Argument's default value (may be empty) */
+  QCString docs;     /*!< Argument's documentation (may be empty) */
+};
+
+/*! \brief This class represents an function or template argument list. 
+ *
+ *  This class also stores some information about member that is typically
+ *  put after the argument list, such as wether the member is const, 
+ *  volatile or pure virtual.
+ */
+class ArgumentList : public QList<Argument> 
+{
+  public:
+    /*! Creates an empty argument list */
+    ArgumentList() : QList<Argument>(), 
+                     constSpecifier(FALSE),
+                     volatileSpecifier(FALSE),
+                     pureSpecifier(FALSE)
+                     { setAutoDelete(TRUE); }
+    /*! Destroys the argument list */
+   ~ArgumentList() {}
+    bool hasDocumentation() const;
+    /*! Does the member modify the state of the class? default: FALSE. */
+    bool constSpecifier;
+    /*! Is the member volatile? default: FALSE. */
+    bool volatileSpecifier;
+    /*! Is this a pure virtual member? default: FALSE */
+    bool pureSpecifier;
+};
+
+typedef QListIterator<Argument> ArgumentListIterator;
+
+/*! \brief This struct is used to capture the tag file information 
+ *         for an Entry. 
+ */
+struct TagInfo 
+{
+  QCString tagName;
+  QCString fileName;
+  QCString anchor;
+};
+
+struct Grouping 
+{
+  enum GroupPri_t 
+  {
+    GROUPING_LOWEST,
+    GROUPING_AUTO_WEAK = 
+      GROUPING_LOWEST,     //!< membership in group was defined via \@weakgroup 
+    GROUPING_AUTO_ADD,     //!< membership in group was defined via \@add[to]group 
+    GROUPING_AUTO_DEF,     //!< membership in group was defined via \@defgroup
+    GROUPING_AUTO_HIGHEST = GROUPING_AUTO_DEF,
+    GROUPING_INGROUP,      //!< membership in group was defined by \@ingroup
+    GROUPING_HIGHEST = GROUPING_INGROUP
+  };
+
+  static const char *getGroupPriName( GroupPri_t priority )
+  {
+    switch( priority )
+    {
+      case GROUPING_AUTO_WEAK:
+        return "@weakgroup";
+      case GROUPING_AUTO_ADD:
+        return "@addtogroup";
+      case GROUPING_AUTO_DEF:
+        return "@defgroup";
+      case GROUPING_INGROUP:
+        return "@ingroup";
+    }	    
+    return "???";
+  }
+
+  Grouping( const char *gn, GroupPri_t p ) : groupname(gn), pri(p) {}
+  Grouping( const Grouping &g ) : groupname(g.groupname), pri(g.pri) {}
+  QCString groupname;   //!< name of the group
+  GroupPri_t pri;       //!< priority of this definition
+
+};
+
+/*! \brief Represents an unstructured piece of information, about an
+ *         entity found in the sources. 
+ *
+ *  parseMain() in scanner.l will generate a tree of these
+ *  entries.
+ */
+class Entry
+{
+  public:
+
+    /*! Kind of entries that are supported */
+    enum Sections { 
+      CLASS_SEC        = 0x00000001, 
+      NAMESPACE_SEC    = 0x00000010,
+      COMPOUND_MASK    = CLASS_SEC,
+      SCOPE_MASK       = COMPOUND_MASK | NAMESPACE_SEC,
+      
+      CLASSDOC_SEC     = 0x00000800, 
+      STRUCTDOC_SEC    = 0x00001000,
+      UNIONDOC_SEC     = 0x00002000,
+      EXCEPTIONDOC_SEC = 0x00004000,
+      NAMESPACEDOC_SEC = 0x00008000,
+      INTERFACEDOC_SEC = 0x00010000,
+      PROTOCOLDOC_SEC  = 0x00020000,
+      CATEGORYDOC_SEC  = 0x00040000,
+      COMPOUNDDOC_MASK = CLASSDOC_SEC | STRUCTDOC_SEC | UNIONDOC_SEC | 
+                         INTERFACEDOC_SEC | EXCEPTIONDOC_SEC | PROTOCOLDOC_SEC |
+                         CATEGORYDOC_SEC,
+
+      SOURCE_SEC       = 0x00400000,
+      HEADER_SEC       = 0x00800000,
+      FILE_MASK        = SOURCE_SEC | HEADER_SEC,
+
+      ENUMDOC_SEC      = 0x01000000,
+      ENUM_SEC         = 0x02000000,
+      EMPTY_SEC        = 0x03000000, 
+      PAGEDOC_SEC      = 0x04000000, 
+      VARIABLE_SEC     = 0x05000000,
+      FUNCTION_SEC     = 0x06000000,
+      TYPEDEF_SEC      = 0x07000000,
+      MEMBERDOC_SEC    = 0x08000000, 
+      OVERLOADDOC_SEC  = 0x09000000,
+      EXAMPLE_SEC      = 0x0a000000, 
+      VARIABLEDOC_SEC  = 0x0b000000,
+      FILEDOC_SEC      = 0x0c000000,
+      DEFINEDOC_SEC    = 0x0d000000,
+      INCLUDE_SEC      = 0x0e000000,
+      DEFINE_SEC       = 0x0f000000,
+      GROUPDOC_SEC     = 0x10000000,
+      USINGDIR_SEC     = 0x11000000,
+      MAINPAGEDOC_SEC  = 0x12000000,
+      MEMBERGRP_SEC    = 0x13000000,
+      USINGDECL_SEC    = 0x14000000,
+      PACKAGE_SEC      = 0x15000000,
+      PACKAGEDOC_SEC   = 0x16000000,
+      OBJCIMPL_SEC     = 0x17000000,
+      DIRDOC_SEC       = 0x18000000
+    };
+    enum MemberSpecifier
+    {
+      Inline    = 0x000001,
+      Explicit  = 0x000002,
+      Mutable   = 0x000004,
+      Settable  = 0x000008,
+      Gettable  = 0x000010,
+      Readable  = 0x000020,
+      Writable  = 0x000040,
+      Final     = 0x000080,
+      Abstract  = 0x000100,
+      Addable   = 0x000200,
+      Removable = 0x000400,
+      Raisable  = 0x000800,
+      Override  = 0x001000,
+      New       = 0x002000,
+      Sealed    = 0x004000,
+      Initonly  = 0x008000,
+      Optional  = 0x010000,
+      Required  = 0x020000,
+      NonAtomic = 0x040000,
+      Copy      = 0x080000,
+      Retain    = 0x100000,
+      Assign    = 0x200000
+    };
+    enum ClassSpecifier
+    {
+      Template       = 0x0001,
+      Generic        = 0x0002,
+      Ref            = 0x0004,
+      Value          = 0x0008,
+      Interface      = 0x0010,
+      Struct         = 0x0020,
+      Union          = 0x0040,
+      Exception      = 0x0080,
+      Protocol       = 0x0100,
+      Category       = 0x0200,
+      SealedClass    = 0x0400,
+      AbstractClass  = 0x0800
+    };
+    enum GroupDocType
+    {
+      GROUPDOC_NORMAL,        //!< defgroup
+      GROUPDOC_ADD,           //!< addgroup
+      GROUPDOC_WEAK           //!< weakgroup
+    };                        //!< kind of group
+
+
+    Entry();
+    Entry(const Entry &);
+    ~Entry();
+    int getSize();
+    void addSpecialListItem(const char *listName,int index);
+    void createNavigationIndex(EntryNav *rootNav,FileStorage *storage,FileDef *fd);
+
+    // while parsing a file these function can be used to navigate/build the tree
+    void setParent(Entry *parent) { m_parent = parent; }
+    Entry *parent() const { return m_parent; }
+    const QList<Entry> *children() const { return m_sublist; }
+
+    /*! Adds entry \e as a child to this entry */
+    void	addSubEntry (Entry* e) ;
+    /*! Restore the state of this Entry to the default value it has
+     *  at construction time. 
+     */
+    void reset();
+    void marshall(StorageIntf *);
+    void unmarshall(StorageIntf *);
+
+  public:
+
+    // identification
+    int          section;     //!< entry type (see Sections);
+    QCString	 type;        //!< member type 
+    QCString	 name;        //!< member name
+    TagInfo     *tagInfo;     //!< tag file info
+
+    // content
+    Protection protection;    //!< class protection
+    MethodTypes mtype;        //!< signal, slot, (dcop) method, or property?
+    int  spec;                //!< class/member specifiers
+    int  initLines;           //!< define/variable initializer lines to show 
+    bool stat;                //!< static ?
+    bool explicitExternal;    //!< explicitly defined as external?
+    bool proto;               //!< prototype ?
+    bool subGrouping;         //!< automatically group class members?
+    bool callGraph;           //!< do we need to draw the call graph?
+    bool callerGraph;         //!< do we need to draw the caller graph?
+    Specifier    virt;        //!< virtualness of the entry 
+    QCString     args;        //!< member argument string
+    QCString     bitfields;   //!< member's bit fields
+    ArgumentList *argList;    //!< member arguments as a list
+    QList<ArgumentList> *tArgLists; //!< template argument declarations
+    QGString	 program;     //!< the program text
+    QGString     initializer; //!< initial value (for variables)
+    QCString     includeFile; //!< include file (2 arg of \\class, must be unique)
+    QCString     includeName; //!< include name (3 arg of \\class)
+    QCString     doc;         //!< documentation block (partly parsed)
+    int          docLine;     //!< line number at which the documentation was found
+    QCString     docFile;     //!< file in which the documentation was found
+    QCString     brief;       //!< brief description (doc block)
+    int          briefLine;   //!< line number at which the brief desc. was found
+    QCString     briefFile;   //!< file in which the brief desc. was found
+    QCString     inbodyDocs;  //!< documentation inside the body of a function
+    int          inbodyLine;  //!< line number at which the body doc was found
+    QCString     inbodyFile;  //!< file in which the body doc was found
+    QCString     relates;     //!< related class (doc block)
+    RelatesType  relatesType; //!< how relates is handled
+    QCString     read;        //!< property read accessor
+    QCString     write;       //!< property write accessor
+    QCString     inside;      //!< name of the class in which documents are found
+    QCString     exception;   //!< throw specification
+    ArgumentList *typeConstr; //!< where clause (C#) for type constraints
+    int          bodyLine;    //!< line number of the definition in the source
+    int          endBodyLine; //!< line number where the definition ends
+    int          mGrpId;      //!< member group id
+    QList<BaseInfo> *extends; //!< list of base classes    
+    QList<Grouping> *groups;  //!< list of groups this entry belongs to
+    QList<SectionInfo> *anchors; //!< list of anchors defined in this entry
+    QCString	fileName;     //!< file this entry was extracted from
+    int		startLine;    //!< start line of entry in the source
+    QList<ListItemInfo> *sli; //!< special lists (test/todo/bug/deprecated/..) this entry is in
+    bool        objc;         //!< Objective-C construct
+    bool        hidden;       //!< does this represent an entity that is hidden from the output
+    bool        artificial;   //!< Artificially introduced item
+    GroupDocType groupDocType;
+
+    static int  num;          //!< counts the total number of entries
+
+    /// return the command name used to define GROUPDOC_SEC
+    const char *groupDocCmd() const
+    {
+      switch( groupDocType ) 
+      {
+        case GROUPDOC_NORMAL: return "\\defgroup";
+        case GROUPDOC_ADD: return "\\addgroup";
+        case GROUPDOC_WEAK: return "\\weakgroup";
+        default: return "unknown group command";
+      }
+    }
+    Grouping::GroupPri_t groupingPri() const
+    {
+      if( section != GROUPDOC_SEC ) 
+      {
+        return Grouping::GROUPING_LOWEST;
+      }
+      switch( groupDocType ) 
+      {
+        case GROUPDOC_NORMAL: return Grouping::GROUPING_AUTO_DEF;
+        case GROUPDOC_ADD:    return Grouping::GROUPING_AUTO_ADD;
+        case GROUPDOC_WEAK:   return Grouping::GROUPING_AUTO_WEAK;
+        default: return Grouping::GROUPING_LOWEST;
+      }
+    }
+
+  private:  
+    void createSubtreeIndex(EntryNav *nav,FileStorage *storage,FileDef *fd);
+    Entry         *m_parent;    //!< parent node in the tree
+    QList<Entry>  *m_sublist;   //!< entries that are children of this one
+    Entry &operator=(const Entry &); 
+};
+
+class EntryNav
+{
+  public:
+    EntryNav(EntryNav *parent,Entry *e);
+   ~EntryNav();
+    void addChild(EntryNav *);
+    bool loadEntry(FileStorage *storage);
+    bool saveEntry(Entry *e,FileStorage *storage);
+    void setEntry(Entry *e);
+    void releaseEntry();
+    void changeSection(int section) { m_section = section; }
+    void setFileDef(FileDef *fd) { m_fileDef = fd; }
+
+    Entry *entry() const { return m_info; }
+    int section() const { return m_section; }
+    const QCString &type() const { return m_type; }
+    const QCString &name() const { return m_name; }
+    TagInfo *tagInfo() const { return m_tagInfo; }
+    const QList<EntryNav> *children() const { return m_subList; }
+    EntryNav *parent() const { return m_parent; }
+    FileDef *fileDef() const { return m_fileDef; }
+
+  private:
+
+    // navigation 
+    EntryNav        *m_parent;    //!< parent node in the tree
+    QList<EntryNav> *m_subList;   //!< entries that are children of this one
+
+    // identification
+    int          m_section;     //!< entry type (see Sections);
+    QCString	 m_type;        //!< member type 
+    QCString	 m_name;        //!< member name
+    TagInfo     *m_tagInfo;      //!< tag file info
+    FileDef     *m_fileDef;
+
+    Entry       *m_info;
+    int64        m_offset;
+    bool         m_noLoad;
+};
+
+
+typedef QList<Entry> EntryList;
+typedef QListIterator<Entry> EntryListIterator;
+
+typedef QList<EntryNav> EntryNavList;
+typedef QListIterator<EntryNav> EntryNavListIterator;
+
+#endif