adding the breathe files

doc/breathe/parser/__init__.py

@@ -0,0 +1,118 @@
+
+import breathe.parser.doxygen.index
+import breathe.parser.doxygen.compound
+
+class ParserError(Exception):
+
+    def __init__(self, error, filename):
+        Exception.__init__(self, error)
+
+        self.error = error
+        self.filename = filename
+
+class FileIOError(Exception):
+
+    def __init__(self, error, filename):
+        Exception.__init__(self, error)
+
+        self.error = error
+        self.filename = filename
+
+class Parser(object):
+
+    def __init__(self, cache, path_handler, file_state_cache):
+
+        self.cache = cache
+        self.path_handler = path_handler
+        self.file_state_cache = file_state_cache
+
+class DoxygenIndexParser(Parser):
+
+    def __init__(self, cache, path_handler, file_state_cache):
+        Parser.__init__(self, cache, path_handler, file_state_cache)
+
+    def parse(self, project_info):
+
+        filename = self.path_handler.resolve_path(
+                project_info.project_path(),
+                "index.xml"
+                )
+
+        self.file_state_cache.update(filename)
+
+        try: 
+            # Try to get from our cache
+            return self.cache[filename]
+        except KeyError:
+
+            # If that fails, parse it afresh
+            try:
+                result = breathe.parser.doxygen.index.parse(filename)
+                self.cache[filename] = result
+                return result
+            except breathe.parser.doxygen.index.ParseError as e:
+                raise ParserError(e, filename)
+            except breathe.parser.doxygen.index.FileIOError as e:
+                raise FileIOError(e, filename)
+
+class DoxygenCompoundParser(Parser):
+
+    def __init__(self, cache, path_handler, file_state_cache, project_info):
+        Parser.__init__(self, cache, path_handler, file_state_cache)
+
+        self.project_info = project_info
+
+    def parse(self, refid):
+
+        filename = self.path_handler.resolve_path(
+                self.project_info.project_path(),
+                "%s.xml" % refid
+                )
+
+        self.file_state_cache.update(filename)
+
+        try: 
+            # Try to get from our cache
+            return self.cache[filename]
+        except KeyError:
+
+            # If that fails, parse it afresh
+            try:
+                result = breathe.parser.doxygen.compound.parse(filename)
+                self.cache[filename] = result
+                return result
+            except breathe.parser.doxygen.compound.ParseError as e:
+                raise ParserError(e, filename)
+            except breathe.parser.doxygen.compound.FileIOError as e:
+                raise FileIOError(e, filename)
+
+class CacheFactory(object):
+
+    def create_cache(self):
+
+        # Return basic dictionary as cache
+        return {}
+
+class DoxygenParserFactory(object):
+
+    def __init__(self, cache, path_handler, file_state_cache):
+
+        self.cache = cache
+        self.path_handler = path_handler
+        self.file_state_cache = file_state_cache
+
+    def create_index_parser(self):
+
+        return DoxygenIndexParser(self.cache, self.path_handler, self.file_state_cache)
+
+    def create_compound_parser(self, project_info):
+
+        return DoxygenCompoundParser(
+                self.cache,
+                self.path_handler,
+                self.file_state_cache,
+                project_info
+                )
+
+
+

doc/breathe/parser/doxygen/compound.py

@@ -0,0 +1,964 @@
+#!/usr/bin/env python
+
+"""
+Generated Mon Feb  9 19:08:05 2009 by generateDS.py.
+"""
+
+from xml.dom import minidom
+from xml.dom import Node
+from xml.parsers.expat import ExpatError
+
+from . import compoundsuper as supermod
+from .compoundsuper import MixedContainer
+
+
+class DoxygenTypeSub(supermod.DoxygenType):
+
+    node_type = "doxygendef"
+
+    def __init__(self, version=None, compounddef=None):
+        supermod.DoxygenType.__init__(self, version, compounddef)
+supermod.DoxygenType.subclass = DoxygenTypeSub
+# end class DoxygenTypeSub
+
+
+class compounddefTypeSub(supermod.compounddefType):
+
+    node_type = "compounddef"
+
+    def __init__(self, kind=None, prot=None, id=None, compoundname='', title='',
+                 basecompoundref=None, derivedcompoundref=None, includes=None, includedby=None,
+                 incdepgraph=None, invincdepgraph=None, innerdir=None, innerfile=None,
+                 innerclass=None, innernamespace=None, innerpage=None, innergroup=None,
+                 templateparamlist=None, sectiondef=None, briefdescription=None,
+                 detaileddescription=None, inheritancegraph=None, collaborationgraph=None,
+                 programlisting=None, location=None, listofallmembers=None):
+
+        supermod.compounddefType.__init__(self, kind, prot, id, compoundname, title,
+                                          basecompoundref, derivedcompoundref, includes, includedby,
+                                          incdepgraph, invincdepgraph, innerdir, innerfile,
+                                          innerclass, innernamespace, innerpage, innergroup,
+                                          templateparamlist, sectiondef, briefdescription,
+                                          detaileddescription, inheritancegraph, collaborationgraph,
+                                          programlisting, location, listofallmembers)
+
+supermod.compounddefType.subclass = compounddefTypeSub
+# end class compounddefTypeSub
+
+
+class listofallmembersTypeSub(supermod.listofallmembersType):
+
+    node_type = "listofallmembers"
+
+    def __init__(self, member=None):
+        supermod.listofallmembersType.__init__(self, member)
+supermod.listofallmembersType.subclass = listofallmembersTypeSub
+# end class listofallmembersTypeSub
+
+
+class memberRefTypeSub(supermod.memberRefType):
+
+    node_type = "memberref"
+
+    def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope='', name=''):
+        supermod.memberRefType.__init__(self, virt, prot, refid, ambiguityscope, scope, name)
+supermod.memberRefType.subclass = memberRefTypeSub
+# end class memberRefTypeSub
+
+
+class compoundRefTypeSub(supermod.compoundRefType):
+
+    node_type = "compoundref"
+
+    def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None,
+                 content_=None):
+        supermod.compoundRefType.__init__(self, mixedclass_, content_)
+supermod.compoundRefType.subclass = compoundRefTypeSub
+# end class compoundRefTypeSub
+
+
+class reimplementTypeSub(supermod.reimplementType):
+
+    node_type = "reimplement"
+
+    def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None):
+        supermod.reimplementType.__init__(self, mixedclass_, content_)
+supermod.reimplementType.subclass = reimplementTypeSub
+# end class reimplementTypeSub
+
+
+class incTypeSub(supermod.incType):
+
+    node_type = "inc"
+
+    def __init__(self, local=None, refid=None, valueOf_='', mixedclass_=None, content_=None):
+        supermod.incType.__init__(self, mixedclass_, content_)
+supermod.incType.subclass = incTypeSub
+# end class incTypeSub
+
+
+class refTypeSub(supermod.refType):
+
+    node_type = "ref"
+
+    def __init__(self, node_name, prot=None, refid=None, valueOf_='', mixedclass_=None,
+                 content_=None):
+        supermod.refType.__init__(self, mixedclass_, content_)
+
+        self.node_name = node_name
+
+supermod.refType.subclass = refTypeSub
+
+
+class refTextTypeSub(supermod.refTextType):
+
+    node_type = "reftex"
+
+    def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None,
+                 content_=None):
+        supermod.refTextType.__init__(self, mixedclass_, content_)
+
+supermod.refTextType.subclass = refTextTypeSub
+# end class refTextTypeSub
+
+
+class sectiondefTypeSub(supermod.sectiondefType):
+
+    node_type = "sectiondef"
+
+    def __init__(self, kind=None, header='', description=None, memberdef=None):
+        supermod.sectiondefType.__init__(self, kind, header, description, memberdef)
+
+supermod.sectiondefType.subclass = sectiondefTypeSub
+# end class sectiondefTypeSub
+
+
+class memberdefTypeSub(supermod.memberdefType):
+
+    node_type = "memberdef"
+
+    def __init__(self, initonly=None, kind=None, volatile=None, const=None, raise_=None, virt=None,
+                 readable=None, prot=None, explicit=None, new=None, final=None, writable=None,
+                 add=None, static=None, remove=None, sealed=None, mutable=None, gettable=None,
+                 inline=None, settable=None, id=None, templateparamlist=None, type_=None,
+                 definition='', argsstring='', name='', read='', write='', bitfield='',
+                 reimplements=None, reimplementedby=None, param=None, enumvalue=None,
+                 initializer=None, exceptions=None, briefdescription=None, detaileddescription=None,
+                 inbodydescription=None, location=None, references=None, referencedby=None):
+
+        supermod.memberdefType.__init__(self, initonly, kind, volatile, const, raise_, virt,
+                                        readable, prot, explicit, new, final, writable, add, static,
+                                        remove, sealed, mutable, gettable, inline, settable, id,
+                                        templateparamlist, type_, definition, argsstring, name,
+                                        read, write, bitfield, reimplements, reimplementedby, param,
+                                        enumvalue, initializer, exceptions, briefdescription,
+                                        detaileddescription, inbodydescription, location,
+                                        references, referencedby)
+
+        self.parameterlist = supermod.docParamListType.factory()
+        self.parameterlist.kind = "param"
+
+    def buildChildren(self, child_, nodeName_):
+        supermod.memberdefType.buildChildren(self, child_, nodeName_)
+
+        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'param':
+
+            # Get latest param
+            param = self.param[-1]
+
+            # If it doesn't have a description we're done
+            if not param.briefdescription:
+                return
+
+            # Construct our own param list from the descriptions stored inline
+            # with the parameters
+            paramdescription = param.briefdescription
+            paramname = supermod.docParamName.factory()
+
+            # Add parameter name
+            obj_ = paramname.mixedclass_(MixedContainer.CategoryText, MixedContainer.TypeNone, '',
+                                         param.declname)
+            paramname.content_.append(obj_)
+
+            paramnamelist = supermod.docParamNameList.factory()
+            paramnamelist.parametername.append(paramname)
+
+            paramlistitem = supermod.docParamListItem.factory()
+            paramlistitem.parameternamelist.append(paramnamelist)
+
+            # Add parameter description
+            paramlistitem.parameterdescription = paramdescription
+
+            self.parameterlist.parameteritem.append(paramlistitem)
+
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'detaileddescription':
+
+            if not self.parameterlist.parameteritem:
+                # No items in our list
+                return
+
+            # Assume supermod.memberdefType.buildChildren has already built the
+            # description object, we just want to slot our parameterlist in at
+            # a reasonable point
+
+            if not self.detaileddescription:
+                # Create one if it doesn't exist
+                self.detaileddescription = supermod.descriptionType.factory()
+
+            detaileddescription = self.detaileddescription
+
+            para = supermod.docParaType.factory()
+            para.parameterlist.append(self.parameterlist)
+
+            obj_ = detaileddescription.mixedclass_(MixedContainer.CategoryComplex,
+                                                   MixedContainer.TypeNone, 'para', para)
+
+            index = 0
+            detaileddescription.content_.insert(index, obj_)
+
+
+supermod.memberdefType.subclass = memberdefTypeSub
+# end class memberdefTypeSub
+
+
+class descriptionTypeSub(supermod.descriptionType):
+
+    node_type = "description"
+
+    def __init__(self, title='', para=None, sect1=None, internal=None, mixedclass_=None,
+                 content_=None):
+        supermod.descriptionType.__init__(self, mixedclass_, content_)
+
+supermod.descriptionType.subclass = descriptionTypeSub
+# end class descriptionTypeSub
+
+
+class enumvalueTypeSub(supermod.enumvalueType):
+
+    node_type = "enumvalue"
+
+    def __init__(self, prot=None, id=None, name='', initializer=None, briefdescription=None,
+                 detaileddescription=None, mixedclass_=None, content_=None):
+        supermod.enumvalueType.__init__(self, mixedclass_, content_)
+
+        self.initializer = None
+
+    def buildChildren(self, child_, nodeName_):
+        # Get text from <name> child and put it in self.name
+        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'name':
+            value_ = []
+            for text_ in child_.childNodes:
+                value_.append(text_.nodeValue)
+            valuestr_ = ''.join(value_)
+            self.name = valuestr_
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'briefdescription':
+            obj_ = supermod.descriptionType.factory()
+            obj_.build(child_)
+            self.set_briefdescription(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'detaileddescription':
+            obj_ = supermod.descriptionType.factory()
+            obj_.build(child_)
+            self.set_detaileddescription(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'initializer':
+            childobj_ = supermod.linkedTextType.factory()
+            childobj_.build(child_)
+            obj_ = self.mixedclass_(MixedContainer.CategoryComplex, MixedContainer.TypeNone,
+                                    'initializer', childobj_)
+            self.set_initializer(obj_)
+            self.content_.append(obj_)
+
+supermod.enumvalueType.subclass = enumvalueTypeSub
+# end class enumvalueTypeSub
+
+
+class templateparamlistTypeSub(supermod.templateparamlistType):
+
+    node_type = "templateparamlist"
+
+    def __init__(self, param=None):
+        supermod.templateparamlistType.__init__(self, param)
+supermod.templateparamlistType.subclass = templateparamlistTypeSub
+# end class templateparamlistTypeSub
+
+
+class paramTypeSub(supermod.paramType):
+
+    node_type = "param"
+
+    def __init__(self, type_=None, declname='', defname='', array='', defval=None,
+                 briefdescription=None):
+        supermod.paramType.__init__(self, type_, declname, defname, array, defval, briefdescription)
+supermod.paramType.subclass = paramTypeSub
+# end class paramTypeSub
+
+
+class linkedTextTypeSub(supermod.linkedTextType):
+
+    node_type = "linkedtext"
+
+    def __init__(self, ref=None, mixedclass_=None, content_=None):
+        supermod.linkedTextType.__init__(self, mixedclass_, content_)
+supermod.linkedTextType.subclass = linkedTextTypeSub
+# end class linkedTextTypeSub
+
+
+class graphTypeSub(supermod.graphType):
+
+    node_type = "graph"
+
+    def __init__(self, node=None):
+        supermod.graphType.__init__(self, node)
+supermod.graphType.subclass = graphTypeSub
+# end class graphTypeSub
+
+
+class nodeTypeSub(supermod.nodeType):
+
+    node_type = "node"
+
+    def __init__(self, id=None, label='', link=None, childnode=None):
+        supermod.nodeType.__init__(self, id, label, link, childnode)
+supermod.nodeType.subclass = nodeTypeSub
+# end class nodeTypeSub
+
+
+class childnodeTypeSub(supermod.childnodeType):
+
+    node_type = "childnode"
+
+    def __init__(self, relation=None, refid=None, edgelabel=None):
+        supermod.childnodeType.__init__(self, relation, refid, edgelabel)
+supermod.childnodeType.subclass = childnodeTypeSub
+# end class childnodeTypeSub
+
+
+class linkTypeSub(supermod.linkType):
+
+    node_type = "link"
+
+    def __init__(self, refid=None, external=None, valueOf_=''):
+        supermod.linkType.__init__(self, refid, external)
+supermod.linkType.subclass = linkTypeSub
+# end class linkTypeSub
+
+
+class listingTypeSub(supermod.listingType):
+
+    node_type = "listing"
+
+    def __init__(self, codeline=None):
+        supermod.listingType.__init__(self, codeline)
+supermod.listingType.subclass = listingTypeSub
+# end class listingTypeSub
+
+
+class codelineTypeSub(supermod.codelineType):
+
+    node_type = "codeline"
+
+    def __init__(self, external=None, lineno=None, refkind=None, refid=None, highlight=None):
+        supermod.codelineType.__init__(self, external, lineno, refkind, refid, highlight)
+supermod.codelineType.subclass = codelineTypeSub
+# end class codelineTypeSub
+
+
+class highlightTypeSub(supermod.highlightType):
+
+    node_type = "highlight"
+
+    def __init__(self, class_=None, sp=None, ref=None, mixedclass_=None, content_=None):
+        supermod.highlightType.__init__(self, mixedclass_, content_)
+supermod.highlightType.subclass = highlightTypeSub
+# end class highlightTypeSub
+
+
+class referenceTypeSub(supermod.referenceType):
+
+    node_type = "reference"
+
+    def __init__(self, endline=None, startline=None, refid=None, compoundref=None, valueOf_='',
+                 mixedclass_=None, content_=None):
+        supermod.referenceType.__init__(self, mixedclass_, content_)
+supermod.referenceType.subclass = referenceTypeSub
+# end class referenceTypeSub
+
+
+class locationTypeSub(supermod.locationType):
+
+    node_type = "location"
+
+    def __init__(self, bodystart=None, line=None, bodyend=None, bodyfile=None, file=None,
+                 valueOf_=''):
+        supermod.locationType.__init__(self, bodystart, line, bodyend, bodyfile, file)
+supermod.locationType.subclass = locationTypeSub
+# end class locationTypeSub
+
+
+class docSect1TypeSub(supermod.docSect1Type):
+
+    node_type = "docsect1"
+
+    def __init__(self, id=None, title='', para=None, sect2=None, internal=None, mixedclass_=None,
+                 content_=None):
+        supermod.docSect1Type.__init__(self, mixedclass_, content_)
+supermod.docSect1Type.subclass = docSect1TypeSub
+# end class docSect1TypeSub
+
+
+class docSect2TypeSub(supermod.docSect2Type):
+
+    node_type = "docsect2"
+
+    def __init__(self, id=None, title='', para=None, sect3=None, internal=None, mixedclass_=None,
+                 content_=None):
+        supermod.docSect2Type.__init__(self, mixedclass_, content_)
+supermod.docSect2Type.subclass = docSect2TypeSub
+# end class docSect2TypeSub
+
+
+class docSect3TypeSub(supermod.docSect3Type):
+
+    node_type = "docsect3"
+
+    def __init__(self, id=None, title='', para=None, sect4=None, internal=None, mixedclass_=None,
+                 content_=None):
+        supermod.docSect3Type.__init__(self, mixedclass_, content_)
+supermod.docSect3Type.subclass = docSect3TypeSub
+# end class docSect3TypeSub
+
+
+class docSect4TypeSub(supermod.docSect4Type):
+
+    node_type = "docsect4"
+
+    def __init__(self, id=None, title='', para=None, internal=None, mixedclass_=None,
+                 content_=None):
+        supermod.docSect4Type.__init__(self, mixedclass_, content_)
+supermod.docSect4Type.subclass = docSect4TypeSub
+# end class docSect4TypeSub
+
+
+class docInternalTypeSub(supermod.docInternalType):
+
+    node_type = "docinternal"
+
+    def __init__(self, para=None, sect1=None, mixedclass_=None, content_=None):
+        supermod.docInternalType.__init__(self, mixedclass_, content_)
+supermod.docInternalType.subclass = docInternalTypeSub
+# end class docInternalTypeSub
+
+
+class docInternalS1TypeSub(supermod.docInternalS1Type):
+
+    node_type = "docinternals1"
+
+    def __init__(self, para=None, sect2=None, mixedclass_=None, content_=None):
+        supermod.docInternalS1Type.__init__(self, mixedclass_, content_)
+supermod.docInternalS1Type.subclass = docInternalS1TypeSub
+# end class docInternalS1TypeSub
+
+
+class docInternalS2TypeSub(supermod.docInternalS2Type):
+
+    node_type = "docinternals2"
+
+    def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):
+        supermod.docInternalS2Type.__init__(self, mixedclass_, content_)
+supermod.docInternalS2Type.subclass = docInternalS2TypeSub
+# end class docInternalS2TypeSub
+
+
+class docInternalS3TypeSub(supermod.docInternalS3Type):
+
+    node_type = "docinternals3"
+
+    def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):
+        supermod.docInternalS3Type.__init__(self, mixedclass_, content_)
+supermod.docInternalS3Type.subclass = docInternalS3TypeSub
+# end class docInternalS3TypeSub
+
+
+class docInternalS4TypeSub(supermod.docInternalS4Type):
+
+    node_type = "docinternals4"
+
+    def __init__(self, para=None, mixedclass_=None, content_=None):
+        supermod.docInternalS4Type.__init__(self, mixedclass_, content_)
+supermod.docInternalS4Type.subclass = docInternalS4TypeSub
+# end class docInternalS4TypeSub
+
+
+class docURLLinkSub(supermod.docURLLink):
+
+    node_type = "docurllink"
+
+    def __init__(self, url=None, valueOf_='', mixedclass_=None, content_=None):
+        supermod.docURLLink.__init__(self, mixedclass_, content_)
+supermod.docURLLink.subclass = docURLLinkSub
+# end class docURLLinkSub
+
+
+class docAnchorTypeSub(supermod.docAnchorType):
+
+    node_type = "docanchor"
+
+    def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
+        supermod.docAnchorType.__init__(self, mixedclass_, content_)
+supermod.docAnchorType.subclass = docAnchorTypeSub
+# end class docAnchorTypeSub
+
+
+class docFormulaTypeSub(supermod.docFormulaType):
+
+    node_type = "docformula"
+
+    def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
+        supermod.docFormulaType.__init__(self, mixedclass_, content_)
+supermod.docFormulaType.subclass = docFormulaTypeSub
+# end class docFormulaTypeSub
+
+
+class docIndexEntryTypeSub(supermod.docIndexEntryType):
+
+    node_type = "docindexentry"
+
+    def __init__(self, primaryie='', secondaryie=''):
+        supermod.docIndexEntryType.__init__(self, primaryie, secondaryie)
+supermod.docIndexEntryType.subclass = docIndexEntryTypeSub
+# end class docIndexEntryTypeSub
+
+
+class docListTypeSub(supermod.docListType):
+
+    node_type = "doclist"
+
+    def __init__(self, listitem=None, subtype=""):
+        self.node_subtype = "itemized"
+        if subtype is not "":
+            self.node_subtype = subtype
+        supermod.docListType.__init__(self, listitem)
+supermod.docListType.subclass = docListTypeSub
+# end class docListTypeSub
+
+
+class docListItemTypeSub(supermod.docListItemType):
+
+    node_type = "doclistitem"
+
+    def __init__(self, para=None):
+        supermod.docListItemType.__init__(self, para)
+supermod.docListItemType.subclass = docListItemTypeSub
+# end class docListItemTypeSub
+
+
+class docSimpleSectTypeSub(supermod.docSimpleSectType):
+
+    node_type = "docsimplesect"
+
+    def __init__(self, kind=None, title=None, para=None):
+        supermod.docSimpleSectType.__init__(self, kind, title, para)
+supermod.docSimpleSectType.subclass = docSimpleSectTypeSub
+# end class docSimpleSectTypeSub
+
+
+class docVarListEntryTypeSub(supermod.docVarListEntryType):
+
+    node_type = "docvarlistentry"
+
+    def __init__(self, term=None):
+        supermod.docVarListEntryType.__init__(self, term)
+supermod.docVarListEntryType.subclass = docVarListEntryTypeSub
+# end class docVarListEntryTypeSub
+
+
+class docRefTextTypeSub(supermod.docRefTextType):
+
+    node_type = "docreftext"
+
+    def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None,
+                 content_=None):
+        supermod.docRefTextType.__init__(self, mixedclass_, content_)
+
+        self.para = []
+
+    def buildChildren(self, child_, nodeName_):
+        supermod.docRefTextType.buildChildren(self, child_, nodeName_)
+
+        if child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'para':
+            obj_ = supermod.docParaType.factory()
+            obj_.build(child_)
+            self.para.append(obj_)
+
+supermod.docRefTextType.subclass = docRefTextTypeSub
+# end class docRefTextTypeSub
+
+
+class docTableTypeSub(supermod.docTableType):
+
+    node_type = "doctable"
+
+    def __init__(self, rows=None, cols=None, row=None, caption=None):
+        supermod.docTableType.__init__(self, rows, cols, row, caption)
+supermod.docTableType.subclass = docTableTypeSub
+# end class docTableTypeSub
+
+
+class docRowTypeSub(supermod.docRowType):
+
+    node_type = "docrow"
+
+    def __init__(self, entry=None):
+        supermod.docRowType.__init__(self, entry)
+supermod.docRowType.subclass = docRowTypeSub
+# end class docRowTypeSub
+
+
+class docEntryTypeSub(supermod.docEntryType):
+
+    node_type = "docentry"
+
+    def __init__(self, thead=None, para=None):
+        supermod.docEntryType.__init__(self, thead, para)
+supermod.docEntryType.subclass = docEntryTypeSub
+# end class docEntryTypeSub
+
+
+class docHeadingTypeSub(supermod.docHeadingType):
+
+    node_type = "docheading"
+
+    def __init__(self, level=None, valueOf_='', mixedclass_=None, content_=None):
+        supermod.docHeadingType.__init__(self, mixedclass_, content_)
+
+    def buildChildren(self, child_, nodeName_):
+        supermod.docHeadingType.buildChildren(self, child_, nodeName_)
+
+        # Account for styled content in the heading. This might need to be expanded to include other
+        # nodes as it seems from the xsd that headings can have a lot of different children but we
+        # really don't expect most of them to come up.
+        if child_.nodeType == Node.ELEMENT_NODE and (
+                nodeName_ == 'bold' or
+                nodeName_ == 'emphasis' or
+                nodeName_ == 'computeroutput' or
+                nodeName_ == 'subscript' or
+                nodeName_ == 'superscript' or
+                nodeName_ == 'center' or
+                nodeName_ == 'small'):
+            obj_ = supermod.docMarkupType.factory()
+            obj_.build(child_)
+            obj_.type_ = nodeName_
+            self.content_.append(obj_)
+
+supermod.docHeadingType.subclass = docHeadingTypeSub
+# end class docHeadingTypeSub
+
+
+class docImageTypeSub(supermod.docImageType):
+
+    node_type = "docimage"
+
+    def __init__(self, width=None, type_=None, name=None, height=None, valueOf_='',
+                 mixedclass_=None, content_=None):
+        supermod.docImageType.__init__(self, mixedclass_, content_)
+supermod.docImageType.subclass = docImageTypeSub
+# end class docImageTypeSub
+
+
+class docDotFileTypeSub(supermod.docDotFileType):
+
+    node_type = "docdocfile"
+
+    def __init__(self, name=None, valueOf_='', mixedclass_=None, content_=None):
+        supermod.docDotFileType.__init__(self, mixedclass_, content_)
+supermod.docDotFileType.subclass = docDotFileTypeSub
+# end class docDotFileTypeSub
+
+
+class docTocItemTypeSub(supermod.docTocItemType):
+
+    node_type = "doctocitem"
+
+    def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
+        supermod.docTocItemType.__init__(self, mixedclass_, content_)
+supermod.docTocItemType.subclass = docTocItemTypeSub
+# end class docTocItemTypeSub
+
+
+class docTocListTypeSub(supermod.docTocListType):
+
+    node_type = "doctoclist"
+
+    def __init__(self, tocitem=None):
+        supermod.docTocListType.__init__(self, tocitem)
+supermod.docTocListType.subclass = docTocListTypeSub
+# end class docTocListTypeSub
+
+
+class docLanguageTypeSub(supermod.docLanguageType):
+
+    node_type = "doclanguage"
+
+    def __init__(self, langid=None, para=None):
+        supermod.docLanguageType.__init__(self, langid, para)
+supermod.docLanguageType.subclass = docLanguageTypeSub
+# end class docLanguageTypeSub
+
+
+class docParamListTypeSub(supermod.docParamListType):
+
+    node_type = "docparamlist"
+
+    def __init__(self, kind=None, parameteritem=None):
+        supermod.docParamListType.__init__(self, kind, parameteritem)
+supermod.docParamListType.subclass = docParamListTypeSub
+# end class docParamListTypeSub
+
+
+class docParamListItemSub(supermod.docParamListItem):
+
+    node_type = "docparamlistitem"
+
+    def __init__(self, parameternamelist=None, parameterdescription=None):
+        supermod.docParamListItem.__init__(self, parameternamelist, parameterdescription)
+supermod.docParamListItem.subclass = docParamListItemSub
+# end class docParamListItemSub
+
+
+class docParamNameListSub(supermod.docParamNameList):
+
+    node_type = "docparamnamelist"
+
+    def __init__(self, parametername=None):
+        supermod.docParamNameList.__init__(self, parametername)
+supermod.docParamNameList.subclass = docParamNameListSub
+# end class docParamNameListSub
+
+
+class docParamNameSub(supermod.docParamName):
+
+    node_type = "docparamname"
+
+    def __init__(self, direction=None, ref=None, mixedclass_=None, content_=None):
+        supermod.docParamName.__init__(self, mixedclass_, content_)
+supermod.docParamName.subclass = docParamNameSub
+# end class docParamNameSub
+
+
+class docXRefSectTypeSub(supermod.docXRefSectType):
+
+    node_type = "docxrefsect"
+
+    def __init__(self, id=None, xreftitle=None, xrefdescription=None):
+        supermod.docXRefSectType.__init__(self, id, xreftitle, xrefdescription)
+supermod.docXRefSectType.subclass = docXRefSectTypeSub
+# end class docXRefSectTypeSub
+
+
+class docCopyTypeSub(supermod.docCopyType):
+
+    node_type = "doccopy"
+
+    def __init__(self, link=None, para=None, sect1=None, internal=None):
+        supermod.docCopyType.__init__(self, link, para, sect1, internal)
+supermod.docCopyType.subclass = docCopyTypeSub
+# end class docCopyTypeSub
+
+
+class docCharTypeSub(supermod.docCharType):
+
+    node_type = "docchar"
+
+    def __init__(self, char=None, valueOf_=''):
+        supermod.docCharType.__init__(self, char)
+supermod.docCharType.subclass = docCharTypeSub
+# end class docCharTypeSub
+
+
+class verbatimTypeSub(object):
+    """
+    New node type. Structure is largely pillaged from other nodes in order to
+    match the set.
+    """
+
+    node_type = "verbatim"
+
+    def __init__(self, valueOf_='', mixedclass_=None, content_=None):
+        if mixedclass_ is None:
+            self.mixedclass_ = MixedContainer
+        else:
+            self.mixedclass_ = mixedclass_
+        if content_ is None:
+            self.content_ = []
+        else:
+            self.content_ = content_
+        self.text = ""
+
+    def factory(*args, **kwargs):
+        return verbatimTypeSub(*args, **kwargs)
+
+    factory = staticmethod(factory)
+
+    def buildAttributes(self, attrs):
+        pass
+
+    def build(self, node_):
+        attrs = node_.attributes
+        self.buildAttributes(attrs)
+        self.valueOf_ = ''
+        for child_ in node_.childNodes:
+            nodeName_ = child_.nodeName.split(':')[-1]
+            self.buildChildren(child_, nodeName_)
+
+    def buildChildren(self, child_, nodeName_):
+        if child_.nodeType == Node.TEXT_NODE:
+            self.text += child_.nodeValue
+
+
+class docParaTypeSub(supermod.docParaType):
+
+    node_type = "docpara"
+
+    def __init__(self, char=None, valueOf_=''):
+        supermod.docParaType.__init__(self, char)
+
+        self.parameterlist = []
+        self.simplesects = []
+        self.content = []
+        self.programlisting = []
+        self.images = []
+
+    def buildChildren(self, child_, nodeName_):
+        supermod.docParaType.buildChildren(self, child_, nodeName_)
+
+        if child_.nodeType == Node.TEXT_NODE:
+            obj_ = self.mixedclass_(MixedContainer.CategoryText,
+                                    MixedContainer.TypeNone, '', child_.nodeValue)
+            self.content.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "ref":
+            obj_ = supermod.docRefTextType.factory()
+            obj_.build(child_)
+            self.content.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'parameterlist':
+            obj_ = supermod.docParamListType.factory()
+            obj_.build(child_)
+            self.parameterlist.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'simplesect':
+            obj_ = supermod.docSimpleSectType.factory()
+            obj_.build(child_)
+            self.simplesects.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'programlisting':
+            obj_ = supermod.listingType.factory()
+            obj_.build(child_)
+            self.programlisting.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'image':
+            obj_ = supermod.docImageType.factory()
+            obj_.build(child_)
+            self.images.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and (
+                nodeName_ == 'bold' or
+                nodeName_ == 'emphasis' or
+                nodeName_ == 'computeroutput' or
+                nodeName_ == 'subscript' or
+                nodeName_ == 'superscript' or
+                nodeName_ == 'center' or
+                nodeName_ == 'small'):
+            obj_ = supermod.docMarkupType.factory()
+            obj_.build(child_)
+            obj_.type_ = nodeName_
+            self.content.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'verbatim':
+            childobj_ = verbatimTypeSub.factory()
+            childobj_.build(child_)
+            obj_ = self.mixedclass_(MixedContainer.CategoryComplex, MixedContainer.TypeNone,
+                                    'verbatim', childobj_)
+            self.content.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'formula':
+            childobj_ = docFormulaTypeSub.factory()
+            childobj_.build(child_)
+            obj_ = self.mixedclass_(MixedContainer.CategoryComplex, MixedContainer.TypeNone,
+                                    'formula', childobj_)
+            self.content.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "itemizedlist":
+            obj_ = supermod.docListType.factory(subtype="itemized")
+            obj_.build(child_)
+            self.content.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == "orderedlist":
+            obj_ = supermod.docListType.factory(subtype="ordered")
+            obj_.build(child_)
+            self.content.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'heading':
+            obj_ = supermod.docHeadingType.factory()
+            obj_.build(child_)
+            self.content.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'ulink':
+            obj_ = supermod.docURLLink.factory()
+            obj_.build(child_)
+            self.content.append(obj_)
+
+supermod.docParaType.subclass = docParaTypeSub
+# end class docParaTypeSub
+
+
+class docMarkupTypeSub(supermod.docMarkupType):
+
+    node_type = "docmarkup"
+
+    def __init__(self, valueOf_='', mixedclass_=None, content_=None):
+        supermod.docMarkupType.__init__(self, valueOf_, mixedclass_, content_)
+        self.type_ = None
+
+    def buildChildren(self, child_, nodeName_):
+        if child_.nodeType == Node.TEXT_NODE:
+            obj_ = self.mixedclass_(MixedContainer.CategoryText, MixedContainer.TypeNone, '',
+                                    child_.nodeValue)
+            self.content_.append(obj_)
+        elif child_.nodeType == Node.ELEMENT_NODE and nodeName_ == 'ref':
+            childobj_ = supermod.docRefTextType.factory()
+            childobj_.build(child_)
+            obj_ = self.mixedclass_(MixedContainer.CategoryComplex, MixedContainer.TypeNone, 'ref',
+                                    childobj_)
+            self.content_.append(obj_)
+        if child_.nodeType == Node.TEXT_NODE:
+            self.valueOf_ += child_.nodeValue
+        elif child_.nodeType == Node.CDATA_SECTION_NODE:
+            self.valueOf_ += '![CDATA[' + child_.nodeValue + ']]'
+
+supermod.docMarkupType.subclass = docMarkupTypeSub
+# end class docMarkupTypeSub
+
+
+class docTitleTypeSub(supermod.docTitleType):
+
+    node_type = "doctitle"
+
+    def __init__(self, valueOf_='', mixedclass_=None, content_=None):
+        supermod.docTitleType.__init__(self, valueOf_, mixedclass_, content_)
+        self.type_ = None
+
+supermod.docTitleType.subclass = docTitleTypeSub
+# end class docTitleTypeSub
+
+
+class ParseError(Exception):
+    pass
+
+
+class FileIOError(Exception):
+    pass
+
+
+def parse(inFilename):
+
+    try:
+        doc = minidom.parse(inFilename)
+    except IOError as e:
+        raise FileIOError(e)
+    except ExpatError as e:
+        raise ParseError(e)
+
+    rootNode = doc.documentElement
+    rootObj = supermod.DoxygenType.factory()
+    rootObj.build(rootNode)
+    return rootObj
+
+

doc/breathe/parser/doxygen/index.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+"""
+Generated Mon Feb  9 19:08:05 2009 by generateDS.py.
+"""
+
+from xml.dom import minidom
+from xml.parsers.expat import ExpatError
+
+
+from . import indexsuper as supermod
+
+class DoxygenTypeSub(supermod.DoxygenType):
+
+    node_type = "doxygen"
+
+    def __init__(self, version=None, compound=None):
+        supermod.DoxygenType.__init__(self, version, compound)
+supermod.DoxygenType.subclass = DoxygenTypeSub
+# end class DoxygenTypeSub
+
+
+class CompoundTypeSub(supermod.CompoundType):
+    
+    node_type = "compound"
+
+    def __init__(self, kind=None, refid=None, name='', member=None):
+        supermod.CompoundType.__init__(self, kind, refid, name, member)
+supermod.CompoundType.subclass = CompoundTypeSub
+# end class CompoundTypeSub
+
+
+class MemberTypeSub(supermod.MemberType):
+
+    node_type = "member"
+
+    def __init__(self, kind=None, refid=None, name=''):
+        supermod.MemberType.__init__(self, kind, refid, name)
+supermod.MemberType.subclass = MemberTypeSub
+# end class MemberTypeSub
+
+
+class ParseError(Exception):
+    pass
+
+class FileIOError(Exception):
+    pass
+
+def parse(inFilename):
+
+    try:
+        doc = minidom.parse(inFilename)
+    except IOError as e:
+        raise FileIOError(e)
+    except ExpatError as e:
+        raise ParseError(e)
+
+    rootNode = doc.documentElement
+    rootObj = supermod.DoxygenType.factory()
+    rootObj.build(rootNode)
+
+    return rootObj
+

doc/breathe/parser/doxygen/indexsuper.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python
+
+#
+# Generated Thu Jun 11 18:43:54 2009 by generateDS.py.
+#
+
+import sys
+import getopt
+from xml.dom import minidom
+from xml.dom import Node
+
+#
+# User methods
+#
+# Calls to the methods in these classes are generated by generateDS.py.
+# You can replace these methods by re-implementing the following class
+#   in a module named generatedssuper.py.
+
+try:
+    from generatedssuper import GeneratedsSuper
+except ImportError as exp:
+
+    class GeneratedsSuper:
+        def format_string(self, input_data, input_name=''):
+            return input_data
+        def format_integer(self, input_data, input_name=''):
+            return '%d' % input_data
+        def format_float(self, input_data, input_name=''):
+            return '%f' % input_data
+        def format_double(self, input_data, input_name=''):
+            return '%e' % input_data
+        def format_boolean(self, input_data, input_name=''):
+            return '%s' % input_data
+
+
+#
+# If you have installed IPython you can uncomment and use the following.
+# IPython is available from http://ipython.scipy.org/.
+#
+
+## from IPython.Shell import IPShellEmbed
+## args = ''
+## ipshell = IPShellEmbed(args,
+##     banner = 'Dropping into IPython',
+##     exit_msg = 'Leaving Interpreter, back to program.')
+
+# Then use the following line where and when you want to drop into the
+# IPython shell:
+#    ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')
+
+#
+# Globals
+#
+
+ExternalEncoding = 'ascii'
+
+#
+# Support/utility functions.
+#
+
+def showIndent(outfile, level):
+    for idx in range(level):
+        outfile.write('    ')
+
+def quote_xml(inStr):
+    s1 = (isinstance(inStr, basestring) and inStr or
+          '%s' % inStr)
+    s1 = s1.replace('&', '&amp;')
+    s1 = s1.replace('<', '&lt;')
+    s1 = s1.replace('>', '&gt;')
+    return s1
+
+def quote_attrib(inStr):
+    s1 = (isinstance(inStr, basestring) and inStr or
+          '%s' % inStr)
+    s1 = s1.replace('&', '&amp;')
+    s1 = s1.replace('<', '&lt;')
+    s1 = s1.replace('>', '&gt;')
+    if '"' in s1:
+        if "'" in s1:
+            s1 = '"%s"' % s1.replace('"', "&quot;")
+        else:
+            s1 = "'%s'" % s1
+    else:
+        s1 = '"%s"' % s1
+    return s1
+
+def quote_python(inStr):
+    s1 = inStr
+    if s1.find("'") == -1:
+        if s1.find('\n') == -1:
+            return "'%s'" % s1
+        else:
+            return "'''%s'''" % s1
+    else:
+        if s1.find('"') != -1:
+            s1 = s1.replace('"', '\\"')
+        if s1.find('\n') == -1:
+            return '"%s"' % s1
+        else:
+            return '"""%s"""' % s1
+
+
+class MixedContainer:
+    # Constants for category:
+    CategoryNone = 0
+    CategoryText = 1
+    CategorySimple = 2
+    CategoryComplex = 3
+    # Constants for content_type:
+    TypeNone = 0
+    TypeText = 1
+    TypeString = 2
+    TypeInteger = 3
+    TypeFloat = 4
+    TypeDecimal = 5
+    TypeDouble = 6
+    TypeBoolean = 7
+    def __init__(self, category, content_type, name, value):
+        self.category = category
+        self.content_type = content_type
+        self.name = name
+        self.value = value
+    def getCategory(self):
+        return self.category
+    def getContenttype(self, content_type):
+        return self.content_type
+    def getValue(self):
+        return self.value
+    def getName(self):
+        return self.name
+
+
+class _MemberSpec(object):
+    def __init__(self, name='', data_type='', container=0):
+        self.name = name
+        self.data_type = data_type
+        self.container = container
+    def set_name(self, name): self.name = name
+    def get_name(self): return self.name
+    def set_data_type(self, data_type): self.data_type = data_type
+    def get_data_type(self): return self.data_type
+    def set_container(self, container): self.container = container
+    def get_container(self): return self.container
+
+
+#
+# Data representation classes.
+#
+
+class DoxygenType(GeneratedsSuper):
+    subclass = None
+    superclass = None
+    def __init__(self, version=None, compound=None):
+        self.version = version
+        if compound is None:
+            self.compound = []
+        else:
+            self.compound = compound
+    def factory(*args_, **kwargs_):
+        if DoxygenType.subclass:
+            return DoxygenType.subclass(*args_, **kwargs_)
+        else:
+            return DoxygenType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_compound(self): return self.compound
+    def set_compound(self, compound): self.compound = compound
+    def add_compound(self, value): self.compound.append(value)
+    def insert_compound(self, index, value): self.compound[index] = value
+    def get_version(self): return self.version
+    def set_version(self, version): self.version = version
+    def hasContent_(self):
+        if (
+            self.compound is not None
+            ):
+            return True
+        else:
+            return False
+    def build(self, node_):
+        attrs = node_.attributes
+        self.buildAttributes(attrs)
+        for child_ in node_.childNodes:
+            nodeName_ = child_.nodeName.split(':')[-1]
+            self.buildChildren(child_, nodeName_)
+    def buildAttributes(self, attrs):
+        if attrs.get('version'):
+            self.version = attrs.get('version').value
+    def buildChildren(self, child_, nodeName_):
+        if child_.nodeType == Node.ELEMENT_NODE and \
+            nodeName_ == 'compound':
+            obj_ = CompoundType.factory()
+            obj_.build(child_)
+            self.compound.append(obj_)
+# end class DoxygenType
+
+
+class CompoundType(GeneratedsSuper):
+    subclass = None
+    superclass = None
+    def __init__(self, kind=None, refid=None, name=None, member=None):
+        self.kind = kind
+        self.refid = refid
+        self.name = name
+        if member is None:
+            self.member = []
+        else:
+            self.member = member
+    def factory(*args_, **kwargs_):
+        if CompoundType.subclass:
+            return CompoundType.subclass(*args_, **kwargs_)
+        else:
+            return CompoundType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_name(self): return self.name
+    def set_name(self, name): self.name = name
+    def get_member(self): return self.member
+    def set_member(self, member): self.member = member
+    def add_member(self, value): self.member.append(value)
+    def insert_member(self, index, value): self.member[index] = value
+    def get_kind(self): return self.kind
+    def set_kind(self, kind): self.kind = kind
+    def get_refid(self): return self.refid
+    def set_refid(self, refid): self.refid = refid
+    def build(self, node_):
+        attrs = node_.attributes
+        self.buildAttributes(attrs)
+        for child_ in node_.childNodes:
+            nodeName_ = child_.nodeName.split(':')[-1]
+            self.buildChildren(child_, nodeName_)
+    def buildAttributes(self, attrs):
+        if attrs.get('kind'):
+            self.kind = attrs.get('kind').value
+        if attrs.get('refid'):
+            self.refid = attrs.get('refid').value
+    def buildChildren(self, child_, nodeName_):
+        if child_.nodeType == Node.ELEMENT_NODE and \
+            nodeName_ == 'name':
+            name_ = ''
+            for text__content_ in child_.childNodes:
+                name_ += text__content_.nodeValue
+            self.name = name_
+        elif child_.nodeType == Node.ELEMENT_NODE and \
+            nodeName_ == 'member':
+            obj_ = MemberType.factory()
+            obj_.build(child_)
+            self.member.append(obj_)
+# end class CompoundType
+
+
+class MemberType(GeneratedsSuper):
+    subclass = None
+    superclass = None
+    def __init__(self, kind=None, refid=None, name=None):
+        self.kind = kind
+        self.refid = refid
+        self.name = name
+    def factory(*args_, **kwargs_):
+        if MemberType.subclass:
+            return MemberType.subclass(*args_, **kwargs_)
+        else:
+            return MemberType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_name(self): return self.name
+    def set_name(self, name): self.name = name
+    def get_kind(self): return self.kind
+    def set_kind(self, kind): self.kind = kind
+    def get_refid(self): return self.refid
+    def set_refid(self, refid): self.refid = refid
+    def hasContent_(self):
+        if (
+            self.name is not None
+            ):
+            return True
+        else:
+            return False
+    def build(self, node_):
+        attrs = node_.attributes
+        self.buildAttributes(attrs)
+        for child_ in node_.childNodes:
+            nodeName_ = child_.nodeName.split(':')[-1]
+            self.buildChildren(child_, nodeName_)
+    def buildAttributes(self, attrs):
+        if attrs.get('kind'):
+            self.kind = attrs.get('kind').value
+        if attrs.get('refid'):
+            self.refid = attrs.get('refid').value
+    def buildChildren(self, child_, nodeName_):
+        if child_.nodeType == Node.ELEMENT_NODE and \
+            nodeName_ == 'name':
+            name_ = ''
+            for text__content_ in child_.childNodes:
+                name_ += text__content_.nodeValue
+            self.name = name_
+# end class MemberType
+
+
+USAGE_TEXT = """
+Usage: python <Parser>.py [ -s ] <in_xml_file>
+Options:
+    -s        Use the SAX parser, not the minidom parser.
+"""
+
+def usage():
+    print(USAGE_TEXT)
+    sys.exit(1)
+
+
+def parse(inFileName):
+    doc = minidom.parse(inFileName)
+    rootNode = doc.documentElement
+    rootObj = DoxygenType.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    sys.stdout.write('<?xml version="1.0" ?>\n')
+    rootObj.export(sys.stdout, 0, name_="doxygenindex",
+        namespacedef_='')
+    return rootObj
+
+
+def parseString(inString):
+    doc = minidom.parseString(inString)
+    rootNode = doc.documentElement
+    rootObj = DoxygenType.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    sys.stdout.write('<?xml version="1.0" ?>\n')
+    rootObj.export(sys.stdout, 0, name_="doxygenindex",
+        namespacedef_='')
+    return rootObj
+
+
+def parseLiteral(inFileName):
+    doc = minidom.parse(inFileName)
+    rootNode = doc.documentElement
+    rootObj = DoxygenType.factory()
+    rootObj.build(rootNode)
+    # Enable Python to collect the space used by the DOM.
+    doc = None
+    sys.stdout.write('from index import *\n\n')
+    sys.stdout.write('rootObj = doxygenindex(\n')
+    rootObj.exportLiteral(sys.stdout, 0, name_="doxygenindex")
+    sys.stdout.write(')\n')
+    return rootObj
+
+
+def main():
+    args = sys.argv[1:]
+    if len(args) == 1:
+        parse(args[0])
+    else:
+        usage()
+
+
+
+
+if __name__ == '__main__':
+    main()
+    #import pdb
+    #pdb.run('main()')
+