diff options
Diffstat (limited to 'addon/doxmlparser')
25 files changed, 5472 insertions, 0 deletions
diff --git a/addon/doxmlparser/Doxyfile b/addon/doxmlparser/Doxyfile new file mode 100644 index 0000000..6225af2 --- /dev/null +++ b/addon/doxmlparser/Doxyfile @@ -0,0 +1,177 @@ +# Doxyfile 1.2.12-20011209 + +#--------------------------------------------------------------------------- +# General configuration options +#--------------------------------------------------------------------------- +PROJECT_NAME = doxmlparser +PROJECT_NUMBER = +OUTPUT_DIRECTORY = doc +OUTPUT_LANGUAGE = English +EXTRACT_ALL = YES +EXTRACT_PRIVATE = YES +EXTRACT_STATIC = YES +EXTRACT_LOCAL_CLASSES = YES +HIDE_UNDOC_MEMBERS = NO +HIDE_UNDOC_CLASSES = NO +BRIEF_MEMBER_DESC = YES +REPEAT_BRIEF = YES +ALWAYS_DETAILED_SEC = NO +INLINE_INHERITED_MEMB = NO +FULL_PATH_NAMES = NO +STRIP_FROM_PATH = +INTERNAL_DOCS = NO +STRIP_CODE_COMMENTS = YES +CASE_SENSE_NAMES = YES +SHORT_NAMES = NO +HIDE_SCOPE_NAMES = NO +VERBATIM_HEADERS = YES +SHOW_INCLUDE_FILES = YES +JAVADOC_AUTOBRIEF = NO +INHERIT_DOCS = YES +INLINE_INFO = YES +SORT_MEMBER_DOCS = YES +DISTRIBUTE_GROUP_DOC = NO +TAB_SIZE = 8 +GENERATE_TODOLIST = YES +GENERATE_TESTLIST = YES +GENERATE_BUGLIST = YES +ALIASES = +ENABLED_SECTIONS = +MAX_INITIALIZER_LINES = 30 +OPTIMIZE_OUTPUT_FOR_C = NO +SHOW_USED_FILES = YES +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- +QUIET = YES +WARNINGS = YES +WARN_IF_UNDOCUMENTED = YES +WARN_FORMAT = +WARN_LOGFILE = +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- +INPUT = include +FILE_PATTERNS = *.h +RECURSIVE = NO +EXCLUDE = +EXCLUDE_PATTERNS = +EXAMPLE_PATH = +EXAMPLE_PATTERNS = +EXAMPLE_RECURSIVE = NO +IMAGE_PATH = +INPUT_FILTER = +FILTER_SOURCE_FILES = NO +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- +SOURCE_BROWSER = YES +INLINE_SOURCES = NO +REFERENCED_BY_RELATION = YES +REFERENCES_RELATION = YES +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- +ALPHABETICAL_INDEX = NO +COLS_IN_ALPHA_INDEX = 5 +IGNORE_PREFIX = +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- +GENERATE_HTML = YES +HTML_OUTPUT = +HTML_HEADER = +HTML_FOOTER = +HTML_STYLESHEET = +HTML_ALIGN_MEMBERS = YES +GENERATE_HTMLHELP = NO +GENERATE_CHI = NO +BINARY_TOC = NO +TOC_EXPAND = NO +DISABLE_INDEX = NO +ENUM_VALUES_PER_LINE = 4 +GENERATE_TREEVIEW = NO +TREEVIEW_WIDTH = 250 +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- +GENERATE_LATEX = NO +LATEX_OUTPUT = +COMPACT_LATEX = NO +PAPER_TYPE = a4wide +EXTRA_PACKAGES = +LATEX_HEADER = +PDF_HYPERLINKS = NO +USE_PDFLATEX = NO +LATEX_BATCHMODE = NO +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- +GENERATE_RTF = NO +RTF_OUTPUT = +COMPACT_RTF = NO +RTF_HYPERLINKS = NO +RTF_STYLESHEET_FILE = +RTF_EXTENSIONS_FILE = +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- +GENERATE_MAN = NO +MAN_OUTPUT = +MAN_EXTENSION = +MAN_LINKS = NO +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- +GENERATE_XML = YES +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- +GENERATE_AUTOGEN_DEF = NO +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- +ENABLE_PREPROCESSING = YES +MACRO_EXPANSION = NO +EXPAND_ONLY_PREDEF = NO +SEARCH_INCLUDES = YES +INCLUDE_PATH = +INCLUDE_FILE_PATTERNS = +PREDEFINED = +EXPAND_AS_DEFINED = +SKIP_FUNCTION_MACROS = YES +#--------------------------------------------------------------------------- +# Configuration::addtions related to external references +#--------------------------------------------------------------------------- +TAGFILES = ../../qtools_docs/qtools.tag=../../../../qtools_docs/html +GENERATE_TAGFILE = +ALLEXTERNALS = NO +PERL_PATH = +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- +CLASS_DIAGRAMS = NO +HAVE_DOT = YES +CLASS_GRAPH = YES +COLLABORATION_GRAPH = YES +TEMPLATE_RELATIONS = YES +HIDE_UNDOC_RELATIONS = YES +INCLUDE_GRAPH = YES +INCLUDED_BY_GRAPH = YES +GRAPHICAL_HIERARCHY = YES +DOT_PATH = +DOTFILE_DIRS = +MAX_DOT_GRAPH_WIDTH = 1280 +MAX_DOT_GRAPH_HEIGHT = 1024 +GENERATE_LEGEND = YES +DOT_CLEANUP = YES +#--------------------------------------------------------------------------- +# Configuration::addtions related to the search engine +#--------------------------------------------------------------------------- +SEARCHENGINE = NO +CGI_NAME = +CGI_URL = +DOC_URL = +DOC_ABSPATH = +BIN_ABSPATH = +EXT_DOC_PATHS = diff --git a/addon/doxmlparser/doxygen.dtd b/addon/doxmlparser/doxygen.dtd new file mode 100644 index 0000000..5b293d0 --- /dev/null +++ b/addon/doxmlparser/doxygen.dtd @@ -0,0 +1,123 @@ +<!-- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! --> +<!-- NOTE: THIS DTD IS NOT UP TO DATE!!! DO NOT DEPEND ON IT --> +<!-- !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! --> + +<?xml version="1.0" encoding="ISO-8859-1"?> +<!-- DTD describing the grammar used in doxygen's XML output --> + +<!-- standard character entities --> +<!ENTITY lt "&#60;"> +<!ENTITY gt ">"> +<!ENTITY amp "&#38;"> +<!ENTITY apos "'"> +<!ENTITY quot """> + +<!-- required attributes for compounds --> +<!ENTITY % compound-req.att + 'id ID #REQUIRED + type (group|file|namespace| + class|struct|union| + interface|dispinterface| + valuetype|library) #REQUIRED' +> +<!-- required attributes for references --> +<!ENTITY % ref-req.att 'idref IDREF #REQUIRED' +> +<!-- required attributes for inheritance relations --> +<!ENTITY % inheritcompref-req.att + '%ref-req.att; + prot (public|protected|private) #REQUIRED + virt (non-virtual|virtual) #REQUIRED' +> + +<!-- required attributes for member sections --> +<!ENTITY % sec-req.att 'type (user + |public-type + |public-func + |public-attrib + |public-slot + |public-static-func + |public-static-attrib + |protected-type + |protected-func + |protected-attrib + |protected-slot + |protected-static-func + |protected-static-attrib + |private-type + |private-func + |private-attrib + |private-slot + |private-static-func + |private-static-attrib + |signal + |friend + |related + |define|prototype|typedef|enum|func|var + |dcop-func + |property + ) #REQUIRED + ' +> +<!-- required attributes for members --> +<!ENTITY % mem-req.att 'id ID #REQUIRED'> + +<!-- optional attributes for function --> +<!ENTITY % func-opt.att 'virt (virtual|pure-virtual) #IMPLIED'> + +<!-- elements --> +<!ELEMENT doxygen (compounddef)*> +<!ELEMENT compounddef (compoundname, + basecompoundref*, + derivedcompoundref*, + sectiondef*, + briefdescription, + detaileddescription, + inheritancegraph?, + collaborationgraph?, + sourcecode? + ) +> +<!ATTLIST compounddef %compound-req.att;> +<!ELEMENT compoundref (#PCDATA)> +<!ATTLIST compoundref %ref-req.att;> +<!ELEMENT memberref (#PCDATA)> +<!ATTLIST memberref %ref-req.att;> +<!ELEMENT basecompoundref EMPTY> +<!ATTLIST basecompoundref %inheritcompref-req.att;> +<!ELEMENT derivedcompoundref EMPTY> +<!ATTLIST derivedcompoundref %inheritcompref-req.att;> +<!ELEMENT sectionlist (sectiondef)+> +<!ELEMENT sectiondef (memberlist)> +<!ATTLIST sectiondef %sec-req.att;> +<!ELEMENT memberlist (functiondef|variabledef|typedef|definedef|enumdef)+> +<!ELEMENT functiondef (type?,name,paramlist)> +<!ATTLIST functiondef %mem-req.att; %func-opt.att;> +<!ELEMENT variabledef (type,name,array?,initializer?)> +<!ATTLIST variabledef %mem-req.att;> +<!ELEMENT typedef (type,name)> +<!ATTLIST typedef %mem-req.att;> +<!ELEMENT definedef (name,defparamlist?,initializer?)> +<!ATTLIST definedef %mem-req.att;> +<!ELEMENT enumdef (name,enumvaluelist)> +<!ATTLIST enumdef %mem-req.att;> +<!ELEMENT slotdef (type,name,paramlist)> +<!ATTLIST slotdef %mem-req.att;> +<!ELEMENT signaldef (type,name,paramlist)> +<!ATTLIST signaldef %mem-req.att;> +<!ELEMENT paramlist (param)*> +<!ELEMENT param (attributes?,type,declname?,defname?,array?,defval?)> +<!ELEMENT defparamlist (defarg)*> +<!ELEMENT defarg (#PCDATA)> +<!ELEMENT enumvaluelist (enumvalue)*> +<!ELEMENT enumvalue (name,initializer?)> +<!ELEMENT name (#PCDATA)> +<!ELEMENT compoundname (#PCDATA)> +<!ELEMENT declname (#PCDATA)> +<!ELEMENT defname (#PCDATA)> +<!ELEMENT type (#PCDATA|memberref|compoundref|compounddef)*> +<!ELEMENT defval (#PCDATA|memberref|compoundref)*> +<!ELEMENT initializer (#PCDATA|memberref|compoundref)*> +<!ELEMENT array (#PCDATA)> +<!ELEMENT attributes (#PCDATA)> + diff --git a/addon/doxmlparser/include/doxmlintf.h b/addon/doxmlparser/include/doxmlintf.h new file mode 100644 index 0000000..ec2950c --- /dev/null +++ b/addon/doxmlparser/include/doxmlintf.h @@ -0,0 +1,422 @@ +#ifndef _DOXMLINTF_H +#define _DOXMLINTF_H + +#include <qstring.h> + +class IMember; +class IDocIterator; + +class ILinkedText +{ + public: + enum Kind { Kind_Text, Kind_Ref }; + virtual Kind kind() const = 0; +}; + +class ILT_Text : public ILinkedText +{ + public: + virtual QString text() const = 0; +}; + +class ILT_Ref : public ILinkedText +{ + public: + virtual QString id() const = 0; + virtual QString external() const = 0; + virtual QString text() const = 0; +}; + +class ILinkedTextIterator +{ + public: + virtual ILinkedText *toFirst() = 0; + virtual ILinkedText *toLast() = 0; + virtual ILinkedText *toNext() = 0; + virtual ILinkedText *toPrev() = 0; + virtual ILinkedText *current() const = 0; + virtual void release() = 0; +}; + +class IParam +{ + public: + virtual ILinkedTextIterator *type() const = 0; + virtual QString declarationName() const = 0; + virtual QString definitionName() const = 0; + virtual QString attrib() const = 0; + virtual QString arraySpecifier() const = 0; + virtual ILinkedTextIterator *defaultValue() const = 0; +}; + +class IParamIterator +{ + public: + virtual IParam *toFirst() = 0; + virtual IParam *toLast() = 0; + virtual IParam *toNext() = 0; + virtual IParam *toPrev() = 0; + virtual IParam *current() const = 0; + virtual void release() = 0; +}; + +class IMemberReference +{ + public: + virtual IMember *member() const = 0; + virtual QString memberName() const = 0; +}; + +class IMemberReferenceIterator +{ + public: + virtual IMemberReference *toFirst() = 0; + virtual IMemberReference *toLast() = 0; + virtual IMemberReference *toNext() = 0; + virtual IMemberReference *toPrev() = 0; + virtual IMemberReference *current() const = 0; + virtual void release() = 0; +}; + +class IEnumValue +{ + public: + virtual QString name() const = 0; + virtual QString initializer() const = 0; +}; + +class IEnumValueIterator +{ + public: + virtual IEnumValue *toFirst() = 0; + virtual IEnumValue *toLast() = 0; + virtual IEnumValue *toNext() = 0; + virtual IEnumValue *toPrev() = 0; + virtual IEnumValue *current() const = 0; + virtual void release() = 0; +}; + +class IDoc +{ + public: + enum Kind + { + Para, // 0 -> IDocPara + Text, // 1 -> IDocText + MarkupModifier, // 2 -> IDocMarkupModifier + ItemizedList, // 3 -> IDocList + OrderedList, // 4 -> IDocList + ListItem, // 5 -> IDocListItem + ParameterList, // 6 -> IDocParameterList + Parameter, // 7 -> IDocParameter + SimpleSect, // 8 -> IDocSimpleSect + Title, // 9 -> IDocTitle + Ref, // 10 -> IDocRef + VariableList, // 11 -> IDocVariableList + VariableListEntry, // 12 -> IDocVariableListEntry + HRuler, // 13 -> IDocHRuler + LineBreak, // 14 -> IDocLineBreak + ULink, // 15 -> IDocULink + EMail, // 16 -> IDocEMail + Link, // 17 -> IDocLink + ProgramListing, // 18 -> IDocProgramListing + CodeLine, // 19 -> IDocCodeLine + Highlight, // 20 -> IDocHighlight + Anchor, // 21 -> IDocAnchor + Formula, // 22 -> IDocFormula + Image, // 23 -> IDocImage + DotFile, // 24 -> IDocDotFile + IndexEntry, // 25 -> IDocIndexEntry + Table, // 26 -> IDocTable + Row, // 27 -> IDocRow + Entry, // 28 -> IDocEntry + Section, // 29 -> IDocSection + Root // 30 -> IDocRoot + }; + virtual Kind kind() const = 0; +}; + +class IDocMarkup : public IDoc +{ + public: + enum Markup + { + Normal = 0x00, + Bold = 0x01, + Emphasis = 0x02, + ComputerOutput = 0x04, + Subscript = 0x08, + Superscript = 0x10, + SmallFont = 0x20, + Center = 0x40 + }; + +}; + +class IDocPara : public IDoc +{ + public: + virtual IDocIterator *contents() const = 0; +}; + +class IDocText : public IDocMarkup +{ + public: + virtual QString text() const = 0; + virtual int markup() const = 0; +}; + +class IDocMarkupModifier : public IDoc +{ +}; + +class IDocList : public IDoc +{ +}; + +class IDocListItem : public IDoc +{ +}; + +class IDocParameterList : public IDoc +{ +}; + +class IDocParameter : public IDoc +{ +}; + +class IDocSimpleSect : public IDoc +{ +}; + +class IDocTitle : public IDoc +{ + public: + virtual IDocIterator *title() const = 0; +}; + +class IDocRef : public IDoc +{ +}; + +class IDocVariableList : public IDoc +{ +}; + +class IDocVariableListEntry : public IDoc +{ +}; + +class IDocHRuler : public IDoc +{ +}; + +class IDocLineBreak : public IDoc +{ +}; + +class IDocULink : public IDoc +{ +}; + +class IDocEMail : public IDoc +{ +}; + +class IDocLink : public IDoc +{ +}; + +class IDocProgramListing : public IDoc +{ +}; + +class IDocCodeLine : public IDoc +{ +}; + +class IDocHighlight : public IDoc +{ +}; + +class IDocAnchor : public IDoc +{ +}; + +class IDocFormula : public IDoc +{ +}; + +class IDocImage : public IDoc +{ +}; + +class IDocDotFile : public IDoc +{ +}; + +class IDocIndexEntry : public IDoc +{ +}; + +class IDocTable : public IDoc +{ +}; + +class IDocRow : public IDoc +{ +}; + +class IDocEntry : public IDoc +{ +}; + +class IDocSection : public IDoc +{ + public: + virtual QString id() const = 0; + virtual int level() const = 0; + virtual IDocIterator *title() const = 0; +}; + +class IDocRoot : public IDoc +{ + public: + virtual IDocIterator *contents() const = 0; +}; + +class IDocIterator +{ + public: + virtual IDoc *toFirst() = 0; + virtual IDoc *toLast() = 0; + virtual IDoc *toNext() = 0; + virtual IDoc *toPrev() = 0; + virtual IDoc *current() const = 0; + virtual void release() = 0; +}; + +class IMember +{ + public: + virtual QString kind() const = 0; + virtual QString id() const = 0; + virtual QString protection() const = 0; + virtual QString virtualness() const = 0; + virtual ILinkedTextIterator *type() const = 0; + virtual QString name() const = 0; + virtual bool isConst() const = 0; + virtual bool isVolatile() const = 0; + virtual IParamIterator *params() const = 0; + virtual ILinkedTextIterator *initializer() const = 0; + virtual ILinkedTextIterator *exceptions() const = 0; + virtual IMemberReferenceIterator *references() const = 0; + virtual IMemberReferenceIterator *referencedBy() const = 0; + virtual int bodyStart() const = 0; + virtual int bodyEnd() const = 0; + virtual QString definitionFile() const = 0; + virtual int definitionLine() const = 0; + virtual IMemberReference *reimplements() const = 0; + virtual IMemberReferenceIterator *reimplementedBy() const = 0; + virtual IEnumValueIterator *enumValues() const = 0; + virtual IDocRoot *briefDescription() const = 0; + virtual IDocRoot *detailedDescription() const = 0; +}; + +class IMemberIterator +{ + public: + virtual IMember *toFirst() = 0; + virtual IMember *toLast() = 0; + virtual IMember *toNext() = 0; + virtual IMember *toPrev() = 0; + virtual IMember *current() const = 0; + virtual void release() = 0; +}; + +class ISection +{ + public: + virtual QString kind() const = 0; + virtual IMemberIterator *members() const = 0; +}; + +class ISectionIterator +{ + public: + virtual ISection *toFirst() = 0; + virtual ISection *toLast() = 0; + virtual ISection *toNext() = 0; + virtual ISection *toPrev() = 0; + virtual ISection *current() const = 0; + virtual void release() = 0; +}; + +class ICompound +{ + public: + virtual QString name() const = 0; + virtual QString id() const = 0; + virtual QString kind() const = 0; + virtual ISectionIterator *sections() const = 0; + virtual IDocRoot *briefDescription() const = 0; + virtual IDocRoot *detailedDescription() const = 0; +}; + +class ICompoundIterator +{ + public: + virtual ICompound *toFirst() = 0; + virtual ICompound *toLast() = 0; + virtual ICompound *toNext() = 0; + virtual ICompound *toPrev() = 0; + virtual ICompound *current() const = 0; + virtual void release() = 0; +}; + +/*! Root node of the object model. */ +class IDoxygen +{ + public: + /*! Returns an iterator that can be used to iterate over the list + * of compounds found in the project. + */ + virtual ICompoundIterator *compounds() const = 0; + + /*! Returns a compound given its unique \a id. If you have a + * compound id this function is much more efficient than iterating + * over the compound list. Returns 0 if the id is not valid. + */ + virtual ICompound *compoundById(const QString &id) const = 0; + + /*! Returns a compound given its name (including the scope). + * Returns 0 if the name is not found in the project. + */ + virtual ICompound *compoundByName(const QString &name) const = 0; + + /*! Returns an interface to a member given its id. + * @param id The member id. + */ + virtual IMember *memberById(const QString &id) const = 0; + + /*! Returns a list of all members with a certain name. + * @param name The name of the member. + */ + virtual IMemberIterator *memberByName(const QString &name) const = 0; + + /*! Releases the memory for the object hierarchy obtained by + * createdObjecModelFromXML(). First release all iterators before calling + * this function. + */ + virtual void release() = 0; +}; + +/*! Factory method that creates an object model given an XML file generated + * by doxygen. + * @param xmlFileName The name of the XML to parse. + * @returns An iterface to the object model. + */ +IDoxygen *createObjectModelFromXML(const char *xmlFileName); + +#endif diff --git a/addon/doxmlparser/src/Makefile.in b/addon/doxmlparser/src/Makefile.in new file mode 100644 index 0000000..049f969 --- /dev/null +++ b/addon/doxmlparser/src/Makefile.in @@ -0,0 +1,13 @@ +all clean depend: Makefile.doxmlparser + $(MAKE) -f Makefile.doxmlparser $@ + +distclean: clean + $(RM) -rf Makefile.doxmlparser doxmlparser.pro Makefile obj + +tmake: + $(ENV) $(PERL) $(TMAKE) doxmlparser.pro >Makefile.doxmlparser + +Makefile.doxmlparser: doxmlparser.pro + $(ENV) $(PERL) $(TMAKE) doxmlparser.pro >Makefile.doxmlparser + +install: diff --git a/addon/doxmlparser/src/basehandler.h b/addon/doxmlparser/src/basehandler.h new file mode 100644 index 0000000..d62cf74 --- /dev/null +++ b/addon/doxmlparser/src/basehandler.h @@ -0,0 +1,282 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#ifndef _BASEHANDLER_H +#define _BASEHANDLER_H + +#include <qxml.h> +#include <qdict.h> +#include <qstring.h> + +class IBaseHandler +{ + public: + virtual void setDelegate(QXmlDefaultHandler *delegate) = 0; + virtual QXmlDefaultHandler *delegate() const = 0; +}; + +class IFallBackHandler +{ + public: + virtual bool handleStartElement(const QString & name, + const QXmlAttributes & attrib) = 0; + virtual bool handleEndElement(const QString &name) = 0; +}; + +template<class T> class ElementMapper +{ + class StartElementHandler + { + typedef void (T::*Handler)(const QXmlAttributes &attrib); + public: + StartElementHandler() : m_parent(0) {} + StartElementHandler(T *parent, Handler h) + : m_parent(parent), m_handler(h) {} + void operator()(const QXmlAttributes &attrib) + { if (m_parent) (m_parent->*m_handler)(attrib); } + private: + T *m_parent; + Handler m_handler; + }; + + class EndElementHandler + { + typedef void (T::*Handler)(); + public: + EndElementHandler() : m_parent(0) {} + EndElementHandler(T *parent, Handler h) + : m_parent(parent), m_handler(h) {} + void operator()() + { if (m_parent) (m_parent->*m_handler)(); } + private: + T *m_parent; + Handler m_handler; + }; + + typedef StartElementHandler<T> StartElementHandlerT; + typedef EndElementHandler<T> EndElementHandlerT; + + public: + ElementMapper() : m_startHandlers(67), m_endHandlers(67) + { + m_startHandlers.setAutoDelete(TRUE); + m_endHandlers.setAutoDelete(TRUE); + } + virtual ~ElementMapper() + { + } + + void addStartHandler(const char *key) + { + m_startHandlers.insert(key,new StartElementHandlerT); + } + + void addStartHandler(const char *key, T *obj, void (T::*handler)(const QXmlAttributes &)) + { + m_startHandlers.insert(key,new StartElementHandlerT(obj,handler)); + } + + void addEndHandler(const char *key) + { + m_endHandlers.insert(key,new EndElementHandlerT); + } + + void addEndHandler(const char *key, T *obj, void (T::*handler)()) + { + m_endHandlers.insert(key,new EndElementHandlerT(obj,handler)); + } + + + protected: + QDict<StartElementHandlerT> m_startHandlers; + QDict<EndElementHandlerT> m_endHandlers; +}; + +template<class T> class BaseHandler : public IBaseHandler, + public QXmlDefaultHandler, + public ElementMapper<T> +{ + public: + BaseHandler() : m_delegateHandler(0), m_fallBackHandler(0) + { + } + + virtual ~BaseHandler() + { + ASSERT(m_delegateHandler==0); + } + + virtual bool startDocument() + { + return TRUE; + } + + virtual bool startElement( const QString & namespaceURI, + const QString & localName, + const QString & name, + const QXmlAttributes & attrib + ) + { + if (m_delegateHandler) + { + return m_delegateHandler->startElement(namespaceURI,localName,name,attrib); + } + if (!m_skipUntil.isEmpty()) // skip mode + { + if (m_skipUntil==name) m_skipCount++; + printf("skipping start tag %s count=%d\n",name.data(),m_skipCount); + return TRUE; + } + + StartElementHandlerT *handler = m_startHandlers[name]; + if (handler) + { + (*handler)(attrib); + //printf("found start tag %s\n",name.data()); + } + else if (!m_fallBackHandler || + !m_fallBackHandler->handleStartElement(name,attrib) + ) + { + printf("found unexpected tag `%s', skipping until matching end tag\n",name.data()); + m_skipUntil = name; + m_skipCount=1; + } + return TRUE; + } + + virtual bool endElement( const QString& namespaceURI, const QString& localName, const QString& name ) + { + if (m_delegateHandler) + { + return m_delegateHandler->endElement(namespaceURI,localName,name); + } + + if (name==m_skipUntil) + { + m_skipCount--; + printf("skipping end tag %s count=%d\n",name.data(),m_skipCount); + if (m_skipCount==0) + { + m_skipUntil=""; + } + //printf("found end tag %s\n",name.data()); + } + else if (m_skipUntil.isEmpty()) + { + EndElementHandlerT *handler = m_endHandlers[name]; + if (handler) + { + (*handler)(); + //printf("found end tag %s\n",name.data()); + } + else if (m_fallBackHandler) + { + m_fallBackHandler->handleEndElement(name); + } + } + m_curString=""; + return TRUE; + } + + bool skippedEntity ( const QString &s ) + { + if (m_delegateHandler) + { + return m_delegateHandler->skippedEntity(s); + } + + printf("Skipped unhandled entity %s\n",s.data()); + return TRUE; + } + + /*! called when a number of characters are received by the parser. + * \param ch the characters. + */ + virtual bool characters ( const QString & ch ) + { + if (m_delegateHandler) + { + return m_delegateHandler->characters(ch); + } + + //printf("Found characters \"%s\"\n",ch.data()); + m_curString+=ch; + return TRUE; + } + + void setDelegate(QXmlDefaultHandler *delegate) + { + m_delegateHandler = delegate; + } + + QXmlDefaultHandler *delegate() const + { + return m_delegateHandler; + } + + void setFallBackHandler(IFallBackHandler *h) + { + m_fallBackHandler = h; + } + + IFallBackHandler *fallBackHandler() const + { + return m_fallBackHandler; + } + + protected: + QString m_curString; + QString m_skipUntil; + int m_skipCount; + QXmlDefaultHandler *m_delegateHandler; + IFallBackHandler *m_fallBackHandler; +}; + +template<class T> class BaseFallBackHandler : public ElementMapper<T>, + public IFallBackHandler +{ + public: + BaseFallBackHandler() + { + } + virtual ~BaseFallBackHandler() + { + } + bool handleStartElement(const QString & name, + const QXmlAttributes & attrib) + { + StartElementHandlerT *handler = m_startHandlers[name]; + if (handler) + { + (*handler)(attrib); + return TRUE; + } + return FALSE; + } + bool handleEndElement(const QString &name) + { + EndElementHandlerT *handler = m_endHandlers[name]; + if (handler) + { + (*handler)(); + return TRUE; + } + return FALSE; + } +}; + + +#endif diff --git a/addon/doxmlparser/src/baseiterator.h b/addon/doxmlparser/src/baseiterator.h new file mode 100644 index 0000000..52a4c4e --- /dev/null +++ b/addon/doxmlparser/src/baseiterator.h @@ -0,0 +1,35 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ +#ifndef BASEITERATOR_H +#define BASEITERATOR_H + +#include <qlist.h> +#include <doxmlintf.h> + +template<class Intf,class ElemIntf,class ElemImpl> class BaseIterator : + public Intf, public QListIterator<ElemImpl> +{ + public: + BaseIterator(const QList<ElemImpl> &list) : QListIterator<ElemImpl>(list) {} + virtual ~BaseIterator() {} + virtual ElemIntf *toFirst() { return QListIterator<ElemImpl>::toFirst(); } + virtual ElemIntf *toLast() { return QListIterator<ElemImpl>::toLast(); } + virtual ElemIntf *toNext() { return QListIterator<ElemImpl>::operator++(); } + virtual ElemIntf *toPrev() { return QListIterator<ElemImpl>::operator--(); } + virtual ElemIntf *current() const { return QListIterator<ElemImpl>::current(); } + virtual void release() { delete this; } +}; + +#endif diff --git a/addon/doxmlparser/src/compoundhandler.cpp b/addon/doxmlparser/src/compoundhandler.cpp new file mode 100644 index 0000000..0b420bf --- /dev/null +++ b/addon/doxmlparser/src/compoundhandler.cpp @@ -0,0 +1,148 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#include "mainhandler.h" +#include "compoundhandler.h" +#include "dochandler.h" + +CompoundHandler::CompoundHandler(IBaseHandler *parent) + : m_parent(parent), m_brief(0), m_detailed(0), m_programListing(0) +{ + m_superClasses.setAutoDelete(TRUE); + m_subClasses.setAutoDelete(TRUE); + m_sections.setAutoDelete(TRUE); + + addEndHandler("compounddef",this,&CompoundHandler::endCompound); + + addStartHandler("compoundname"); + addEndHandler("compoundname",this,&CompoundHandler::endCompoundName); + + addStartHandler("derivedcompoundref",this,&CompoundHandler::addSubClass); + addEndHandler("derivedcompoundref"); + + addStartHandler("basecompoundref",this,&CompoundHandler::addSuperClass); + addEndHandler("basecompoundref"); + + addStartHandler("briefdescription",this,&CompoundHandler::startBriefDesc); + + addStartHandler("detaileddescription",this,&CompoundHandler::startDetailedDesc); + + addStartHandler("sectiondef",this,&CompoundHandler::startSection); + + addStartHandler("location",this,&CompoundHandler::startLocation); + addEndHandler("location"); + + addStartHandler("programlisting",this,&CompoundHandler::startProgramListing); +} + +CompoundHandler::~CompoundHandler() +{ + delete m_brief; + delete m_detailed; + delete m_programListing; +} + +void CompoundHandler::startSection(const QXmlAttributes& attrib) +{ + SectionHandler *sectHandler = new SectionHandler(this); + sectHandler->startSection(attrib); + m_sections.append(sectHandler); +} + +void CompoundHandler::startBriefDesc(const QXmlAttributes& attrib) +{ + DocHandler *docHandler = new DocHandler(this); + docHandler->startDoc(attrib); + m_brief = docHandler; +} + +void CompoundHandler::startDetailedDesc(const QXmlAttributes& attrib) +{ + DocHandler *docHandler = new DocHandler(this); + docHandler->startDoc(attrib); + m_detailed = docHandler; +} + +void CompoundHandler::startProgramListing(const QXmlAttributes& attrib) +{ + ProgramListingHandler *plHandler = new ProgramListingHandler(this); + plHandler->startProgramListing(attrib); + m_programListing = plHandler; +} + +void CompoundHandler::startCompound(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + m_id = attrib.value("id"); + m_kind = attrib.value("kind"); + printf("startCompound(id=`%s' type=`%s')\n",m_id.data(),m_kind.data()); +} + +void CompoundHandler::startLocation(const QXmlAttributes& attrib) +{ + m_defFile = attrib.value("file"); + m_defLine = attrib.value("line").toInt(); +} + +void CompoundHandler::endCompound() +{ + printf("endCompound()\n"); + m_parent->setDelegate(0); +} + +void CompoundHandler::endCompoundName() +{ + m_name = m_curString.stripWhiteSpace(); + printf("Compound name `%s'\n",m_name.data()); +} + +void CompoundHandler::addSuperClass(const QXmlAttributes& attrib) +{ + SuperClass *sc=new SuperClass( + attrib.value("idref"), + attrib.value("prot"), + attrib.value("virt") + ); + printf("super class id=`%s' prot=`%s' virt=`%s'\n", + sc->m_id.data(), + sc->m_protection.data(), + sc->m_virtualness.data()); + m_superClasses.append(sc); +} + +void CompoundHandler::addSubClass(const QXmlAttributes& attrib) +{ + SubClass *sc = new SubClass( + attrib.value("idref"), + attrib.value("prot"), + attrib.value("virt") + ); + printf("sub class id=`%s' prot=`%s' virt=`%s'\n", + sc->m_id.data(), + sc->m_protection.data(), + sc->m_virtualness.data()); + m_subClasses.append(sc); +} + +void CompoundHandler::initialize(MainHandler *m) +{ + QListIterator<ISection> msi(m_sections); + SectionHandler *sec; + for (;(sec=(SectionHandler *)msi.current());++msi) + { + sec->initialize(m); + } +} + diff --git a/addon/doxmlparser/src/compoundhandler.h b/addon/doxmlparser/src/compoundhandler.h new file mode 100644 index 0000000..99db5d8 --- /dev/null +++ b/addon/doxmlparser/src/compoundhandler.h @@ -0,0 +1,101 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ +#ifndef _COMPOUNDHANDLER_H +#define _COMPOUNDHANDLER_H + +#include <qstring.h> +#include <qlist.h> +#include <qxml.h> +#include <doxmlintf.h> + +#include "basehandler.h" +#include "baseiterator.h" +#include "sectionhandler.h" + +class MainHandler; +class DocHandler; +class ProgramListingHandler; + +class CompoundIterator : public BaseIterator<ICompoundIterator,ICompound,ICompound> +{ + public: + CompoundIterator(const QList<ICompound> &list) : + BaseIterator<ICompoundIterator,ICompound,ICompound>(list) {} +}; + +class CompoundHandler : public ICompound, public BaseHandler<CompoundHandler> +{ + public: + virtual void startSection(const QXmlAttributes& attrib); + virtual void startCompound(const QXmlAttributes& attrib); + virtual void addSuperClass(const QXmlAttributes& attrib); + virtual void addSubClass(const QXmlAttributes& attrib); + virtual void endCompound(); + virtual void endCompoundName(); + virtual void startBriefDesc(const QXmlAttributes& attrib); + virtual void startDetailedDesc(const QXmlAttributes& attrib); + virtual void startLocation(const QXmlAttributes& attrib); + virtual void startProgramListing(const QXmlAttributes& attrib); + + CompoundHandler(IBaseHandler *parent); + virtual ~CompoundHandler(); + void initialize(MainHandler *m); + + // ICompound implementation + QString name() const { return m_name; } + QString id() const { return m_id; } + QString kind() const { return m_kind; } + ISectionIterator *sections() const + { return new SectionIterator(m_sections); } + virtual IDocRoot *briefDescription() const + { return m_brief; } + virtual IDocRoot *detailedDescription() const + { return m_detailed; } + + + private: + struct SuperClass + { + SuperClass(const QString &id,const QString &prot,const QString &virt) : + m_id(id),m_protection(prot),m_virtualness(virt) {} + + QString m_id; + QString m_protection; + QString m_virtualness; + }; + struct SubClass + { + SubClass(const QString &id,const QString &prot,const QString &virt) : + m_id(id),m_protection(prot),m_virtualness(virt) {} + + QString m_id; + QString m_protection; + QString m_virtualness; + }; + QList<SuperClass> m_superClasses; + QList<SubClass> m_subClasses; + QList<ISection> m_sections; + IBaseHandler *m_parent; + DocHandler *m_brief; + DocHandler *m_detailed; + ProgramListingHandler *m_programListing; + QString m_id; + QString m_kind; + QString m_name; + QString m_defFile; + int m_defLine; +}; + +#endif diff --git a/addon/doxmlparser/src/dochandler.cpp b/addon/doxmlparser/src/dochandler.cpp new file mode 100644 index 0000000..3350cf4 --- /dev/null +++ b/addon/doxmlparser/src/dochandler.cpp @@ -0,0 +1,1479 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#include "dochandler.h" +#include <qmap.h> + +class TypeNameMapper +{ + public: + TypeNameMapper() + { + m_typeNameMap.insert("see", SimpleSectHandler::See); + m_typeNameMap.insert("return", SimpleSectHandler::Return); + m_typeNameMap.insert("author", SimpleSectHandler::Author); + m_typeNameMap.insert("version", SimpleSectHandler::Version); + m_typeNameMap.insert("since", SimpleSectHandler::Since); + m_typeNameMap.insert("date", SimpleSectHandler::Date); + m_typeNameMap.insert("bug", SimpleSectHandler::Bug); + m_typeNameMap.insert("note", SimpleSectHandler::Note); + m_typeNameMap.insert("warning", SimpleSectHandler::Warning); + m_typeNameMap.insert("par", SimpleSectHandler::Par); + m_typeNameMap.insert("deprecated",SimpleSectHandler::Deprecated); + m_typeNameMap.insert("pre", SimpleSectHandler::Pre); + m_typeNameMap.insert("post", SimpleSectHandler::Post); + m_typeNameMap.insert("invariant", SimpleSectHandler::Invar); + m_typeNameMap.insert("remark", SimpleSectHandler::Remark); + m_typeNameMap.insert("attention", SimpleSectHandler::Attention); + m_typeNameMap.insert("todo", SimpleSectHandler::Todo); + m_typeNameMap.insert("test", SimpleSectHandler::Test); + m_typeNameMap.insert("rcs", SimpleSectHandler::RCS); + m_typeNameMap.insert("enumvalues",SimpleSectHandler::EnumValues); + m_typeNameMap.insert("examples", SimpleSectHandler::Examples); + } + SimpleSectHandler::Types stringToType(const QString &typeStr) + { + return m_typeNameMap[typeStr]; + } + private: + QMap<QString,SimpleSectHandler::Types> m_typeNameMap; +}; + +static TypeNameMapper g_typeMapper; + + +//---------------------------------------------------------------------- +// MarkupHandler +//---------------------------------------------------------------------- + +MarkupHandler::MarkupHandler(QList<IDoc> &children,QString &curString) + : m_children(children), m_curString(curString), m_curMarkup(IDocMarkup::Normal) +{ + addStartHandler("bold",this,&MarkupHandler::startBold); + addEndHandler("bold",this,&MarkupHandler::endBold); + + addStartHandler("emphasis",this,&MarkupHandler::startEmphasis); + addEndHandler("emphasis",this,&MarkupHandler::endEmphasis); + + addStartHandler("computeroutput",this,&MarkupHandler::startComputerOutput); + addEndHandler("computeroutput",this,&MarkupHandler::endComputerOutput); + + addStartHandler("center",this,&MarkupHandler::startCenter); + addEndHandler("center",this,&MarkupHandler::endCenter); + + addStartHandler("small",this,&MarkupHandler::startSmallFont); + addEndHandler("small",this,&MarkupHandler::endSmallFont); + + addStartHandler("subscript",this,&MarkupHandler::startSubscript); + addEndHandler("subscript",this,&MarkupHandler::endSubscript); + + addStartHandler("superscript",this,&MarkupHandler::startSuperscript); + addEndHandler("superscript",this,&MarkupHandler::endSuperscript); +} + +MarkupHandler::~MarkupHandler() +{ +} + +void MarkupHandler::addTextNode() +{ + if (!m_curString.isEmpty()) + { + m_children.append(new TextNode(m_curString,m_curMarkup)); + printf("addTextNode() text=%s markup=%x\n",m_curString.data(),m_curMarkup); + m_curString=""; + } +} + +void MarkupHandler::startBold(const QXmlAttributes & /*attrib*/) +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Bold,TRUE)); + m_curMarkup |= IDocMarkup::Bold; +} + +void MarkupHandler::endBold() +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Bold,FALSE)); + m_curMarkup &= ~IDocMarkup::Bold; +} + +void MarkupHandler::startEmphasis(const QXmlAttributes & /*attrib*/) +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Emphasis,TRUE)); + m_curMarkup |= IDocMarkup::Emphasis; +} + +void MarkupHandler::endEmphasis() +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Emphasis,FALSE)); + m_curMarkup &= ~IDocMarkup::Emphasis; +} + +void MarkupHandler::startComputerOutput(const QXmlAttributes & /*attrib*/) +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::ComputerOutput,TRUE)); + m_curMarkup |= IDocMarkup::ComputerOutput; +} + +void MarkupHandler::endComputerOutput() +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::ComputerOutput,FALSE)); + m_curMarkup &= ~IDocMarkup::ComputerOutput; +} + +void MarkupHandler::startCenter(const QXmlAttributes & /*attrib*/) +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Center,TRUE)); + m_curMarkup |= IDocMarkup::Center; +} + +void MarkupHandler::endCenter() +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Center,FALSE)); + m_curMarkup &= ~IDocMarkup::Center; +} + +void MarkupHandler::startSmallFont(const QXmlAttributes & /*attrib*/) +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::SmallFont,TRUE)); + m_curMarkup |= IDocMarkup::SmallFont; +} + +void MarkupHandler::endSmallFont() +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::SmallFont,FALSE)); + m_curMarkup &= ~IDocMarkup::SmallFont; +} + +void MarkupHandler::startSubscript(const QXmlAttributes & /*attrib*/) +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Subscript,TRUE)); + m_curMarkup |= IDocMarkup::Subscript; +} + +void MarkupHandler::endSubscript() +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Subscript,FALSE)); + m_curMarkup &= ~IDocMarkup::Subscript; +} + +void MarkupHandler::startSuperscript(const QXmlAttributes & /*attrib*/) +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Superscript,TRUE)); + m_curMarkup |= IDocMarkup::Superscript; +} + +void MarkupHandler::endSuperscript() +{ + addTextNode(); + m_children.append(new MarkupModifierNode(IDocMarkup::Superscript,FALSE)); + m_curMarkup &= ~IDocMarkup::Superscript; +} + +//---------------------------------------------------------------------- +// ListItemHandler +//---------------------------------------------------------------------- + +ListItemHandler::ListItemHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + + addEndHandler("listitem",this,&ListItemHandler::endListItem); + + addStartHandler("para",this,&ListItemHandler::startParagraph); +} + +ListItemHandler::~ListItemHandler() +{ +} + +void ListItemHandler::startListItem(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("start list item handler\n"); +} + +void ListItemHandler::endListItem() +{ + printf("end list item handler\n"); + m_parent->setDelegate(0); +} + +void ListItemHandler::startParagraph(const QXmlAttributes& attrib) +{ + ParagraphHandler *parHandler = new ParagraphHandler(this); + parHandler->startParagraph(attrib); + m_children.append(parHandler); +} + +//---------------------------------------------------------------------- +// ListHandler +//---------------------------------------------------------------------- + +ListHandler::ListHandler(Kind k,IBaseHandler *parent) + : m_parent(parent), m_kind(k) +{ + m_children.setAutoDelete(TRUE); + const char *endListName=0; + switch(k) + { + case ItemizedList : endListName="itemizedlist"; break; + case OrderedList : endListName="orderedlist"; break; + default: ASSERT(0); + } + addEndHandler(endListName,this,&ListHandler::endList); + + addStartHandler("listitem",this,&ListHandler::startListItem); +} + +ListHandler::~ListHandler() +{ +} + +void ListHandler::startList(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); +} + +void ListHandler::endList() +{ + m_parent->setDelegate(0); +} + +void ListHandler::startListItem(const QXmlAttributes& attrib) +{ + ListItemHandler *liHandler = new ListItemHandler(this); + liHandler->startListItem(attrib); + m_children.append(liHandler); +} + +//---------------------------------------------------------------------- +// ParameterHandler +//---------------------------------------------------------------------- + +ParameterHandler::ParameterHandler(IBaseHandler *parent) : + m_parent(parent), m_description(0) +{ + addEndHandler("parametername",this,&ParameterHandler::endParameterName); + addEndHandler("parameterdescription",this,&ParameterHandler::endParameterDescription); + addStartHandler("para",this,&ParameterHandler::startParagraph); +} + +ParameterHandler::~ParameterHandler() +{ + delete m_description; +} + +void ParameterHandler::startParameterName(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); +} + +void ParameterHandler::endParameterName() +{ + m_name = m_curString; + printf("parameter %s\n",m_name.data()); + m_curString=""; + m_parent->setDelegate(0); +} + +void ParameterHandler::startParameterDescription(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); +} + +void ParameterHandler::endParameterDescription() +{ + m_parent->setDelegate(0); +} + +void ParameterHandler::startParagraph(const QXmlAttributes& attrib) +{ + ASSERT(m_description==0); + m_description = new ParagraphHandler(this); + m_description->startParagraph(attrib); +} + +//---------------------------------------------------------------------- +// ParameterListHandler +//---------------------------------------------------------------------- + +ParameterListHandler::ParameterListHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("parameterlist",this,&ParameterListHandler::endParameterList); + addStartHandler("parametername",this,&ParameterListHandler::startParameterName); + addStartHandler("parameterdescription",this,&ParameterListHandler::startParameterDescription); + addStartHandler("title"); + addEndHandler("title"); + m_parameters.setAutoDelete(TRUE); + m_curParam=0; +} + +ParameterListHandler::~ParameterListHandler() +{ +} + +void ParameterListHandler::startParameterList(const QXmlAttributes& attrib) +{ + QString kind = attrib.value("kind"); + if (kind=="retval") m_type=RetVal; + else if (kind=="exception") m_type=Exception; + else if (kind=="param") m_type=Param; + else + { + printf("Error: invalid parameterlist type: %s\n",kind.data()); + } + printf("parameterlist kind=%s\n",kind.data()); + m_parent->setDelegate(this); +} + +void ParameterListHandler::endParameterList() +{ + m_parent->setDelegate(0); +} + +void ParameterListHandler::startParameterName(const QXmlAttributes& attrib) +{ + m_curParam = new ParameterHandler(this); + m_parameters.append(m_curParam); + m_curParam->startParameterName(attrib); +} + +void ParameterListHandler::startParameterDescription(const QXmlAttributes& attrib) +{ + ASSERT(m_curParam!=0); + m_curParam->startParameterDescription(attrib); +} + +//---------------------------------------------------------------------- +// LinkHandler +//---------------------------------------------------------------------- + +LinkHandler::LinkHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("link",this,&LinkHandler::endLink); +} + +LinkHandler::~LinkHandler() +{ +} + +void LinkHandler::startLink(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + printf("Start link\n"); + m_ref = attrib.value("linkend"); + m_curString=""; +} + +void LinkHandler::endLink() +{ + m_text = m_curString; + m_curString=""; + m_parent->setDelegate(0); + printf("End link\n"); +} + +//---------------------------------------------------------------------- +// EMailHandler +//---------------------------------------------------------------------- + +EMailHandler::EMailHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("email",this,&EMailHandler::endEMail); +} + +EMailHandler::~EMailHandler() +{ +} + +void EMailHandler::startEMail(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("Start email\n"); + m_curString=""; +} + +void EMailHandler::endEMail() +{ + m_address = m_curString; + m_curString=""; + m_parent->setDelegate(0); + printf("End email\n"); +} + +//---------------------------------------------------------------------- +// ULinkHandler +//---------------------------------------------------------------------- + +ULinkHandler::ULinkHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("ulink",this,&ULinkHandler::endULink); +} + +ULinkHandler::~ULinkHandler() +{ +} + +void ULinkHandler::startULink(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + printf("Start ulink\n"); + m_url = attrib.value("url"); + m_curString=""; +} + +void ULinkHandler::endULink() +{ + m_text = m_curString; + m_curString=""; + m_parent->setDelegate(0); + printf("End ulink\n"); +} + +//---------------------------------------------------------------------- +// LineBreakHandler +//---------------------------------------------------------------------- + +LineBreakHandler::LineBreakHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("linebreak",this,&LineBreakHandler::endLineBreak); +} + +LineBreakHandler::~LineBreakHandler() +{ +} + +void LineBreakHandler::startLineBreak(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("Start linebreak\n"); +} + +void LineBreakHandler::endLineBreak() +{ + m_parent->setDelegate(0); + printf("End linebreak\n"); +} + +//---------------------------------------------------------------------- +// HRulerHandler +//---------------------------------------------------------------------- + +HRulerHandler::HRulerHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("hruler",this,&HRulerHandler::endHRuler); +} + +HRulerHandler::~HRulerHandler() +{ +} + +void HRulerHandler::startHRuler(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("Start hruler\n"); +} + +void HRulerHandler::endHRuler() +{ + m_parent->setDelegate(0); + printf("End hruler\n"); +} + +//---------------------------------------------------------------------- +// RefHandler +//---------------------------------------------------------------------- + +RefHandler::RefHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("ref",this,&RefHandler::endRef); +} + +RefHandler::~RefHandler() +{ +} + +void RefHandler::startRef(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + m_refId = attrib.value("idref"); + m_anchor = attrib.value("anchor"); + printf("Start ref refId=%s anchor=%s\n",m_refId.data(),m_anchor.data()); + m_curString=""; +} + +void RefHandler::endRef() +{ + m_linkText = m_curString; + m_parent->setDelegate(0); + printf("End ref: text=`%s'\n",m_linkText.data()); +} + + +//---------------------------------------------------------------------- +// TitleHandler +//---------------------------------------------------------------------- + +TitleHandler::TitleHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + m_markupHandler = new MarkupHandler(m_children,m_curString); + setFallBackHandler(m_markupHandler); + addStartHandler("ref",this,&TitleHandler::startRef); + addEndHandler("title",this,&TitleHandler::endTitle); +} + +TitleHandler::~TitleHandler() +{ + delete m_markupHandler; +} + +void TitleHandler::startTitle(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("Start title\n"); + m_curString=""; +} + +void TitleHandler::endTitle() +{ + addTextNode(); + m_parent->setDelegate(0); + printf("End title\n"); +} + +void TitleHandler::addTextNode() +{ + if (!m_curString.isEmpty()) + { + m_children.append(new TextNode(m_curString,m_markupHandler->markup())); + printf("addTextNode() text=\"%s\" markup=%x\n", + m_curString.data(),m_markupHandler->markup()); + m_curString=""; + } +} + +void TitleHandler::startRef(const QXmlAttributes& attrib) +{ + RefHandler *ref = new RefHandler(this); + ref->startRef(attrib); + m_children.append(ref); +} + +IDocIterator *TitleHandler::title() const +{ + return new TitleIterator(*this); +} + +//---------------------------------------------------------------------- +// SimpleSectHandler +//---------------------------------------------------------------------- + +SimpleSectHandler::SimpleSectHandler(IBaseHandler *parent) + : m_parent(parent), m_paragraph(0), m_title(0) +{ + addStartHandler("title",this,&SimpleSectHandler::startTitle); + addStartHandler("para",this,&SimpleSectHandler::startParagraph); + addEndHandler("simplesect",this,&SimpleSectHandler::endSimpleSect); +} + +SimpleSectHandler::~SimpleSectHandler() +{ +} + +void SimpleSectHandler::startSimpleSect(const QXmlAttributes& attrib) +{ + m_type = g_typeMapper.stringToType(attrib.value("kind")); + printf("start simple section %s\n",attrib.value("kind").data()); + m_parent->setDelegate(this); +} + +void SimpleSectHandler::endSimpleSect() +{ + printf("end simple section\n"); + m_parent->setDelegate(0); +} + +void SimpleSectHandler::startTitle(const QXmlAttributes& attrib) +{ + ASSERT(m_title==0); + m_title = new TitleHandler(this); + m_title->startTitle(attrib); +} + +void SimpleSectHandler::startParagraph(const QXmlAttributes& attrib) +{ + ASSERT(m_paragraph==0); + m_paragraph = new ParagraphHandler(this); + m_paragraph->startParagraph(attrib); +} + +//---------------------------------------------------------------------- +// VariableListEntryHandler +//---------------------------------------------------------------------- + +VariableListEntryHandler::VariableListEntryHandler(IBaseHandler *parent) + : m_parent(parent), m_description(0) +{ + addStartHandler("term",this,&VariableListEntryHandler::startTerm); + addEndHandler("term",this,&VariableListEntryHandler::endTerm); + addStartHandler("para",this,&VariableListEntryHandler::startParagraph); + addEndHandler("varlistentry",this,&VariableListEntryHandler::endVarListEntry); + addEndHandler("listitem",this,&VariableListEntryHandler::endListItem); +} + +VariableListEntryHandler::~VariableListEntryHandler() +{ + delete m_description; +} + +void VariableListEntryHandler::startVarListEntry(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("start varlistentry\n"); +} + +void VariableListEntryHandler::endVarListEntry() +{ + m_parent->setDelegate(0); + printf("end varlistentry\n"); +} + +void VariableListEntryHandler::startListItem(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("start listitem\n"); +} + +void VariableListEntryHandler::endListItem() +{ + m_parent->setDelegate(0); + printf("end listitem\n"); +} + +void VariableListEntryHandler::startTerm(const QXmlAttributes& /*attrib*/) +{ + m_curString=""; +} + +void VariableListEntryHandler::endTerm() +{ + m_term = m_curString; + printf("term=%s\n",m_term.data()); +} + +void VariableListEntryHandler::startParagraph(const QXmlAttributes& attrib) +{ + ASSERT(m_description==0); + m_description = new ParagraphHandler(this); + m_description->startParagraph(attrib); +} + + + +//---------------------------------------------------------------------- +// VariableListHandler +//---------------------------------------------------------------------- + +VariableListHandler::VariableListHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_entries.setAutoDelete(TRUE); + addStartHandler("varlistentry",this,&VariableListHandler::startVarListEntry); + addStartHandler("listitem",this,&VariableListHandler::startListItem); + addEndHandler("variablelist",this,&VariableListHandler::endVariableList); +} + +VariableListHandler::~VariableListHandler() +{ +} + +void VariableListHandler::startVariableList(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("start variablelist\n"); +} + +void VariableListHandler::endVariableList() +{ + printf("end variablelist\n"); + m_parent->setDelegate(0); +} + +void VariableListHandler::startVarListEntry(const QXmlAttributes& attrib) +{ + VariableListEntryHandler *vle = new VariableListEntryHandler(this); + vle->startVarListEntry(attrib); + m_curEntry = vle; + m_entries.append(vle); +} + +void VariableListHandler::startListItem(const QXmlAttributes& attrib) +{ + ASSERT(m_curEntry!=0); + m_curEntry->startListItem(attrib); +} + +//---------------------------------------------------------------------- +// HighlightHandler +//---------------------------------------------------------------------- + +HighlightHandler::HighlightHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("highlight",this,&HighlightHandler::endHighlight); +} + +HighlightHandler::~HighlightHandler() +{ +} + +void HighlightHandler::startHighlight(const QXmlAttributes& attrib) +{ + m_class = attrib.value("class"); + m_curString=""; + m_parent->setDelegate(this); +} + +void HighlightHandler::endHighlight() +{ + m_text = m_curString; + printf("highlight class=`%s' text=`%s'\n",m_class.data(),m_text.data()); + m_parent->setDelegate(0); +} + +//---------------------------------------------------------------------- +// CodeLineHandler +//---------------------------------------------------------------------- + +CodeLineHandler::CodeLineHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + addEndHandler("codeline",this,&CodeLineHandler::endCodeLine); + addEndHandler("linenumber",this,&CodeLineHandler::endLineNumber); + addStartHandler("highlight",this,&CodeLineHandler::startHighlight); + addStartHandler("ref",this,&CodeLineHandler::startRef); + m_lineNumber = 0; +} + +CodeLineHandler::~CodeLineHandler() +{ +} + +void CodeLineHandler::startCodeLine(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("start codeline\n"); +} + +void CodeLineHandler::endCodeLine() +{ + addTextNode(); + printf("end codeline\n"); + m_parent->setDelegate(0); +} + +void CodeLineHandler::startLineNumber(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + printf("start linenumber\n"); + m_lineNumber = attrib.value("line").toInt(); + m_refId = attrib.value("refid"); +} + +void CodeLineHandler::endLineNumber() +{ + m_parent->setDelegate(0); +} + +void CodeLineHandler::startHighlight(const QXmlAttributes& attrib) +{ + addTextNode(); + HighlightHandler *hlh = new HighlightHandler(this); + m_children.append(hlh); + hlh->startHighlight(attrib); +} + +void CodeLineHandler::startRef(const QXmlAttributes& attrib) +{ + addTextNode(); + RefHandler *rh = new RefHandler(this); + m_children.append(rh); + rh->startRef(attrib); +} + +void CodeLineHandler::addTextNode() +{ + if (!m_curString.isEmpty()) + { + m_children.append(new TextNode(m_curString,IDocMarkup::Normal)); + printf("addTextNode() text=\"%s\"\n", + m_curString.data()); + m_curString=""; + } +} + +//---------------------------------------------------------------------- +// ProgramListingHandler +//---------------------------------------------------------------------- + +ProgramListingHandler::ProgramListingHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + m_hasLineNumber=FALSE; + addEndHandler("programlisting",this,&ProgramListingHandler::endProgramListing); + + addStartHandler("linenumber",this,&ProgramListingHandler::startLineNumber); + addStartHandler("codeline",this,&ProgramListingHandler::startCodeLine); +} + +ProgramListingHandler::~ProgramListingHandler() +{ +} + +void ProgramListingHandler::startProgramListing(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("start programlisting\n"); +} + +void ProgramListingHandler::endProgramListing() +{ + printf("end programlisting\n"); + m_parent->setDelegate(0); +} + +void ProgramListingHandler::startLineNumber(const QXmlAttributes& attrib) +{ + CodeLineHandler *clh = new CodeLineHandler(this); + m_children.append(clh); + m_hasLineNumber=TRUE; + clh->startLineNumber(attrib); +} + +void ProgramListingHandler::startCodeLine(const QXmlAttributes& attrib) +{ + CodeLineHandler *clh = 0; + if (!m_hasLineNumber) + { + clh = new CodeLineHandler(this); + m_children.append(clh); + } + else + { + clh = m_children.getLast(); + } + ASSERT(clh!=0); + clh->startCodeLine(attrib); + m_hasLineNumber=FALSE; +} + +//---------------------------------------------------------------------- +// FormulaHandler +//---------------------------------------------------------------------- + +FormulaHandler::FormulaHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("formula",this,&FormulaHandler::endFormula); +} + +FormulaHandler::~FormulaHandler() +{ +} + +void FormulaHandler::startFormula(const QXmlAttributes& attrib) +{ + m_id = attrib.value("id"); + m_curString=""; + m_parent->setDelegate(this); +} + +void FormulaHandler::endFormula() +{ + m_text = m_curString; + printf("formula id=`%s' text=`%s'\n",m_id.data(),m_text.data()); + m_parent->setDelegate(0); +} + +//---------------------------------------------------------------------- +// ImageHandler +//---------------------------------------------------------------------- + +ImageHandler::ImageHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("image",this,&ImageHandler::endImage); +} + +ImageHandler::~ImageHandler() +{ +} + +void ImageHandler::startImage(const QXmlAttributes& attrib) +{ + m_name = attrib.value("name"); + m_curString=""; + m_parent->setDelegate(this); +} + +void ImageHandler::endImage() +{ + m_caption = m_curString; + printf("image name=`%s' caption=`%s'\n",m_name.data(),m_caption.data()); + m_parent->setDelegate(0); +} + +//---------------------------------------------------------------------- +// DotFileHandler +//---------------------------------------------------------------------- + +DotFileHandler::DotFileHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("image",this,&DotFileHandler::endDotFile); +} + +DotFileHandler::~DotFileHandler() +{ +} + +void DotFileHandler::startDotFile(const QXmlAttributes& attrib) +{ + m_name = attrib.value("name"); + m_curString=""; + m_parent->setDelegate(this); +} + +void DotFileHandler::endDotFile() +{ + m_caption = m_curString; + printf("image name=`%s' caption=`%s'\n",m_name.data(),m_caption.data()); + m_parent->setDelegate(0); +} + +//---------------------------------------------------------------------- +// IndexEntryHandler +//---------------------------------------------------------------------- + +IndexEntryHandler::IndexEntryHandler(IBaseHandler *parent) + : m_parent(parent) +{ + addEndHandler("indexentry",this,&IndexEntryHandler::endIndexEntry); + addStartHandler("primaryie",this,&IndexEntryHandler::startPrimaryIE); + addEndHandler("primaryie",this,&IndexEntryHandler::endPrimaryIE); + addStartHandler("secondaryie",this,&IndexEntryHandler::startSecondaryIE); + addEndHandler("secondaryie",this,&IndexEntryHandler::endSecondaryIE); +} + +IndexEntryHandler::~IndexEntryHandler() +{ +} + +void IndexEntryHandler::startIndexEntry(const QXmlAttributes& /*attrib*/) +{ + printf("start index entry\n"); + m_parent->setDelegate(this); +} + +void IndexEntryHandler::endIndexEntry() +{ + printf("index entry primary=`%s' secondary=`%s'\n", + m_primary.data(),m_secondary.data()); + m_parent->setDelegate(0); +} + +void IndexEntryHandler::startPrimaryIE(const QXmlAttributes& /*attrib*/) +{ + m_curString=""; +} + +void IndexEntryHandler::endPrimaryIE() +{ + m_primary = m_curString; +} + +void IndexEntryHandler::startSecondaryIE(const QXmlAttributes& /*attrib*/) +{ + m_curString=""; +} + +void IndexEntryHandler::endSecondaryIE() +{ + m_secondary = m_curString; +} + +//---------------------------------------------------------------------- +// EntryHandler +//---------------------------------------------------------------------- + +EntryHandler::EntryHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + addEndHandler("entry",this,&EntryHandler::endEntry); + addStartHandler("para",this,&EntryHandler::startParagraph); +} + +EntryHandler::~EntryHandler() +{ +} + +void EntryHandler::startEntry(const QXmlAttributes&) +{ + m_parent->setDelegate(this); +} + +void EntryHandler::endEntry() +{ + m_parent->setDelegate(0); +} + +void EntryHandler::startParagraph(const QXmlAttributes& attrib) +{ + ParagraphHandler *ph = new ParagraphHandler(this); + ph->startParagraph(attrib); + m_children.append(ph); +} + +//---------------------------------------------------------------------- +// RowHandler +//---------------------------------------------------------------------- + +RowHandler::RowHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + addEndHandler("row",this,&RowHandler::endRow); + addStartHandler("entry",this,&RowHandler::startEntry); +} + +RowHandler::~RowHandler() +{ +} + +void RowHandler::startRow(const QXmlAttributes&) +{ + m_parent->setDelegate(this); +} + +void RowHandler::endRow() +{ + m_parent->setDelegate(0); +} + +void RowHandler::startEntry(const QXmlAttributes& attrib) +{ + EntryHandler *eh = new EntryHandler(this); + eh->startEntry(attrib); + m_children.append(eh); +} + +//---------------------------------------------------------------------- +// TableHandler +//---------------------------------------------------------------------- + +TableHandler::TableHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + addEndHandler("table",this,&TableHandler::endTable); + addStartHandler("row",this,&TableHandler::startRow); +} + +TableHandler::~TableHandler() +{ +} + +void TableHandler::startTable(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + m_numColumns = attrib.value("cols").toInt(); + printf("table cols=%d\n",m_numColumns); +} + +void TableHandler::endTable() +{ + m_parent->setDelegate(0); +} + +void TableHandler::startRow(const QXmlAttributes& attrib) +{ + RowHandler *rh = new RowHandler(this); + rh->startRow(attrib); + m_children.append(rh); +} + +//---------------------------------------------------------------------- +// ParagraphHandler +//---------------------------------------------------------------------- + +ParagraphHandler::ParagraphHandler(IBaseHandler *parent) + : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + + m_markupHandler = new MarkupHandler(m_children,m_curString); + setFallBackHandler(m_markupHandler); + + addEndHandler("para",this,&ParagraphHandler::endParagraph); + + addStartHandler("itemizedlist",this,&ParagraphHandler::startItemizedList); + addStartHandler("orderedlist",this,&ParagraphHandler::startOrderedList); + addStartHandler("parameterlist",this,&ParagraphHandler::startParameterList); + addStartHandler("simplesect",this,&ParagraphHandler::startSimpleSect); + addStartHandler("ref",this,&ParagraphHandler::startRef); + addStartHandler("variablelist",this,&ParagraphHandler::startVariableList); + addStartHandler("hruler",this,&ParagraphHandler::startHRuler); + addStartHandler("linebreak",this,&ParagraphHandler::startLineBreak); + addStartHandler("ulink",this,&ParagraphHandler::startULink); + addStartHandler("email",this,&ParagraphHandler::startEMail); + addStartHandler("link",this,&ParagraphHandler::startLink); + addStartHandler("programlisting",this,&ParagraphHandler::startProgramListing); + addStartHandler("formula",this,&ParagraphHandler::startFormula); + addStartHandler("image",this,&ParagraphHandler::startImage); + addStartHandler("dotfile",this,&ParagraphHandler::startDotFile); + addStartHandler("indexentry",this,&ParagraphHandler::startIndexEntry); + addStartHandler("table",this,&ParagraphHandler::startTable); +} + +ParagraphHandler::~ParagraphHandler() +{ + delete m_markupHandler; +} + +void ParagraphHandler::startParagraph(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("para\n"); +} + +void ParagraphHandler::endParagraph() +{ + addTextNode(); + printf("end para\n"); + m_parent->setDelegate(0); +} + +void ParagraphHandler::startItemizedList(const QXmlAttributes& attrib) +{ + addTextNode(); + ListHandler *listHandler = new ListHandler(ItemizedList,this); + listHandler->startList(attrib); + m_children.append(listHandler); +} + +void ParagraphHandler::startOrderedList(const QXmlAttributes& attrib) +{ + addTextNode(); + ListHandler *listHandler = new ListHandler(OrderedList,this); + listHandler->startList(attrib); + m_children.append(listHandler); +} + +void ParagraphHandler::startParameterList(const QXmlAttributes& attrib) +{ + addTextNode(); + ParameterListHandler *parListHandler = new ParameterListHandler(this); + parListHandler->startParameterList(attrib); + m_children.append(parListHandler); +} + +void ParagraphHandler::startSimpleSect(const QXmlAttributes& attrib) +{ + addTextNode(); + SimpleSectHandler *sectHandler = new SimpleSectHandler(this); + sectHandler->startSimpleSect(attrib); + m_children.append(sectHandler); +} + +void ParagraphHandler::startRef(const QXmlAttributes& attrib) +{ + addTextNode(); + RefHandler *ref = new RefHandler(this); + ref->startRef(attrib); + m_children.append(ref); +} + +void ParagraphHandler::startVariableList(const QXmlAttributes& attrib) +{ + addTextNode(); + VariableListHandler *vl = new VariableListHandler(this); + vl->startVariableList(attrib); + m_children.append(vl); +} + +void ParagraphHandler::startHRuler(const QXmlAttributes& attrib) +{ + addTextNode(); + HRulerHandler *hr = new HRulerHandler(this); + hr->startHRuler(attrib); + m_children.append(hr); +} + +void ParagraphHandler::startLineBreak(const QXmlAttributes& attrib) +{ + addTextNode(); + LineBreakHandler *lb = new LineBreakHandler(this); + lb->startLineBreak(attrib); + m_children.append(lb); +} + +void ParagraphHandler::startULink(const QXmlAttributes& attrib) +{ + addTextNode(); + ULinkHandler *uh = new ULinkHandler(this); + uh->startULink(attrib); + m_children.append(uh); +} + +void ParagraphHandler::startEMail(const QXmlAttributes& attrib) +{ + addTextNode(); + EMailHandler *eh = new EMailHandler(this); + eh->startEMail(attrib); + m_children.append(eh); +} + +void ParagraphHandler::startLink(const QXmlAttributes& attrib) +{ + addTextNode(); + LinkHandler *lh = new LinkHandler(this); + lh->startLink(attrib); + m_children.append(lh); +} + +void ParagraphHandler::startProgramListing(const QXmlAttributes& attrib) +{ + addTextNode(); + ProgramListingHandler *pl = new ProgramListingHandler(this); + pl->startProgramListing(attrib); + m_children.append(pl); +} + +void ParagraphHandler::startFormula(const QXmlAttributes& attrib) +{ + addTextNode(); + FormulaHandler *fh = new FormulaHandler(this); + fh->startFormula(attrib); + m_children.append(fh); +} + +void ParagraphHandler::startImage(const QXmlAttributes& attrib) +{ + addTextNode(); + ImageHandler *ih = new ImageHandler(this); + ih->startImage(attrib); + m_children.append(ih); +} + +void ParagraphHandler::startDotFile(const QXmlAttributes& attrib) +{ + addTextNode(); + DotFileHandler *df = new DotFileHandler(this); + df->startDotFile(attrib); + m_children.append(df); +} + +void ParagraphHandler::startIndexEntry(const QXmlAttributes& attrib) +{ + addTextNode(); + IndexEntryHandler *df = new IndexEntryHandler(this); + df->startIndexEntry(attrib); + m_children.append(df); +} + +void ParagraphHandler::startTable(const QXmlAttributes& attrib) +{ + addTextNode(); + TableHandler *th = new TableHandler(this); + th->startTable(attrib); + m_children.append(th); +} + +void ParagraphHandler::addTextNode() +{ + if (!m_curString.isEmpty()) + { + m_children.append(new TextNode(m_curString,m_markupHandler->markup())); + printf("addTextNode() text=\"%s\" markup=%x\n", + m_curString.data(),m_markupHandler->markup()); + m_curString=""; + } +} + +IDocIterator *ParagraphHandler::contents() const +{ + return new ParagraphIterator(*this); +} + +//---------------------------------------------------------------------- +// DocSectionHandler +//---------------------------------------------------------------------- + +DocSectionHandler::DocSectionHandler(IBaseHandler *parent,int level) + : m_parent(parent), m_level(level) +{ + m_children.setAutoDelete(TRUE); + m_markupHandler = new MarkupHandler(m_children,m_curString); + setFallBackHandler(m_markupHandler); + addStartHandler("ref",this,&DocSectionHandler::startRef); + QString sectionKey; + sectionKey.sprintf("sect%d",level); + addEndHandler(sectionKey,this,&DocSectionHandler::endDocSection); +} + +DocSectionHandler::~DocSectionHandler() +{ + delete m_markupHandler; +} + +void DocSectionHandler::startDocSection(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + printf("Start docsection\n"); + m_id = attrib.value("id"); + m_curString=""; +} + +void DocSectionHandler::endDocSection() +{ + addTextNode(); + m_parent->setDelegate(0); + printf("End docsection\n"); +} + +void DocSectionHandler::addTextNode() +{ + if (!m_curString.isEmpty()) + { + m_children.append(new TextNode(m_curString,m_markupHandler->markup())); + printf("addTextNode() text=\"%s\" markup=%x\n", + m_curString.data(),m_markupHandler->markup()); + m_curString=""; + } +} + +void DocSectionHandler::startRef(const QXmlAttributes& attrib) +{ + RefHandler *ref = new RefHandler(this); + ref->startRef(attrib); + m_children.append(ref); +} + +IDocIterator *DocSectionHandler::title() const +{ + return new DocSectionIterator(*this); +} + +//---------------------------------------------------------------------- +// DocHandler +//---------------------------------------------------------------------- + +DocHandler::DocHandler(IBaseHandler *parent) : m_parent(parent) +{ + m_children.setAutoDelete(TRUE); + + addEndHandler("briefdescription",this,&DocHandler::endDoc); + addEndHandler("detaileddescription",this,&DocHandler::endDoc); + + addStartHandler("para",this,&DocHandler::startParagraph); + addStartHandler("sect1",this,&DocHandler::startSect1); + addStartHandler("sect2",this,&DocHandler::startSect2); + addStartHandler("sect3",this,&DocHandler::startSect3); + addStartHandler("title",this,&DocHandler::startTitle); +} + +DocHandler::~DocHandler() +{ +} + +void DocHandler::startDoc(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("start dochandler\n"); +} + +void DocHandler::endDoc() +{ + printf("end dochandler\n"); + m_parent->setDelegate(0); +} + +void DocHandler::startParagraph(const QXmlAttributes& attrib) +{ + ParagraphHandler *parHandler = new ParagraphHandler(this); + parHandler->startParagraph(attrib); + m_children.append(parHandler); +} + +void DocHandler::startSect1(const QXmlAttributes& attrib) +{ + DocSectionHandler *secHandler = new DocSectionHandler(this,1); + secHandler->startDocSection(attrib); + m_children.append(secHandler); +} + +void DocHandler::startSect2(const QXmlAttributes& attrib) +{ + DocSectionHandler *secHandler = new DocSectionHandler(this,2); + secHandler->startDocSection(attrib); + m_children.append(secHandler); +} + +void DocHandler::startSect3(const QXmlAttributes& attrib) +{ + DocSectionHandler *secHandler = new DocSectionHandler(this,3); + secHandler->startDocSection(attrib); + m_children.append(secHandler); +} + +void DocHandler::startTitle(const QXmlAttributes& attrib) +{ + TitleHandler *titleHandler = new TitleHandler(this); + titleHandler->startTitle(attrib); + m_children.append(titleHandler); +} + +IDocIterator *DocHandler::contents() const +{ + return new DocIterator(*this); +} + diff --git a/addon/doxmlparser/src/dochandler.h b/addon/doxmlparser/src/dochandler.h new file mode 100644 index 0000000..3425288 --- /dev/null +++ b/addon/doxmlparser/src/dochandler.h @@ -0,0 +1,859 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#ifndef _DOCHANDLER_H +#define _DOCHANDLER_H + +#include <qstring.h> +#include <qlist.h> +#include <qxml.h> + +#include <doxmlintf.h> +#include "basehandler.h" +#include "baseiterator.h" + +class ParagraphHandler; + +//----------------------------------------------------------------------------- + + +/*! \brief Node representing a piece of text. + * + */ +class TextNode : public IDocText +{ + public: + TextNode(const QString &t,int markup) + : m_text(t), m_markup(markup) {} + virtual ~TextNode() {} + + // IDocText + virtual Kind kind() const { return Text; } + virtual QString text() const { return m_text; } + virtual int markup() const { return m_markup; } + + private: + QString m_text; + int m_markup; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a change in the markup style. + * + */ +class MarkupModifierNode : public IDocMarkupModifier +{ + public: + MarkupModifierNode(int markup,bool enabled) + : m_markup(markup), m_enabled(enabled) {} + virtual ~MarkupModifierNode() {} + + // IDocMarkupModifier + virtual Kind kind() const { return MarkupModifier; } + + private: + int m_markup; + bool m_enabled; +}; + + +//----------------------------------------------------------------------------- + +/*! \brief Handles markup commands in the XML input. + * + */ +class MarkupHandler : public BaseFallBackHandler<MarkupHandler> +{ + public: + MarkupHandler(QList<IDoc> &children,QString &curString); + virtual ~MarkupHandler(); + int markup() const { return m_curMarkup; } + + virtual void startBold(const QXmlAttributes &attrib); + virtual void endBold(); + virtual void startEmphasis(const QXmlAttributes &attrib); + virtual void endEmphasis(); + virtual void startComputerOutput(const QXmlAttributes &attrib); + virtual void endComputerOutput(); + virtual void startCenter(const QXmlAttributes &attrib); + virtual void endCenter(); + virtual void startSmallFont(const QXmlAttributes &attrib); + virtual void endSmallFont(); + virtual void startSubscript(const QXmlAttributes &attrib); + virtual void endSubscript(); + virtual void startSuperscript(const QXmlAttributes &attrib); + virtual void endSuperscript(); + + + private: + void addTextNode(); + + QList<IDoc> &m_children; + QString &m_curString; + int m_curMarkup; +}; + + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a list item. + * + */ +class ListItemHandler : public IDocListItem, public BaseHandler<ListItemHandler> +{ + public: + ListItemHandler(IBaseHandler *parent); + virtual ~ListItemHandler(); + virtual void startListItem(const QXmlAttributes& attrib); + virtual void endListItem(); + virtual void startParagraph(const QXmlAttributes& attrib); + + // IDocItem + virtual Kind kind() const { return ListItem; } + + private: + IBaseHandler *m_parent; + QList<IDoc> m_children; +}; + + +//----------------------------------------------------------------------------- + +/*! \brief Node representing list of items. + * + */ +class ListHandler : public IDocList, public BaseHandler<ListHandler> +{ + public: + ListHandler(Kind k,IBaseHandler *parent); + virtual ~ListHandler(); + virtual void startList(const QXmlAttributes& attrib); + virtual void endList(); + virtual void startListItem(const QXmlAttributes& attrib); + + // IDocList + virtual Kind kind() const { return m_kind; } + + private: + IBaseHandler *m_parent; + QList<IDoc> m_children; + Kind m_kind; +}; + + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a parameter. + * + */ +class ParameterHandler : public IDocParameter, + public BaseHandler<ParameterHandler> +{ + public: + ParameterHandler(IBaseHandler *parent); + virtual ~ParameterHandler(); + virtual void startParameterName(const QXmlAttributes& attrib); + virtual void endParameterName(); + virtual void startParameterDescription(const QXmlAttributes& attrib); + virtual void endParameterDescription(); + virtual void startParagraph(const QXmlAttributes& attrib); + + // IDocParameter + virtual Kind kind() const { return Parameter; } + + private: + IBaseHandler *m_parent; + QString m_name; + ParagraphHandler *m_description; +}; + + +//----------------------------------------------------------------------------- + +/* \brief Node representing a parameter list. + * + */ +class ParameterListHandler : public IDocParameter, + public BaseHandler<ParameterListHandler> +{ + public: + enum Types { Param, RetVal, Exception }; + ParameterListHandler(IBaseHandler *parent); + virtual ~ParameterListHandler(); + virtual void startParameterList(const QXmlAttributes& attrib); + virtual void endParameterList(); + virtual void startParameterName(const QXmlAttributes& attrib); + virtual void startParameterDescription(const QXmlAttributes& attrib); + + // IDocParameterList + virtual Kind kind() const { return ParameterList; } + + private: + IBaseHandler *m_parent; + QList<ParameterHandler> m_parameters; + ParameterHandler *m_curParam; + Types m_type; +}; + +//----------------------------------------------------------------------------- + +/* \brief Node representing a horizontal ruler + * + */ +class LineBreakHandler : public IDocLineBreak, public BaseHandler<LineBreakHandler> +{ + public: + LineBreakHandler(IBaseHandler *parent); + virtual ~LineBreakHandler(); + + void startLineBreak(const QXmlAttributes& attrib); + void endLineBreak(); + + // IDocLineBreak + virtual Kind kind() const { return LineBreak; } + + private: + IBaseHandler *m_parent; +}; + +//----------------------------------------------------------------------------- + +/* \brief Node representing a link to section + * + */ +class LinkHandler : public IDocLink, public BaseHandler<LinkHandler> +{ + public: + LinkHandler(IBaseHandler *parent); + virtual ~LinkHandler(); + + void startLink(const QXmlAttributes& attrib); + void endLink(); + + // IDocLink + virtual Kind kind() const { return Link; } + + private: + IBaseHandler *m_parent; + QString m_ref; + QString m_text; +}; + + +//----------------------------------------------------------------------------- + +/* \brief Node representing a link to an email address + * + */ +class EMailHandler : public IDocEMail, public BaseHandler<EMailHandler> +{ + public: + EMailHandler(IBaseHandler *parent); + virtual ~EMailHandler(); + + void startEMail(const QXmlAttributes& attrib); + void endEMail(); + + // IDocEMail + virtual Kind kind() const { return EMail; } + + private: + IBaseHandler *m_parent; + QString m_address; +}; + + +//----------------------------------------------------------------------------- + +/* \brief Node representing a link to an URL + * + */ +class ULinkHandler : public IDocULink, public BaseHandler<ULinkHandler> +{ + public: + ULinkHandler(IBaseHandler *parent); + virtual ~ULinkHandler(); + + void startULink(const QXmlAttributes& attrib); + void endULink(); + + // IDocULink + virtual Kind kind() const { return ULink; } + + private: + IBaseHandler *m_parent; + QString m_url; + QString m_text; +}; + +//----------------------------------------------------------------------------- + +/* \brief Node representing a horizontal ruler + * + */ +class HRulerHandler : public IDocHRuler, public BaseHandler<HRulerHandler> +{ + public: + HRulerHandler(IBaseHandler *parent); + virtual ~HRulerHandler(); + + void startHRuler(const QXmlAttributes& attrib); + void endHRuler(); + + // IDocHRuler + virtual Kind kind() const { return HRuler; } + + private: + IBaseHandler *m_parent; +}; + +//----------------------------------------------------------------------------- + +/* \brief Node representing a reference to another item + * + */ +class RefHandler : public IDocRef, public BaseHandler<RefHandler> +{ + public: + RefHandler(IBaseHandler *parent); + virtual ~RefHandler(); + void startRef(const QXmlAttributes& attrib); + void endRef(); + + // IDocRef + virtual Kind kind() const { return Ref; } + + private: + IBaseHandler *m_parent; + QString m_refId; + QString m_anchor; + QString m_linkText; +}; + +//----------------------------------------------------------------------------- + +/* \brief Node representing the title of a section + * + */ +// children: text, ref +// children handled by MarkupHandler: +// bold, computeroutput, emphasis, center, +// small, subscript, superscript. +class TitleHandler : public IDocTitle, public BaseHandler<TitleHandler> +{ + friend class TitleIterator; + public: + TitleHandler(IBaseHandler *parent); + virtual ~TitleHandler(); + virtual void startTitle(const QXmlAttributes& attrib); + virtual void endTitle(); + virtual void startRef(const QXmlAttributes& attrib); + void addTextNode(); + + // IDocTitle + virtual Kind kind() const { return Title; } + virtual IDocIterator *title() const; + + private: + IBaseHandler *m_parent; + QList<IDoc> m_children; + MarkupHandler *m_markupHandler; +}; + +class TitleIterator : public BaseIterator<IDocIterator,IDoc,IDoc> +{ + public: + TitleIterator(const TitleHandler &handler) : + BaseIterator<IDocIterator,IDoc,IDoc>(handler.m_children) {} +}; + +//----------------------------------------------------------------------------- + +/* \brief Node representing a simple section with an unnumbered header. + * + */ +// children: title, para +class SimpleSectHandler : public IDocSimpleSect, + public BaseHandler<SimpleSectHandler> +{ + public: + enum Types { Invalid = 0, + See, Return, Author, Version, + Since, Date, Bug, Note, + Warning, Par, Deprecated, Pre, + Post, Invar, Remark, Attention, + Todo, Test, RCS, EnumValues, + Examples + }; + SimpleSectHandler(IBaseHandler *parent); + virtual ~SimpleSectHandler(); + virtual void startSimpleSect(const QXmlAttributes& attrib); + virtual void endSimpleSect(); + virtual void startTitle(const QXmlAttributes& attrib); + virtual void startParagraph(const QXmlAttributes& attrib); + + // IDocSimpleSect + virtual Kind kind() const { return SimpleSect; } + + private: + IBaseHandler *m_parent; + ParagraphHandler *m_paragraph; + Types m_type; + TitleHandler *m_title; +}; + +//----------------------------------------------------------------------------- + +/* \brief Node representing an named item of a VariableList. + * + */ +class VariableListEntryHandler : public IDocVariableListEntry, public BaseHandler<VariableListEntryHandler> +{ + public: + virtual void startVarListEntry(const QXmlAttributes& attrib); + virtual void endVarListEntry(); + virtual void startListItem(const QXmlAttributes& attrib); + virtual void endListItem(); + virtual void startTerm(const QXmlAttributes& attrib); + virtual void endTerm(); + virtual void startParagraph(const QXmlAttributes& attrib); + + VariableListEntryHandler(IBaseHandler *parent); + virtual ~VariableListEntryHandler(); + + // IDocVariableListEntry + virtual Kind kind() const { return VariableListEntry; } + + private: + IBaseHandler *m_parent; + QString m_term; + ParagraphHandler *m_description; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a list of named items. + * + */ +// children: varlistentry, listitem +class VariableListHandler : public IDocVariableList, public BaseHandler<VariableListHandler> +{ + public: + virtual void startVariableList(const QXmlAttributes& attrib); + virtual void endVariableList(); + virtual void startVarListEntry(const QXmlAttributes& attrib); + virtual void startListItem(const QXmlAttributes& attrib); + + VariableListHandler(IBaseHandler *parent); + virtual ~VariableListHandler(); + + // IDocVariableList + virtual Kind kind() const { return VariableList; } + + private: + IBaseHandler *m_parent; + QList<VariableListEntryHandler> m_entries; + VariableListEntryHandler *m_curEntry; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a highlighted text fragment. + * + */ +// children: - +class HighlightHandler : public IDocHighlight, public BaseHandler<HighlightHandler> +{ + public: + HighlightHandler(IBaseHandler *parent); + virtual ~HighlightHandler(); + void startHighlight(const QXmlAttributes& attrib); + void endHighlight(); + + // IDocHighlight + virtual Kind kind() const { return Highlight; } + + private: + IBaseHandler *m_parent; + QString m_class; + QString m_text; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a line of code. + * + */ +// children: linenumber, highlight, anchor, ref +class CodeLineHandler : public IDocCodeLine, public BaseHandler<CodeLineHandler> +{ + public: + + virtual void startCodeLine(const QXmlAttributes&); + virtual void endCodeLine(); + virtual void startLineNumber(const QXmlAttributes&); + virtual void endLineNumber(); + virtual void startHighlight(const QXmlAttributes&); + virtual void startRef(const QXmlAttributes&); + + CodeLineHandler(IBaseHandler *parent); + virtual ~CodeLineHandler(); + + // IDocCodeLine + virtual Kind kind() const { return CodeLine; } + + private: + void addTextNode(); + + IBaseHandler *m_parent; + int m_lineNumber; + QString m_refId; + QList<IDoc> m_children; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a program listing + * + */ +// children: codeline, linenumber +class ProgramListingHandler : public IDocProgramListing, public BaseHandler<ProgramListingHandler> +{ + public: + virtual void startProgramListing(const QXmlAttributes& attrib); + virtual void endProgramListing(); + virtual void startCodeLine(const QXmlAttributes&); + virtual void startLineNumber(const QXmlAttributes&); + + ProgramListingHandler(IBaseHandler *parent); + virtual ~ProgramListingHandler(); + + // IDocProgramListing + virtual Kind kind() const { return ProgramListing; } + + private: + IBaseHandler *m_parent; + QList<CodeLineHandler> m_children; + bool m_hasLineNumber; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a formula. + * + */ +// children: - +class FormulaHandler : public IDocFormula, public BaseHandler<FormulaHandler> +{ + public: + FormulaHandler(IBaseHandler *parent); + virtual ~FormulaHandler(); + void startFormula(const QXmlAttributes& attrib); + void endFormula(); + + // IDocFormula + virtual Kind kind() const { return Formula; } + + private: + IBaseHandler *m_parent; + QString m_id; + QString m_text; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing an image. + * + */ +// children: - +class ImageHandler : public IDocImage, public BaseHandler<ImageHandler> +{ + public: + ImageHandler(IBaseHandler *parent); + virtual ~ImageHandler(); + void startImage(const QXmlAttributes& attrib); + void endImage(); + + // IDocImage + virtual Kind kind() const { return Image; } + + private: + IBaseHandler *m_parent; + QString m_name; + QString m_caption; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a dot file. + * + */ +// children: - +class DotFileHandler : public IDocDotFile, public BaseHandler<DotFileHandler> +{ + public: + DotFileHandler(IBaseHandler *parent); + virtual ~DotFileHandler(); + void startDotFile(const QXmlAttributes& attrib); + void endDotFile(); + + // IDocDotFile + virtual Kind kind() const { return DotFile; } + + private: + IBaseHandler *m_parent; + QString m_name; + QString m_caption; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing an entry in the index. + * + */ +// children: - +class IndexEntryHandler : public IDocIndexEntry, public BaseHandler<IndexEntryHandler> +{ + public: + IndexEntryHandler(IBaseHandler *parent); + virtual ~IndexEntryHandler(); + void startIndexEntry(const QXmlAttributes& attrib); + void endIndexEntry(); + void startPrimaryIE(const QXmlAttributes& attrib); + void endPrimaryIE(); + void startSecondaryIE(const QXmlAttributes& attrib); + void endSecondaryIE(); + + // IDocIndexEntry + virtual Kind kind() const { return IndexEntry; } + + private: + IBaseHandler *m_parent; + QString m_primary; + QString m_secondary; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing an entry in the table entry. + * + */ +// children: para +class EntryHandler : public IDocEntry, public BaseHandler<EntryHandler> +{ + public: + EntryHandler(IBaseHandler *parent); + virtual ~EntryHandler(); + void startEntry(const QXmlAttributes& attrib); + void endEntry(); + void startParagraph(const QXmlAttributes& attrib); + + // IDocEntry + virtual Kind kind() const { return Entry; } + + private: + IBaseHandler *m_parent; + QList<IDoc> m_children; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing an entry in the table row. + * + */ +// children: entry +class RowHandler : public IDocRow, public BaseHandler<RowHandler> +{ + public: + RowHandler(IBaseHandler *parent); + virtual ~RowHandler(); + void startRow(const QXmlAttributes& attrib); + void endRow(); + void startEntry(const QXmlAttributes& attrib); + + // IDocRow + virtual Kind kind() const { return Row; } + + private: + IBaseHandler *m_parent; + QList<EntryHandler> m_children; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing an entry in the table. + * + */ +// children: row +class TableHandler : public IDocTable, public BaseHandler<TableHandler> +{ + public: + TableHandler(IBaseHandler *parent); + virtual ~TableHandler(); + void startTable(const QXmlAttributes& attrib); + void endTable(); + void startRow(const QXmlAttributes& attrib); + + // IDocTable + virtual Kind kind() const { return Table; } + + private: + IBaseHandler *m_parent; + QList<RowHandler> m_children; + int m_numColumns; +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a paragraph of text and commands. + * + */ +// children: itemizedlist, orderedlist, parameterlist, simplesect, ref, +// variablelist, hruler, linebreak, ulink, email, link +// programlisting, formula, image, dotfile, indexentry, +// table +// +// children handled by MarkupHandler: +// bold, computeroutput, emphasis, center, +// small, subscript, superscript. +// +class ParagraphHandler : public IDocPara, + public BaseHandler<ParagraphHandler> +{ + friend class ParagraphIterator; + + public: + virtual void startParagraph(const QXmlAttributes& attrib); + virtual void endParagraph(); + virtual void startItemizedList(const QXmlAttributes& attrib); + virtual void startOrderedList(const QXmlAttributes& attrib); + virtual void startParameterList(const QXmlAttributes& attrib); + virtual void startSimpleSect(const QXmlAttributes& attrib); + virtual void startRef(const QXmlAttributes& attrib); + virtual void startVariableList(const QXmlAttributes& attrib); + virtual void startHRuler(const QXmlAttributes& attrib); + virtual void startLineBreak(const QXmlAttributes& attrib); + virtual void startULink(const QXmlAttributes& attrib); + virtual void startEMail(const QXmlAttributes& attrib); + virtual void startLink(const QXmlAttributes& attrib); + virtual void startProgramListing(const QXmlAttributes& attrib); + virtual void startFormula(const QXmlAttributes& attrib); + virtual void startImage(const QXmlAttributes& attrib); + virtual void startDotFile(const QXmlAttributes& attrib); + virtual void startIndexEntry(const QXmlAttributes& attrib); + virtual void startTable(const QXmlAttributes& attrib); + + ParagraphHandler(IBaseHandler *parent); + virtual ~ParagraphHandler(); + + // IDocPara + virtual Kind kind() const { return Para; } + virtual IDocIterator *contents() const; + + private: + void addTextNode(); + IBaseHandler *m_parent; + QList<IDoc> m_children; + MarkupHandler *m_markupHandler; +}; + +class ParagraphIterator : public BaseIterator<IDocIterator,IDoc,IDoc> +{ + public: + ParagraphIterator(const ParagraphHandler &handler) : + BaseIterator<IDocIterator,IDoc,IDoc>(handler.m_children) {} +}; + + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a section. + * + */ +// children: text, ref +// children handled by MarkupHandler: +// bold, computeroutput, emphasis, center, +// small, subscript, superscript. +class DocSectionHandler : public IDocSection, public BaseHandler<DocSectionHandler> +{ + friend class DocSectionIterator; + public: + DocSectionHandler(IBaseHandler *parent,int level); + virtual ~DocSectionHandler(); + virtual void startDocSection(const QXmlAttributes& attrib); + virtual void endDocSection(); + virtual void startRef(const QXmlAttributes& attrib); + void addTextNode(); + + // IDocSection + virtual Kind kind() const { return Section; } + virtual QString id() const { return m_id; } + virtual int level() const { return m_level; } + virtual IDocIterator *title() const; + + private: + IBaseHandler *m_parent; + QList<IDoc> m_children; + MarkupHandler *m_markupHandler; + QString m_id; + int m_level; +}; + +class DocSectionIterator : public BaseIterator<IDocIterator,IDoc,IDoc> +{ + public: + DocSectionIterator(const DocSectionHandler &handler) : + BaseIterator<IDocIterator,IDoc,IDoc>(handler.m_children) {} +}; + +//----------------------------------------------------------------------------- + +/*! \brief Node representing a documentation block. + * + */ +// children: para, title, sect1, sect2, sect3 +class DocHandler : public IDocRoot, public BaseHandler<DocHandler> +{ + friend class DocIterator; + public: + virtual void startDoc(const QXmlAttributes& attrib); + virtual void endDoc(); + virtual void startParagraph(const QXmlAttributes& attrib); + virtual void startSect1(const QXmlAttributes& attrib); + virtual void startSect2(const QXmlAttributes& attrib); + virtual void startSect3(const QXmlAttributes& attrib); + virtual void startTitle(const QXmlAttributes& attrib); + + DocHandler(IBaseHandler *parent); + virtual ~DocHandler(); + + // IDocRoot + virtual Kind kind() const { return Root; } + virtual IDocIterator *contents() const; + + private: + IBaseHandler *m_parent; + QList<IDoc> m_children; +}; + +class DocIterator : public BaseIterator<IDocIterator,IDoc,IDoc> +{ + public: + DocIterator(const DocHandler &handler) : + BaseIterator<IDocIterator,IDoc,IDoc>(handler.m_children) {} +}; + +#endif diff --git a/addon/doxmlparser/src/doxmlintf.h b/addon/doxmlparser/src/doxmlintf.h new file mode 100644 index 0000000..ec2950c --- /dev/null +++ b/addon/doxmlparser/src/doxmlintf.h @@ -0,0 +1,422 @@ +#ifndef _DOXMLINTF_H +#define _DOXMLINTF_H + +#include <qstring.h> + +class IMember; +class IDocIterator; + +class ILinkedText +{ + public: + enum Kind { Kind_Text, Kind_Ref }; + virtual Kind kind() const = 0; +}; + +class ILT_Text : public ILinkedText +{ + public: + virtual QString text() const = 0; +}; + +class ILT_Ref : public ILinkedText +{ + public: + virtual QString id() const = 0; + virtual QString external() const = 0; + virtual QString text() const = 0; +}; + +class ILinkedTextIterator +{ + public: + virtual ILinkedText *toFirst() = 0; + virtual ILinkedText *toLast() = 0; + virtual ILinkedText *toNext() = 0; + virtual ILinkedText *toPrev() = 0; + virtual ILinkedText *current() const = 0; + virtual void release() = 0; +}; + +class IParam +{ + public: + virtual ILinkedTextIterator *type() const = 0; + virtual QString declarationName() const = 0; + virtual QString definitionName() const = 0; + virtual QString attrib() const = 0; + virtual QString arraySpecifier() const = 0; + virtual ILinkedTextIterator *defaultValue() const = 0; +}; + +class IParamIterator +{ + public: + virtual IParam *toFirst() = 0; + virtual IParam *toLast() = 0; + virtual IParam *toNext() = 0; + virtual IParam *toPrev() = 0; + virtual IParam *current() const = 0; + virtual void release() = 0; +}; + +class IMemberReference +{ + public: + virtual IMember *member() const = 0; + virtual QString memberName() const = 0; +}; + +class IMemberReferenceIterator +{ + public: + virtual IMemberReference *toFirst() = 0; + virtual IMemberReference *toLast() = 0; + virtual IMemberReference *toNext() = 0; + virtual IMemberReference *toPrev() = 0; + virtual IMemberReference *current() const = 0; + virtual void release() = 0; +}; + +class IEnumValue +{ + public: + virtual QString name() const = 0; + virtual QString initializer() const = 0; +}; + +class IEnumValueIterator +{ + public: + virtual IEnumValue *toFirst() = 0; + virtual IEnumValue *toLast() = 0; + virtual IEnumValue *toNext() = 0; + virtual IEnumValue *toPrev() = 0; + virtual IEnumValue *current() const = 0; + virtual void release() = 0; +}; + +class IDoc +{ + public: + enum Kind + { + Para, // 0 -> IDocPara + Text, // 1 -> IDocText + MarkupModifier, // 2 -> IDocMarkupModifier + ItemizedList, // 3 -> IDocList + OrderedList, // 4 -> IDocList + ListItem, // 5 -> IDocListItem + ParameterList, // 6 -> IDocParameterList + Parameter, // 7 -> IDocParameter + SimpleSect, // 8 -> IDocSimpleSect + Title, // 9 -> IDocTitle + Ref, // 10 -> IDocRef + VariableList, // 11 -> IDocVariableList + VariableListEntry, // 12 -> IDocVariableListEntry + HRuler, // 13 -> IDocHRuler + LineBreak, // 14 -> IDocLineBreak + ULink, // 15 -> IDocULink + EMail, // 16 -> IDocEMail + Link, // 17 -> IDocLink + ProgramListing, // 18 -> IDocProgramListing + CodeLine, // 19 -> IDocCodeLine + Highlight, // 20 -> IDocHighlight + Anchor, // 21 -> IDocAnchor + Formula, // 22 -> IDocFormula + Image, // 23 -> IDocImage + DotFile, // 24 -> IDocDotFile + IndexEntry, // 25 -> IDocIndexEntry + Table, // 26 -> IDocTable + Row, // 27 -> IDocRow + Entry, // 28 -> IDocEntry + Section, // 29 -> IDocSection + Root // 30 -> IDocRoot + }; + virtual Kind kind() const = 0; +}; + +class IDocMarkup : public IDoc +{ + public: + enum Markup + { + Normal = 0x00, + Bold = 0x01, + Emphasis = 0x02, + ComputerOutput = 0x04, + Subscript = 0x08, + Superscript = 0x10, + SmallFont = 0x20, + Center = 0x40 + }; + +}; + +class IDocPara : public IDoc +{ + public: + virtual IDocIterator *contents() const = 0; +}; + +class IDocText : public IDocMarkup +{ + public: + virtual QString text() const = 0; + virtual int markup() const = 0; +}; + +class IDocMarkupModifier : public IDoc +{ +}; + +class IDocList : public IDoc +{ +}; + +class IDocListItem : public IDoc +{ +}; + +class IDocParameterList : public IDoc +{ +}; + +class IDocParameter : public IDoc +{ +}; + +class IDocSimpleSect : public IDoc +{ +}; + +class IDocTitle : public IDoc +{ + public: + virtual IDocIterator *title() const = 0; +}; + +class IDocRef : public IDoc +{ +}; + +class IDocVariableList : public IDoc +{ +}; + +class IDocVariableListEntry : public IDoc +{ +}; + +class IDocHRuler : public IDoc +{ +}; + +class IDocLineBreak : public IDoc +{ +}; + +class IDocULink : public IDoc +{ +}; + +class IDocEMail : public IDoc +{ +}; + +class IDocLink : public IDoc +{ +}; + +class IDocProgramListing : public IDoc +{ +}; + +class IDocCodeLine : public IDoc +{ +}; + +class IDocHighlight : public IDoc +{ +}; + +class IDocAnchor : public IDoc +{ +}; + +class IDocFormula : public IDoc +{ +}; + +class IDocImage : public IDoc +{ +}; + +class IDocDotFile : public IDoc +{ +}; + +class IDocIndexEntry : public IDoc +{ +}; + +class IDocTable : public IDoc +{ +}; + +class IDocRow : public IDoc +{ +}; + +class IDocEntry : public IDoc +{ +}; + +class IDocSection : public IDoc +{ + public: + virtual QString id() const = 0; + virtual int level() const = 0; + virtual IDocIterator *title() const = 0; +}; + +class IDocRoot : public IDoc +{ + public: + virtual IDocIterator *contents() const = 0; +}; + +class IDocIterator +{ + public: + virtual IDoc *toFirst() = 0; + virtual IDoc *toLast() = 0; + virtual IDoc *toNext() = 0; + virtual IDoc *toPrev() = 0; + virtual IDoc *current() const = 0; + virtual void release() = 0; +}; + +class IMember +{ + public: + virtual QString kind() const = 0; + virtual QString id() const = 0; + virtual QString protection() const = 0; + virtual QString virtualness() const = 0; + virtual ILinkedTextIterator *type() const = 0; + virtual QString name() const = 0; + virtual bool isConst() const = 0; + virtual bool isVolatile() const = 0; + virtual IParamIterator *params() const = 0; + virtual ILinkedTextIterator *initializer() const = 0; + virtual ILinkedTextIterator *exceptions() const = 0; + virtual IMemberReferenceIterator *references() const = 0; + virtual IMemberReferenceIterator *referencedBy() const = 0; + virtual int bodyStart() const = 0; + virtual int bodyEnd() const = 0; + virtual QString definitionFile() const = 0; + virtual int definitionLine() const = 0; + virtual IMemberReference *reimplements() const = 0; + virtual IMemberReferenceIterator *reimplementedBy() const = 0; + virtual IEnumValueIterator *enumValues() const = 0; + virtual IDocRoot *briefDescription() const = 0; + virtual IDocRoot *detailedDescription() const = 0; +}; + +class IMemberIterator +{ + public: + virtual IMember *toFirst() = 0; + virtual IMember *toLast() = 0; + virtual IMember *toNext() = 0; + virtual IMember *toPrev() = 0; + virtual IMember *current() const = 0; + virtual void release() = 0; +}; + +class ISection +{ + public: + virtual QString kind() const = 0; + virtual IMemberIterator *members() const = 0; +}; + +class ISectionIterator +{ + public: + virtual ISection *toFirst() = 0; + virtual ISection *toLast() = 0; + virtual ISection *toNext() = 0; + virtual ISection *toPrev() = 0; + virtual ISection *current() const = 0; + virtual void release() = 0; +}; + +class ICompound +{ + public: + virtual QString name() const = 0; + virtual QString id() const = 0; + virtual QString kind() const = 0; + virtual ISectionIterator *sections() const = 0; + virtual IDocRoot *briefDescription() const = 0; + virtual IDocRoot *detailedDescription() const = 0; +}; + +class ICompoundIterator +{ + public: + virtual ICompound *toFirst() = 0; + virtual ICompound *toLast() = 0; + virtual ICompound *toNext() = 0; + virtual ICompound *toPrev() = 0; + virtual ICompound *current() const = 0; + virtual void release() = 0; +}; + +/*! Root node of the object model. */ +class IDoxygen +{ + public: + /*! Returns an iterator that can be used to iterate over the list + * of compounds found in the project. + */ + virtual ICompoundIterator *compounds() const = 0; + + /*! Returns a compound given its unique \a id. If you have a + * compound id this function is much more efficient than iterating + * over the compound list. Returns 0 if the id is not valid. + */ + virtual ICompound *compoundById(const QString &id) const = 0; + + /*! Returns a compound given its name (including the scope). + * Returns 0 if the name is not found in the project. + */ + virtual ICompound *compoundByName(const QString &name) const = 0; + + /*! Returns an interface to a member given its id. + * @param id The member id. + */ + virtual IMember *memberById(const QString &id) const = 0; + + /*! Returns a list of all members with a certain name. + * @param name The name of the member. + */ + virtual IMemberIterator *memberByName(const QString &name) const = 0; + + /*! Releases the memory for the object hierarchy obtained by + * createdObjecModelFromXML(). First release all iterators before calling + * this function. + */ + virtual void release() = 0; +}; + +/*! Factory method that creates an object model given an XML file generated + * by doxygen. + * @param xmlFileName The name of the XML to parse. + * @returns An iterface to the object model. + */ +IDoxygen *createObjectModelFromXML(const char *xmlFileName); + +#endif diff --git a/addon/doxmlparser/src/doxmlparser.pro.in b/addon/doxmlparser/src/doxmlparser.pro.in new file mode 100644 index 0000000..7724b47 --- /dev/null +++ b/addon/doxmlparser/src/doxmlparser.pro.in @@ -0,0 +1,23 @@ +TEMPLATE = lib.t +CONFIG = console staticlib warn_on $extraopts +HEADERS = basehandler.h mainhandler.h \ + compoundhandler.h sectionhandler.h \ + memberhandler.h paramhandler.h \ + dochandler.h linkedtexthandler.h +SOURCES = mainhandler.cpp \ + compoundhandler.cpp sectionhandler.cpp \ + memberhandler.cpp paramhandler.cpp \ + dochandler.cpp linkedtexthandler.cpp +unix:LIBS += -L../../../lib -lqtools +win32:INCLUDEPATH += . +win32-mingw:LIBS += -L../../../lib -lqtools +win32-msvc:LIBS += qtools.lib shell32.lib +win32-msvc:TMAKE_LFLAGS += /LIBPATH:....\\..\lib +win32-borland:LIBS += qtools.lib doxycfg.lib shell32.lib +win32-borland:TMAKE_LFLAGS += -L..\..\..\lib +win32:TMAKE_CXXFLAGS += -DQT_NODLL +DESTDIR = ../lib +OBJECTS_DIR = ../objects +TARGET = doxmlparser +INCLUDEPATH += ../../../qtools ../include + diff --git a/addon/doxmlparser/src/linkedtexthandler.cpp b/addon/doxmlparser/src/linkedtexthandler.cpp new file mode 100644 index 0000000..b142188 --- /dev/null +++ b/addon/doxmlparser/src/linkedtexthandler.cpp @@ -0,0 +1,107 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ +#include "linkedtexthandler.h" +#include <doxmlintf.h> + +class LT_Text : public ILT_Text +{ + public: + LT_Text(const QString &text) : m_text(text) {} + virtual ~LT_Text() {} + + // ILT_Text + virtual QString text() const { return m_text; } + virtual Kind kind() const { return Kind_Text; } + private: + QString m_text; +}; + +class LT_Ref : public ILT_Ref +{ + public: + LT_Ref() {} + virtual ~LT_Ref() {} + void setRefId(const QString &refId) { m_refId=refId; } + void setText(const QString &text) { m_text=text; } + void setExtId(const QString &extId) { m_extId=extId; } + + // ILT_Ref + virtual QString text() const { return m_text; } + virtual QString id() const { return m_refId; } + virtual QString external() const { return m_extId; } + virtual Kind kind() const { return Kind_Ref; } + + private: + QString m_refId; + QString m_extId; + QString m_text; +}; + +LinkedTextHandler::LinkedTextHandler(IBaseHandler *parent, + QList<ILinkedText> &children + ) + : m_parent(parent), m_children(children) +{ + addStartHandler("ref",this,&LinkedTextHandler::startRef); + addEndHandler("ref",this,&LinkedTextHandler::endRef); + m_children.setAutoDelete(TRUE); + m_ref=0; +} + +LinkedTextHandler::~LinkedTextHandler() +{ +} + +void LinkedTextHandler::start(const char *endTag) +{ + addEndHandler(endTag,this,&LinkedTextHandler::end); + m_parent->setDelegate(this); + m_curString=""; +} + +void LinkedTextHandler::end() +{ + if (!m_curString.isEmpty()) + { + m_children.append(new LT_Text(m_curString)); + printf("LinkedTextHandler: add text `%s'\n",m_curString.data()); + m_curString=""; + } + m_parent->setDelegate(0); +} + +void LinkedTextHandler::startRef(const QXmlAttributes& attrib) +{ + if (!m_curString.isEmpty()) + { + m_children.append(new LT_Text(m_curString)); + printf("LinkedTextHandler: add text `%s'\n",m_curString.data()); + m_curString=""; + } + ASSERT(m_ref==0); + m_ref = new LT_Ref; + m_ref->setRefId(attrib.value("idref")); + m_ref->setExtId(attrib.value("external")); +} + +void LinkedTextHandler::endRef() +{ + m_ref->setText(m_curString); + m_children.append(m_ref); + printf("LinkedTextHandler: add ref `%s'\n",m_ref->text().data()); + m_ref=0; +} + + diff --git a/addon/doxmlparser/src/linkedtexthandler.h b/addon/doxmlparser/src/linkedtexthandler.h new file mode 100644 index 0000000..0569b00 --- /dev/null +++ b/addon/doxmlparser/src/linkedtexthandler.h @@ -0,0 +1,46 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ +#ifndef LINKEDTEXTHANDLER_H +#define LINKEDTEXTHANDLER_H + +#include "baseiterator.h" +#include "basehandler.h" + +class LT_Ref; + +class LinkedTextIterator : public BaseIterator<ILinkedTextIterator,ILinkedText,ILinkedText> +{ + public: + LinkedTextIterator(const QList<ILinkedText> &list) : + BaseIterator<ILinkedTextIterator,ILinkedText,ILinkedText>(list) {} +}; + +class LinkedTextHandler : public BaseHandler<LinkedTextHandler> +{ + public: + LinkedTextHandler(IBaseHandler *parent,QList<ILinkedText> &children); + virtual ~LinkedTextHandler(); + virtual void start(const char *endTag); + virtual void end(); + virtual void startRef(const QXmlAttributes& attrib); + virtual void endRef(); + + private: + IBaseHandler *m_parent; + QList<ILinkedText> &m_children; + LT_Ref *m_ref; +}; + +#endif diff --git a/addon/doxmlparser/src/mainhandler.cpp b/addon/doxmlparser/src/mainhandler.cpp new file mode 100644 index 0000000..7d0e682 --- /dev/null +++ b/addon/doxmlparser/src/mainhandler.cpp @@ -0,0 +1,126 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#include <qxml.h> +#include "mainhandler.h" + +MainHandler::MainHandler() : m_compoundDict(10007), m_compoundNameDict(10007) +{ + m_compounds.setAutoDelete(TRUE); + addStartHandler("doxygen"); + addStartHandler("compounddef",this,&MainHandler::startCompound); + addEndHandler("doxygen"); + addEndHandler("compounddef"); +} + +MainHandler::~MainHandler() +{ + printf("MainHandler::~MainHandler()\n"); +} + +void MainHandler::startCompound(const QXmlAttributes& attrib) +{ + CompoundHandler *compHandler = new CompoundHandler(this); + compHandler->startCompound(attrib); + m_compounds.append(compHandler); +} + +void MainHandler::insertMemberById(const QString &id,IMember *h) +{ + m_memberDict.insert(id,h); +} + +void MainHandler::insertMemberByName(const QString &name,IMember *h) +{ + QList<IMember> *ml = m_memberNameDict[name]; + if (ml) + { + ml->append(h); + } + else + { + ml = new QList<IMember>; + ml->append(h); + m_memberNameDict.insert(name,ml); + } +} + +void MainHandler::initialize() +{ + QListIterator<ICompound> mci(m_compounds); + CompoundHandler *compHandler; + for (;(compHandler=(CompoundHandler *)mci.current());++mci) + { + compHandler->initialize(this); + m_compoundNameDict.insert(compHandler->name(),compHandler); + m_compoundDict.insert(compHandler->id(),compHandler); + } + + // for each member + QDictIterator< QList<IMember> > mndi(m_memberNameDict); + QList<IMember> *ml; + for (;(ml=mndi.current());++mndi) + { + QListIterator<IMember> mli(*ml); + IMember *mem; + for (;(mem=mli.current());++mli) + { + ((MemberHandler*)mem)->initialize(this); + } + } + +} + +class ErrorHandler : public QXmlErrorHandler +{ + public: + virtual ~ErrorHandler() {} + bool warning( const QXmlParseException & ) + { + return FALSE; + } + bool error( const QXmlParseException & ) + { + return FALSE; + } + bool fatalError( const QXmlParseException &exception ) + { + fprintf(stderr,"Fatal error at line %d column %d: %s\n", + exception.lineNumber(),exception.columnNumber(), + exception.message().data()); + return FALSE; + } + QString errorString() { return ""; } + + private: + QString errorMsg; +}; + +IDoxygen *createObjectModelFromXML(const char * xmlFileName) +{ + QFile xmlFile(xmlFileName); + MainHandler * handler = new MainHandler; + ErrorHandler errorHandler; + QXmlInputSource source( xmlFile ); + QXmlSimpleReader reader; + reader.setContentHandler( handler ); + reader.setErrorHandler( &errorHandler ); + reader.parse( source ); + printf("<---------- initialize ----------->\n"); + handler->initialize(); + printf("<-------- end initialize --------->\n"); + return handler; +} + diff --git a/addon/doxmlparser/src/mainhandler.h b/addon/doxmlparser/src/mainhandler.h new file mode 100644 index 0000000..e466b6f --- /dev/null +++ b/addon/doxmlparser/src/mainhandler.h @@ -0,0 +1,68 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#ifndef _MAINHANDLER_H +#define _MAINHANDLER_H + +#include <qlist.h> +#include "basehandler.h" +#include "compoundhandler.h" +#include <doxmlintf.h> +#include "memberhandler.h" + +class MainHandler : public IDoxygen, public BaseHandler<MainHandler> +{ + public: + virtual void startCompound(const QXmlAttributes& attrib); + MainHandler(); + virtual ~MainHandler(); + + ICompoundIterator *compounds() const + { + return new CompoundIterator(m_compounds); + } + ICompound *compoundById(const QString &id) const + { + return m_compoundDict[id]; + } + virtual ICompound *compoundByName(const QString &name) const + { + return name.isEmpty() ? 0 : m_compoundNameDict[name]; + } + virtual IMember *memberById(const QString &id) const + { + return m_memberDict[id]; + } + virtual IMemberIterator *memberByName(const QString &name) const + { + QList<IMember> *ml = m_memberNameDict[name]; + if (ml==0) return 0; + return new MemberIterator(*ml); + } + virtual void release() { delete this; } + void insertMemberById(const QString &id,IMember *h); + void insertMemberByName(const QString &name,IMember *h); + + void initialize(); + + private: + QList<ICompound> m_compounds; + QDict<ICompound> m_compoundDict; + QDict<ICompound> m_compoundNameDict; + QDict<IMember> m_memberDict; + QDict<QList<IMember> > m_memberNameDict; +}; + +#endif diff --git a/addon/doxmlparser/src/memberhandler.cpp b/addon/doxmlparser/src/memberhandler.cpp new file mode 100644 index 0000000..f211f8e --- /dev/null +++ b/addon/doxmlparser/src/memberhandler.cpp @@ -0,0 +1,299 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#include "memberhandler.h" +#include "sectionhandler.h" +#include "dochandler.h" +#include "mainhandler.h" +#include "linkedtexthandler.h" + +//------------------------------------------------------------------------------ + +void MemberReference::initialize(MainHandler *mh) +{ + m_mainHandler = mh; +} + +IMember *MemberReference::member() const +{ + return m_mainHandler->memberById(m_memId); +} + +//------------------------------------------------------------------------------ + + +EnumValueHandler::EnumValueHandler(IBaseHandler *parent) : m_parent(parent) +{ + addEndHandler("enumvalue",this,&EnumValueHandler::endEnumValue); + + addStartHandler("name",this,&EnumValueHandler::startName); + addEndHandler("name",this,&EnumValueHandler::endName); + addStartHandler("initializer",this,&EnumValueHandler::startInitializer); + addEndHandler("initializer",this,&EnumValueHandler::endInitializer); +} + +void EnumValueHandler::startEnumValue(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); +} + +void EnumValueHandler::endEnumValue() +{ + m_parent->setDelegate(0); +} + +void EnumValueHandler::startName(const QXmlAttributes& /*attrib*/) +{ + m_curString=""; +} + +void EnumValueHandler::endName() +{ + m_name = m_curString; +} + +void EnumValueHandler::startInitializer(const QXmlAttributes& /*attrib*/) +{ + m_curString=""; +} + +void EnumValueHandler::endInitializer() +{ + m_initializer = m_curString; +} + +//------------------------------------------------------------------------------ + +MemberHandler::MemberHandler(IBaseHandler *parent) + : m_parent(parent), m_brief(0), m_detailed(0) +{ + addEndHandler("memberdef",this,&MemberHandler::endMember); + + addStartHandler("type",this,&MemberHandler::startType); + addStartHandler("initializer",this,&MemberHandler::startInitializer); + addStartHandler("exception",this,&MemberHandler::startException); + addStartHandler("enumvalue",this,&MemberHandler::startEnumValue); + + addStartHandler("name"); + addEndHandler("name",this,&MemberHandler::endName); + + addStartHandler("param",this,&MemberHandler::startParam); + + addStartHandler("briefdescription",this,&MemberHandler::startBriefDesc); + + addStartHandler("detaileddescription",this,&MemberHandler::startDetailedDesc); + + addStartHandler("references",this,&MemberHandler::startReferences); + addEndHandler("references",this,&MemberHandler::endReferences); + + addStartHandler("referencedby",this,&MemberHandler::startReferencedBy); + addEndHandler("referencedby",this,&MemberHandler::endReferencedBy); + + addStartHandler("reimplements",this,&MemberHandler::startReimplements); + addEndHandler("reimplements",this,&MemberHandler::endReimplements); + + addStartHandler("reimplementedby",this,&MemberHandler::startReimplementedBy); + addEndHandler("reimplementedby",this,&MemberHandler::endReimplementedBy); + + addStartHandler("location",this,&MemberHandler::startLocation); + addEndHandler("location"); + + m_params.setAutoDelete(TRUE); + m_references.setAutoDelete(TRUE); + m_referencedBy.setAutoDelete(TRUE); + m_reimplements = 0; + m_reimplementedBy.setAutoDelete(TRUE); + m_enumValues.setAutoDelete(TRUE); + m_linkedTextHandler = 0; + m_defLine=0; + m_bodyStart=0; + m_bodyEnd=0; +} + +MemberHandler::~MemberHandler() +{ + delete m_brief; + delete m_detailed; + delete m_linkedTextHandler; +} + +void MemberHandler::startMember(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + m_kind = attrib.value("kind"); + m_id = attrib.value("id"); + m_virtualness = attrib.value("virt"); + m_protection = attrib.value("prot"); + m_isConst = attrib.value("const")=="yes"; + m_isVolatile = attrib.value("volatile")=="yes"; + printf("member kind=`%s' id=`%s' prot=`%s' virt=`%s'\n", + m_kind.data(),m_id.data(),m_protection.data(),m_virtualness.data()); +} + +void MemberHandler::startBriefDesc(const QXmlAttributes& attrib) +{ + DocHandler *docHandler = new DocHandler(this); + docHandler->startDoc(attrib); + m_brief = docHandler; +} + +void MemberHandler::startDetailedDesc(const QXmlAttributes& attrib) +{ + DocHandler *docHandler = new DocHandler(this); + docHandler->startDoc(attrib); + m_detailed = docHandler; +} + +void MemberHandler::startLocation(const QXmlAttributes& attrib) +{ + m_defFile = attrib.value("file"); + QCString s; + s = attrib.value("line"); + if (!s.isEmpty()) m_defLine=s.toInt(); + s = attrib.value("bodystart"); + if (!s.isEmpty()) m_bodyStart=s.toInt(); + s = attrib.value("bodyend"); + if (!s.isEmpty()) m_bodyEnd=s.toInt(); +} + +void MemberHandler::startReferences(const QXmlAttributes& attrib) +{ + MemberReference *mr = new MemberReference; + mr->m_memId = attrib.value("id"); + m_references.append(mr); + m_curString=""; +} + +void MemberHandler::endReferences() +{ + m_references.getLast()->m_name = m_curString; +} + +void MemberHandler::startReferencedBy(const QXmlAttributes& attrib) +{ + MemberReference *mr = new MemberReference; + mr->m_memId = attrib.value("id"); + m_referencedBy.append(mr); + m_curString=""; +} + +void MemberHandler::endReferencedBy() +{ + m_referencedBy.getLast()->m_name = m_curString; +} + +void MemberHandler::startReimplements(const QXmlAttributes& attrib) +{ + m_reimplements = new MemberReference; + m_reimplements->m_memId = attrib.value("id"); + m_curString=""; +} + +void MemberHandler::endReimplements() +{ + m_reimplements->m_name = m_curString; +} + +void MemberHandler::startReimplementedBy(const QXmlAttributes& attrib) +{ + MemberReference *mr = new MemberReference; + mr->m_memId = attrib.value("id"); + m_reimplementedBy.append(mr); + m_curString=""; +} + +void MemberHandler::endReimplementedBy() +{ + m_reimplementedBy.getLast()->m_name = m_curString; +} + +void MemberHandler::endMember() +{ + m_parent->setDelegate(0); +} + +void MemberHandler::startType(const QXmlAttributes &) +{ + printf("startType!\n"); + delete m_linkedTextHandler; + m_linkedTextHandler = new LinkedTextHandler(this,m_type); + m_linkedTextHandler->start("type"); +} + +void MemberHandler::startInitializer(const QXmlAttributes &) +{ + printf("startInitializer!\n"); + delete m_linkedTextHandler; + m_linkedTextHandler = new LinkedTextHandler(this,m_initializer); + m_linkedTextHandler->start("initializer"); +} + +void MemberHandler::startException(const QXmlAttributes &) +{ + printf("startException!\n"); + delete m_linkedTextHandler; + m_linkedTextHandler = new LinkedTextHandler(this,m_exception); + m_linkedTextHandler->start("exception"); +} + +void MemberHandler::endName() +{ + m_name = m_curString.stripWhiteSpace(); + printf("member name=`%s'\n",m_name.data()); +} + +void MemberHandler::startParam(const QXmlAttributes& attrib) +{ + ParamHandler *paramHandler = new ParamHandler(this); + paramHandler->startParam(attrib); + m_params.append(paramHandler); +} + +void MemberHandler::startEnumValue(const QXmlAttributes& attrib) +{ + EnumValueHandler *evh = new EnumValueHandler(this); + evh->startEnumValue(attrib); + m_enumValues.append(evh); +} + +void MemberHandler::initialize(MainHandler *mh) +{ + { + QListIterator<MemberReference> mli(m_references); + MemberReference *mr; + for (;(mr=mli.current());++mli) + { + mr->initialize(mh); + } + } + { + QListIterator<MemberReference> mli(m_referencedBy); + MemberReference *mr; + for (;(mr=mli.current());++mli) + { + mr->initialize(mh); + } + } + { + QListIterator<MemberReference> mli(m_reimplementedBy); + MemberReference *mr; + for (;(mr=mli.current());++mli) + { + mr->initialize(mh); + } + } + if (m_reimplements) m_reimplements->initialize(mh); +} + diff --git a/addon/doxmlparser/src/memberhandler.h b/addon/doxmlparser/src/memberhandler.h new file mode 100644 index 0000000..b599e2f --- /dev/null +++ b/addon/doxmlparser/src/memberhandler.h @@ -0,0 +1,193 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#ifndef _MEMBERHANDLER_H +#define _MEMBERHANDLER_H + +#include <qstring.h> +#include <qlist.h> +#include <qxml.h> +#include <doxmlintf.h> + +#include "basehandler.h" +#include "baseiterator.h" +#include "paramhandler.h" +#include "linkedtexthandler.h" +#include "dochandler.h" + +class MainHandler; + +struct MemberReference : public IMemberReference +{ + virtual ~MemberReference() {} + virtual IMember *member() const; + virtual QString memberName() const { return m_name; } + void initialize(MainHandler *m); + + QString m_memId; + QString m_name; + MainHandler *m_mainHandler; +}; + +class MemberReferenceIterator : public BaseIterator<IMemberReferenceIterator,IMemberReference,MemberReference> +{ + public: + MemberReferenceIterator(const QList<MemberReference> &list) : + BaseIterator<IMemberReferenceIterator,IMemberReference,MemberReference>(list) {} +}; + +class MemberIterator : public BaseIterator<IMemberIterator,IMember,IMember> +{ + public: + MemberIterator(const QList<IMember> &list) : + BaseIterator<IMemberIterator,IMember,IMember>(list) {} +}; + +class EnumValueHandler : public IEnumValue, public BaseHandler<EnumValueHandler> +{ + public: + virtual void startName(const QXmlAttributes& attrib); + virtual void endName(); + virtual void startInitializer(const QXmlAttributes& attrib); + virtual void endInitializer(); + virtual void startEnumValue(const QXmlAttributes& attrib); + virtual void endEnumValue(); + + // IEnumValue + virtual QString name() const { return m_name; } + virtual QString initializer() const { return m_initializer; } + + void setName(const QString &name) { m_name=name; } + void setInitializer(const QString &init) { m_initializer=init; } + + virtual ~EnumValueHandler() {} + EnumValueHandler(IBaseHandler *parent); + + private: + QString m_name; + QString m_initializer; + IBaseHandler *m_parent; +}; + +class EnumValueIterator : public BaseIterator<IEnumValueIterator,IEnumValue,EnumValueHandler> +{ + public: + EnumValueIterator(const QList<EnumValueHandler> &list) : + BaseIterator<IEnumValueIterator,IEnumValue,EnumValueHandler>(list) {} +}; + + +class MemberHandler : public IMember, public BaseHandler<MemberHandler> +{ + public: + virtual void startMember(const QXmlAttributes& attrib); + virtual void endMember(); + virtual void startParam(const QXmlAttributes& attrib); + virtual void startType(const QXmlAttributes& attrib); + virtual void endName(); + virtual void startBriefDesc(const QXmlAttributes& attrib); + virtual void startDetailedDesc(const QXmlAttributes& attrib); + virtual void startLocation(const QXmlAttributes& attrib); + virtual void startReferences(const QXmlAttributes& attrib); + virtual void endReferences(); + virtual void startReferencedBy(const QXmlAttributes& attrib); + virtual void endReferencedBy(); + virtual void startReimplements(const QXmlAttributes& attrib); + virtual void endReimplements(); + virtual void startReimplementedBy(const QXmlAttributes& attrib); + virtual void endReimplementedBy(); + virtual void startInitializer(const QXmlAttributes& attrib); + virtual void startException(const QXmlAttributes& attrib); + virtual void startEnumValue(const QXmlAttributes& attrib); + + MemberHandler(IBaseHandler *parent); + virtual ~MemberHandler(); + + // IMember implementation + virtual QString kind() const + { return m_kind; } + virtual QString id() const + { return m_id; } + virtual QString protection() const + { return m_protection; } + virtual QString virtualness() const + { return m_virtualness; } + virtual QString name() const + { return m_name; } + virtual bool isConst() const + { return m_isConst; } + virtual bool isVolatile() const + { return m_isVolatile; } + virtual ILinkedTextIterator *type() const + { return new LinkedTextIterator(m_type); } + virtual IParamIterator *params() const + { return new ParamIterator(m_params); } + virtual IMemberReferenceIterator *references() const + { return new MemberReferenceIterator(m_references); } + virtual IMemberReferenceIterator *referencedBy() const + { return new MemberReferenceIterator(m_referencedBy); } + virtual ILinkedTextIterator *initializer() const + { return new LinkedTextIterator(m_initializer); } + virtual ILinkedTextIterator *exceptions() const + { return new LinkedTextIterator(m_exception); } + virtual int bodyStart() const + { return m_bodyStart; } + virtual int bodyEnd() const + { return m_bodyEnd; } + virtual QString definitionFile() const + { return m_defFile; } + virtual int definitionLine() const + { return m_defLine; } + virtual IMemberReference *reimplements() const + { return m_reimplements; } + virtual IMemberReferenceIterator *reimplementedBy() const + { return new MemberReferenceIterator(m_reimplementedBy); } + virtual IEnumValueIterator *enumValues() const + { return new EnumValueIterator(m_enumValues); } + virtual IDocRoot *briefDescription() const + { return m_brief; } + virtual IDocRoot *detailedDescription() const + { return m_detailed; } + + void initialize(MainHandler *m); + + private: + IBaseHandler *m_parent; + QString m_kind; + QString m_id; + QString m_protection; + QString m_virtualness; + QList<ILinkedText> m_type; + QList<ILinkedText> m_initializer; + QList<ILinkedText> m_exception; + QString m_name; + DocHandler *m_brief; + DocHandler *m_detailed; + QList<IParam> m_params; + QList<MemberReference> m_references; + QList<MemberReference> m_referencedBy; + MemberReference *m_reimplements; + QList<MemberReference> m_reimplementedBy; + QString m_defFile; + int m_defLine; + int m_bodyStart; + int m_bodyEnd; + bool m_isConst; + bool m_isVolatile; + LinkedTextHandler *m_linkedTextHandler; + QList<EnumValueHandler> m_enumValues; +}; + +#endif diff --git a/addon/doxmlparser/src/paramhandler.cpp b/addon/doxmlparser/src/paramhandler.cpp new file mode 100644 index 0000000..0cf00e4 --- /dev/null +++ b/addon/doxmlparser/src/paramhandler.cpp @@ -0,0 +1,98 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#include "paramhandler.h" +#include "memberhandler.h" + +ParamHandler::ParamHandler(IBaseHandler *parent) : m_parent(parent) +{ + addEndHandler("param",this,&ParamHandler::endParam); + + addStartHandler("type",this,&ParamHandler::startType); + + addStartHandler("declname"); + addEndHandler("declname",this,&ParamHandler::endDeclName); + + addStartHandler("defname"); + addEndHandler("defname",this,&ParamHandler::endDefName); + + addStartHandler("array"); + addEndHandler("array",this,&ParamHandler::endArray); + + addStartHandler("attrib"); + addEndHandler("attrib",this,&ParamHandler::endAttrib); + + addStartHandler("defval",this,&ParamHandler::startDefVal); + + m_linkedTextHandler = 0; +} + +ParamHandler::~ParamHandler() +{ +} + +void ParamHandler::startParam(const QXmlAttributes& /*attrib*/) +{ + m_parent->setDelegate(this); + printf("param\n"); +} + +void ParamHandler::endParam() +{ + m_parent->setDelegate(0); +} + +void ParamHandler::startType(const QXmlAttributes& /*attrib*/) +{ + delete m_linkedTextHandler; + m_linkedTextHandler = new LinkedTextHandler(this,m_type); + m_linkedTextHandler->start("type"); + printf("param type\n"); +} + +void ParamHandler::endDeclName() +{ + m_declName = m_curString.stripWhiteSpace(); + printf("member declName=`%s'\n",m_declName.data()); +} + +void ParamHandler::endDefName() +{ + m_defName = m_curString.stripWhiteSpace(); + printf("member defName=`%s'\n",m_defName.data()); +} + +void ParamHandler::endAttrib() +{ + m_attrib = m_curString.stripWhiteSpace(); + printf("member attrib=`%s'\n",m_attrib.data()); +} + +void ParamHandler::endArray() +{ + m_array = m_curString.stripWhiteSpace(); + printf("member array=`%s'\n",m_array.data()); +} + +void ParamHandler::startDefVal(const QXmlAttributes& /*attrib*/) +{ + delete m_linkedTextHandler; + m_linkedTextHandler = new LinkedTextHandler(this,m_defVal); + m_linkedTextHandler->start("type"); + printf("member defVal\n"); +} + + + diff --git a/addon/doxmlparser/src/paramhandler.h b/addon/doxmlparser/src/paramhandler.h new file mode 100644 index 0000000..6725a5e --- /dev/null +++ b/addon/doxmlparser/src/paramhandler.h @@ -0,0 +1,71 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#ifndef _PARAMHANDLER_H +#define _PARAMHANDLER_H + +#include <qstring.h> +#include <qlist.h> +#include <qxml.h> +#include <doxmlintf.h> + +#include "basehandler.h" +#include "baseiterator.h" +#include "linkedtexthandler.h" + +class ParamIterator : public BaseIterator<IParamIterator,IParam,IParam> +{ + public: + ParamIterator(const QList<IParam> &list) : + BaseIterator<IParamIterator,IParam,IParam>(list) {} +}; + +class ParamHandler : public IParam, public BaseHandler<ParamHandler> +{ + public: + virtual void startParam(const QXmlAttributes& attrib); + virtual void endParam(); + virtual void startType(const QXmlAttributes& attrib); + virtual void endDeclName(); + virtual void endDefName(); + virtual void endAttrib(); + virtual void endArray(); + virtual void startDefVal(const QXmlAttributes& attrib); + + ParamHandler(IBaseHandler *parent); + virtual ~ParamHandler(); + + // IParam + virtual ILinkedTextIterator *type() const + { return new LinkedTextIterator(m_type); } + virtual QString declarationName() const { return m_declName; } + virtual QString definitionName() const { return m_defName; } + virtual QString attrib() const { return m_attrib; } + virtual QString arraySpecifier() const { return m_array; } + virtual ILinkedTextIterator *defaultValue() const + { return new LinkedTextIterator(m_defVal); } + + private: + IBaseHandler *m_parent; + QList<ILinkedText> m_type; + QString m_declName; + QString m_defName; + QString m_attrib; + QString m_array; + QList<ILinkedText> m_defVal; + LinkedTextHandler *m_linkedTextHandler; +}; + +#endif diff --git a/addon/doxmlparser/src/sectionhandler.cpp b/addon/doxmlparser/src/sectionhandler.cpp new file mode 100644 index 0000000..d1c7b1f --- /dev/null +++ b/addon/doxmlparser/src/sectionhandler.cpp @@ -0,0 +1,61 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#include "mainhandler.h" +#include "compoundhandler.h" +#include "sectionhandler.h" + +SectionHandler::SectionHandler(IBaseHandler *parent) : m_parent(parent) +{ + m_members.setAutoDelete(TRUE); + addEndHandler("sectiondef",this,&SectionHandler::endSection); + addStartHandler("memberdef",this,&SectionHandler::startMember); +} + +SectionHandler::~SectionHandler() +{ +} + +void SectionHandler::startSection(const QXmlAttributes& attrib) +{ + m_parent->setDelegate(this); + m_kind = attrib.value("kind"); + printf("section kind=`%s'\n",m_kind.data()); +} + +void SectionHandler::endSection() +{ + m_parent->setDelegate(0); +} + +void SectionHandler::startMember(const QXmlAttributes& attrib) +{ + MemberHandler *memHandler = new MemberHandler(this); + memHandler->startMember(attrib); + m_members.append(memHandler); +} + +void SectionHandler::initialize(MainHandler *m) +{ + QListIterator<IMember> mli(m_members); + MemberHandler *mh; + for (;(mh=(MemberHandler *)mli.current());++mli) + { + m->insertMemberById(mh->id(),mh); + m->insertMemberByName(mh->name(),mh); + } +} + + diff --git a/addon/doxmlparser/src/sectionhandler.h b/addon/doxmlparser/src/sectionhandler.h new file mode 100644 index 0000000..234cce1 --- /dev/null +++ b/addon/doxmlparser/src/sectionhandler.h @@ -0,0 +1,62 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#ifndef _SECTIONHANDLER_H +#define _SECTIONHANDLER_H + +#include <qstring.h> +#include <qlist.h> +#include <qxml.h> +#include <doxmlintf.h> + +#include "basehandler.h" +#include "memberhandler.h" + +class MainHandler; + + +class SectionIterator : + public BaseIterator<ISectionIterator,ISection,ISection> +{ + public: + SectionIterator(const QList<ISection> &list) : + BaseIterator<ISectionIterator,ISection,ISection>(list) {} +}; + + +class SectionHandler : public ISection, public BaseHandler<SectionHandler> +{ + public: + virtual void startMember(const QXmlAttributes& attrib); + virtual void startSection(const QXmlAttributes& attrib); + virtual void endSection(); + + SectionHandler(IBaseHandler *parent); + virtual ~SectionHandler(); + + // ISection + virtual QString kind() const { return m_kind; } + virtual IMemberIterator *members() const + { return new MemberIterator(m_members); } + + void initialize(MainHandler *m); + + private: + IBaseHandler *m_parent; + QString m_kind; + QList<IMember> m_members; +}; + +#endif diff --git a/addon/doxmlparser/test/Makefile.in b/addon/doxmlparser/test/Makefile.in new file mode 100644 index 0000000..1dfbd17 --- /dev/null +++ b/addon/doxmlparser/test/Makefile.in @@ -0,0 +1,13 @@ +all clean depend: Makefile.xmlparse + $(MAKE) -f Makefile.xmlparse $@ + +distclean: clean + $(RM) -rf Makefile.xmlparse xmlparse.pro Makefile obj + +tmake: + $(ENV) $(PERL) $(TMAKE) xmlparse.pro >Makefile.xmlparse + +Makefile.xmlparse: xmlparse.pro + $(ENV) $(PERL) $(TMAKE) xmlparse.pro >Makefile.xmlparse + +install: diff --git a/addon/doxmlparser/test/main.cpp b/addon/doxmlparser/test/main.cpp new file mode 100644 index 0000000..9af575a --- /dev/null +++ b/addon/doxmlparser/test/main.cpp @@ -0,0 +1,225 @@ +/****************************************************************************** + * + * $Id$ + * + * + * Copyright (C) 1997-2001 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. + * + */ + +#include <stdio.h> +#include <doxmlintf.h> + +QString linkedTextToString(ILinkedTextIterator *ti) +{ + QString result; + ILinkedText *lt=0; + for (ti->toFirst();(lt=ti->current());ti->toNext()) + { + switch (lt->kind()) + { + case ILinkedText::Kind_Text: + result+=dynamic_cast<ILT_Text*>(lt)->text(); break; + case ILinkedText::Kind_Ref: + result+=dynamic_cast<ILT_Ref *>(lt)->text(); break; + } + } + return result; +} + +void DumpDoc(IDoc *doc) +{ + printf(" doc node kind=`%d'\n",doc->kind()); + switch (doc->kind()) + { + case IDoc::Para: + { + printf(" --- par --- \n"); + IDocPara *par = dynamic_cast<IDocPara*>(doc); + ASSERT(par!=0); + IDocIterator *di = par->contents(); + IDoc *pdoc; + for (di->toFirst();(pdoc=di->current());di->toNext()) + { + DumpDoc(pdoc); + } + di->release(); + printf(" --- end par --- \n"); + } + break; + case IDoc::Text: + { + IDocText *txt = dynamic_cast<IDocText*>(doc); + ASSERT(txt!=0); + printf(" --- text `%s' markup=%d --- \n",txt->text().data(),txt->markup()); + } + break; + case IDoc::Title: + { + printf(" --- title --- \n"); + IDocTitle *t = dynamic_cast<IDocTitle*>(doc); + ASSERT(t!=0); + IDocIterator *di = t->title(); + IDoc *pdoc; + for (di->toFirst();(pdoc=di->current());di->toNext()) + { + DumpDoc(pdoc); + } + printf(" --- end title --- \n"); + } + break; + case IDoc::Section: + { + IDocSection *sec = dynamic_cast<IDocSection*>(doc); + ASSERT(sec!=0); + printf(" --- section id=`%s' level=%d --- \n", + sec->id().data(),sec->level()); + IDocIterator *di = sec->title(); + IDoc *pdoc; + for (di->toFirst();(pdoc=di->current());di->toNext()) + { + DumpDoc(pdoc); + } + printf(" --- end section --- \n"); + } + break; + case IDoc::Root: + { + printf(" --- root --- \n"); + IDocRoot *root = dynamic_cast<IDocRoot*>(doc); + ASSERT(root!=0); + IDocIterator *di = root->contents(); + IDoc *pdoc; + for (di->toFirst();(pdoc=di->current());di->toNext()) + { + DumpDoc(pdoc); + } + di->release(); + printf(" --- end root --- \n"); + } + break; + + default: + break; + } +} + +int main(int argc,char **argv) +{ + if (argc!=2) + { + printf("Usage: %s file.xml\n",argv[0]); + exit(1); + } + + IDoxygen *dox = createObjectModelFromXML(argv[1]); + + ICompoundIterator *cli = dox->compounds(); + ICompound *comp; + printf("--- compound list ---------\n"); + for (cli->toFirst();(comp=cli->current());cli->toNext()) + { + printf("Compound name=%s id=%s kind=%s\n", + comp->name().data(),comp->id().data(),comp->kind().data()); + ISectionIterator *sli = comp->sections(); + ISection *sec; + for (sli->toFirst();(sec=sli->current());sli->toNext()) + { + printf(" Section kind=%s\n",sec->kind().data()); + IMemberIterator *mli = sec->members(); + IMember *mem; + for (mli->toFirst();(mem=mli->current());mli->toNext()) + { + ILinkedTextIterator *lti = mem->type(); + printf(" Member type=%s name=%s\n", + linkedTextToString(lti).data(),mem->name().data()); + lti->release(); + + IParamIterator *pli = mem->params(); + IParam *par; + for (pli->toFirst();(par=pli->current());pli->toNext()) + { + lti = par->type(); + QString parType = linkedTextToString(lti); + lti->release(); + lti = par->defaultValue(); + QString defVal = linkedTextToString(lti); + lti->release(); + printf(" Param type=%s name=%s defvalue=%s\n", + parType.data(), par->definitionName().data(),defVal.data()); + } + pli->release(); + IMemberReferenceIterator *mri = mem->references(); + IMemberReference *mr; + for (mri->toFirst();(mr=mri->current());mri->toNext()) + { + IMember *memr = mr->member(); + printf(" References %s at line %d\n", + mr->memberName().data(),memr->bodyStart()); + } + + mri->release(); + mri = mem->referencedBy(); + for (mri->toFirst();(mr=mri->current());mri->toNext()) + { + IMember *memr = mr->member(); + printf(" ReferencedBy %s at line %d\n", + mr->memberName().data(),memr->bodyStart()); + } + mri->release(); + + IEnumValueIterator *evi = mem->enumValues(); + IEnumValue *ev; + for (evi->toFirst();(ev=evi->current());evi->toNext()) + { + printf(" Enum value `%s' init=`%s'\n", + ev->name().data(),ev->initializer().data()); + } + evi->release(); + + IDoc *doc = mem->briefDescription(); + if (doc) + { + printf("===== brief description ==== \n"); + DumpDoc(doc); + } + + doc = mem->detailedDescription(); + if (doc) + { + printf("===== detailed description ==== \n"); + DumpDoc(doc); + } + } + mli->release(); + } + sli->release(); + + IDoc *doc = comp->briefDescription(); + if (doc) + { + printf("===== brief description ==== \n"); + DumpDoc(doc); + } + + doc = comp->detailedDescription(); + if (doc) + { + printf("===== detailed description ==== \n"); + DumpDoc(doc); + } + } + cli->release(); + printf("---------------------------\n"); + + dox->release(); + + return 0; +} + diff --git a/addon/doxmlparser/test/xmlparse.pro.in b/addon/doxmlparser/test/xmlparse.pro.in new file mode 100644 index 0000000..1dc095b --- /dev/null +++ b/addon/doxmlparser/test/xmlparse.pro.in @@ -0,0 +1,19 @@ +TEMPLATE = app.t +CONFIG = console warn_on $extraopts +HEADERS = +SOURCES = main.cpp +unix:LIBS += -L../../../lib -L../lib -ldoxmlparser -lqtools +win32:INCLUDEPATH += . +win32-mingw:LIBS += -L../../../lib -L../lib -ldoxmlparser -lqtools +win32-msvc:LIBS += doxmlparser.lib qtools.lib shell32.lib +win32-msvc:TMAKE_LFLAGS += /LIBPATH:..\..\..\lib;..\lib +win32-borland:LIBS += doxmlparser.lib qtools.lib shell32.lib +win32-borland:TMAKE_LFLAGS += -L..\..\..\lib -L..\lib +win32:TMAKE_CXXFLAGS += -DQT_NODLL +DESTDIR = +OBJECTS_DIR = ../objects +TARGET = xmlparse +INCLUDEPATH += ../../../qtools ../include +unix:TARGETDEPS = ../lib/libdoxmlparser.a +win32:TARGETDEPS = ..\lib\doxmlparser.lib + |