deleting the Breathe sources
This commit is contained in:
Celine Mercier
@ -1,16 +0,0 @@
|
||||
|
||||
__version__ = '4.0.0'
|
||||
|
||||
|
||||
def setup(app):
|
||||
|
||||
# We can't do the import at the module scope as setup.py has to be able to
|
||||
# import this file to read __version__ without hitting any syntax errors
|
||||
# from both Python 2 & Python 3.
|
||||
|
||||
# By the time this function is called, the directives code will have been
|
||||
# converted with 2to3 if appropriate
|
||||
|
||||
from . import directives
|
||||
|
||||
directives.setup(app)
|
||||
Binary file not shown.
Binary file not shown.
@ -1,88 +0,0 @@
|
||||
|
||||
from ..renderer.rst.doxygen.base import RenderContext
|
||||
from ..renderer.rst.doxygen import format_parser_error
|
||||
from ..parser import ParserError, FileIOError
|
||||
|
||||
from docutils import nodes
|
||||
from docutils.parsers import rst
|
||||
|
||||
|
||||
class WarningHandler(object):
|
||||
|
||||
def __init__(self, state, context):
|
||||
self.state = state
|
||||
self.context = context
|
||||
|
||||
def warn(self, raw_text, rendered_nodes=None):
|
||||
raw_text = self.format(raw_text)
|
||||
if rendered_nodes is None:
|
||||
rendered_nodes = [nodes.paragraph("", "", nodes.Text(raw_text))]
|
||||
return [
|
||||
nodes.warning("", *rendered_nodes),
|
||||
self.state.document.reporter.warning(raw_text, line=self.context['lineno'])
|
||||
]
|
||||
|
||||
def format(self, text):
|
||||
return text.format(**self.context)
|
||||
|
||||
|
||||
def create_warning(project_info, state, lineno, **kwargs):
|
||||
|
||||
tail = ''
|
||||
if project_info:
|
||||
tail = 'in doxygen xml output for project "{project}" from directory: {path}'.format(
|
||||
project=project_info.name(),
|
||||
path=project_info.project_path()
|
||||
)
|
||||
|
||||
context = dict(
|
||||
lineno=lineno,
|
||||
tail=tail,
|
||||
**kwargs
|
||||
)
|
||||
|
||||
return WarningHandler(state, context)
|
||||
|
||||
|
||||
class BaseDirective(rst.Directive):
|
||||
|
||||
def __init__(self, root_data_object, renderer_factory_creator_constructor, finder_factory,
|
||||
project_info_factory, filter_factory, target_handler_factory, parser_factory, *args):
|
||||
rst.Directive.__init__(self, *args)
|
||||
self.directive_args = list(args) # Convert tuple to list to allow modification.
|
||||
|
||||
self.root_data_object = root_data_object
|
||||
self.renderer_factory_creator_constructor = renderer_factory_creator_constructor
|
||||
self.finder_factory = finder_factory
|
||||
self.project_info_factory = project_info_factory
|
||||
self.filter_factory = filter_factory
|
||||
self.target_handler_factory = target_handler_factory
|
||||
self.parser_factory = parser_factory
|
||||
|
||||
def render(self, node_stack, project_info, options, filter_, target_handler, mask_factory):
|
||||
"Standard render process used by subclasses"
|
||||
|
||||
renderer_factory_creator = self.renderer_factory_creator_constructor.create_factory_creator(
|
||||
project_info,
|
||||
self.state.document,
|
||||
options,
|
||||
target_handler
|
||||
)
|
||||
|
||||
try:
|
||||
renderer_factory = renderer_factory_creator.create_factory(
|
||||
node_stack,
|
||||
self.state,
|
||||
self.state.document,
|
||||
filter_,
|
||||
target_handler,
|
||||
)
|
||||
except ParserError as e:
|
||||
return format_parser_error("doxygenclass", e.error, e.filename, self.state,
|
||||
self.lineno, True)
|
||||
except FileIOError as e:
|
||||
return format_parser_error("doxygenclass", e.error, e.filename, self.state, self.lineno)
|
||||
|
||||
context = RenderContext(node_stack, mask_factory, self.directive_args)
|
||||
object_renderer = renderer_factory.create_renderer(context)
|
||||
return object_renderer.render()
|
||||
Binary file not shown.
@ -1,123 +0,0 @@
|
||||
|
||||
from ..renderer.rst.doxygen.base import RenderContext
|
||||
from ..renderer.rst.doxygen.mask import NullMaskFactory
|
||||
from ..directive.base import BaseDirective
|
||||
from ..project import ProjectError
|
||||
from .base import create_warning
|
||||
|
||||
from docutils.parsers.rst.directives import unchanged_required, flag
|
||||
from docutils.parsers import rst
|
||||
|
||||
|
||||
class BaseFileDirective(BaseDirective):
|
||||
"""Base class handle the main work when given the appropriate file and project info to work
|
||||
from.
|
||||
"""
|
||||
|
||||
# We use inheritance here rather than a separate object and composition, because so much
|
||||
# information is present in the Directive class from the docutils framework that we'd have to
|
||||
# pass way too much stuff to a helper object to be reasonable.
|
||||
|
||||
def handle_contents(self, file_, project_info):
|
||||
|
||||
finder = self.finder_factory.create_finder(project_info)
|
||||
|
||||
finder_filter = self.filter_factory.create_file_finder_filter(file_)
|
||||
|
||||
matches = []
|
||||
finder.filter_(finder_filter, matches)
|
||||
|
||||
if len(matches) > 1:
|
||||
warning = create_warning(None, self.state, self.lineno, file=file_,
|
||||
directivename=self.directive_name)
|
||||
return warning.warn('{directivename}: Found multiple matches for file "{file} {tail}')
|
||||
|
||||
elif not matches:
|
||||
warning = create_warning(None, self.state, self.lineno, file=file_,
|
||||
directivename=self.directive_name)
|
||||
return warning.warn('{directivename}: Cannot find file "{file} {tail}')
|
||||
|
||||
target_handler = self.target_handler_factory.create_target_handler(
|
||||
self.options, project_info, self.state.document)
|
||||
filter_ = self.filter_factory.create_file_filter(file_, self.options)
|
||||
|
||||
renderer_factory_creator = self.renderer_factory_creator_constructor.create_factory_creator(
|
||||
project_info,
|
||||
self.state.document,
|
||||
self.options,
|
||||
target_handler
|
||||
)
|
||||
node_list = []
|
||||
for node_stack in matches:
|
||||
|
||||
renderer_factory = renderer_factory_creator.create_factory(
|
||||
node_stack,
|
||||
self.state,
|
||||
self.state.document,
|
||||
filter_,
|
||||
target_handler,
|
||||
)
|
||||
|
||||
mask_factory = NullMaskFactory()
|
||||
context = RenderContext(node_stack, mask_factory, self.directive_args)
|
||||
object_renderer = renderer_factory.create_renderer(context)
|
||||
node_list.extend(object_renderer.render())
|
||||
|
||||
return node_list
|
||||
|
||||
|
||||
class DoxygenFileDirective(BaseFileDirective):
|
||||
|
||||
directive_name = 'doxygenfile'
|
||||
|
||||
required_arguments = 0
|
||||
optional_arguments = 2
|
||||
option_spec = {
|
||||
"path": unchanged_required,
|
||||
"project": unchanged_required,
|
||||
"outline": flag,
|
||||
"no-link": flag,
|
||||
}
|
||||
has_content = False
|
||||
|
||||
def run(self):
|
||||
"""Get the file from the argument and the project info from the factory."""
|
||||
|
||||
file_ = self.arguments[0]
|
||||
|
||||
try:
|
||||
project_info = self.project_info_factory.create_project_info(self.options)
|
||||
except ProjectError as e:
|
||||
warning = create_warning(None, self.state, self.lineno)
|
||||
return warning.warn('doxygenfile: %s' % e)
|
||||
|
||||
return self.handle_contents(file_, project_info)
|
||||
|
||||
|
||||
class AutoDoxygenFileDirective(BaseFileDirective):
|
||||
|
||||
directive_name = 'autodoxygenfile'
|
||||
|
||||
required_arguments = 1
|
||||
option_spec = {
|
||||
"project": unchanged_required,
|
||||
"outline": flag,
|
||||
"no-link": flag,
|
||||
}
|
||||
has_content = False
|
||||
|
||||
def run(self):
|
||||
"""Get the file from the argument and extract the associated project info for the named
|
||||
project given that it is an auto-project.
|
||||
"""
|
||||
|
||||
file_ = self.arguments[0]
|
||||
|
||||
try:
|
||||
project_info = self.project_info_factory.retrieve_project_info_for_auto(self.options)
|
||||
except ProjectError as e:
|
||||
warning = create_warning(None, self.state, self.lineno)
|
||||
return warning.warn('autodoxygenfile: %s' % e)
|
||||
|
||||
return self.handle_contents(file_, project_info)
|
||||
|
||||
Binary file not shown.
@ -1,115 +0,0 @@
|
||||
|
||||
from ..renderer.rst.doxygen.base import RenderContext
|
||||
from ..renderer.rst.doxygen.mask import NullMaskFactory
|
||||
from ..renderer.rst.doxygen import format_parser_error
|
||||
from ..directive.base import BaseDirective
|
||||
from ..project import ProjectError
|
||||
from ..parser import ParserError, FileIOError
|
||||
from .base import create_warning
|
||||
|
||||
from docutils.parsers import rst
|
||||
from docutils.parsers.rst.directives import unchanged_required, flag
|
||||
|
||||
|
||||
class BaseIndexDirective(BaseDirective):
|
||||
"""Base class handle the main work when given the appropriate project info to work from.
|
||||
"""
|
||||
|
||||
# We use inheritance here rather than a separate object and composition, because so much
|
||||
# information is present in the Directive class from the docutils framework that we'd have to
|
||||
# pass way too much stuff to a helper object to be reasonable.
|
||||
|
||||
def handle_contents(self, project_info):
|
||||
|
||||
try:
|
||||
finder = self.finder_factory.create_finder(project_info)
|
||||
except ParserError as e:
|
||||
return format_parser_error(self.name, e.error, e.filename, self.state,
|
||||
self.lineno, True)
|
||||
except FileIOError as e:
|
||||
return format_parser_error(self.name, e.error, e.filename, self.state, self.lineno)
|
||||
|
||||
data_object = finder.root()
|
||||
|
||||
target_handler = self.target_handler_factory.create_target_handler(
|
||||
self.options, project_info, self.state.document)
|
||||
filter_ = self.filter_factory.create_index_filter(self.options)
|
||||
|
||||
renderer_factory_creator = self.renderer_factory_creator_constructor.create_factory_creator(
|
||||
project_info,
|
||||
self.state.document,
|
||||
self.options,
|
||||
target_handler
|
||||
)
|
||||
renderer_factory = renderer_factory_creator.create_factory(
|
||||
[data_object],
|
||||
self.state,
|
||||
self.state.document,
|
||||
filter_,
|
||||
target_handler,
|
||||
)
|
||||
|
||||
mask_factory = NullMaskFactory()
|
||||
context = RenderContext([data_object, self.root_data_object], mask_factory, self.directive_args)
|
||||
object_renderer = renderer_factory.create_renderer(context)
|
||||
|
||||
try:
|
||||
node_list = object_renderer.render()
|
||||
except ParserError as e:
|
||||
return format_parser_error(self.name, e.error, e.filename, self.state,
|
||||
self.lineno, True)
|
||||
except FileIOError as e:
|
||||
return format_parser_error(self.name, e.error, e.filename, self.state, self.lineno)
|
||||
|
||||
return node_list
|
||||
|
||||
|
||||
class DoxygenIndexDirective(BaseIndexDirective):
|
||||
|
||||
required_arguments = 0
|
||||
optional_arguments = 2
|
||||
option_spec = {
|
||||
"path": unchanged_required,
|
||||
"project": unchanged_required,
|
||||
"outline": flag,
|
||||
"no-link": flag,
|
||||
}
|
||||
has_content = False
|
||||
|
||||
def run(self):
|
||||
"""Extract the project info and pass it to the helper method"""
|
||||
|
||||
try:
|
||||
project_info = self.project_info_factory.create_project_info(self.options)
|
||||
except ProjectError as e:
|
||||
warning = create_warning(None, self.state, self.lineno)
|
||||
return warning.warn('doxygenindex: %s' % e)
|
||||
|
||||
return self.handle_contents(project_info)
|
||||
|
||||
|
||||
class AutoDoxygenIndexDirective(BaseIndexDirective):
|
||||
|
||||
required_arguments = 0
|
||||
final_argument_whitespace = True
|
||||
option_spec = {
|
||||
"project": unchanged_required,
|
||||
"outline": flag,
|
||||
"no-link": flag,
|
||||
}
|
||||
has_content = False
|
||||
|
||||
def run(self):
|
||||
"""Extract the project info from the auto project info store and pass it to the helper
|
||||
method
|
||||
"""
|
||||
|
||||
try:
|
||||
project_info = self.project_info_factory.retrieve_project_info_for_auto(self.options)
|
||||
except ProjectError as e:
|
||||
warning = create_warning(None, self.state, self.lineno)
|
||||
return warning.warn('autodoxygenindex: %s' % e)
|
||||
|
||||
return self.handle_contents(project_info)
|
||||
|
||||
|
||||
Binary file not shown.
File diff suppressed because it is too large
Load Diff
Binary file not shown.
@ -1,3 +0,0 @@
|
||||
|
||||
class BreatheError(Exception):
|
||||
pass
|
||||
Binary file not shown.
Binary file not shown.
@ -1,45 +0,0 @@
|
||||
|
||||
class FakeParentNode(object):
|
||||
|
||||
node_type = "fakeparent"
|
||||
|
||||
|
||||
class Finder(object):
|
||||
|
||||
def __init__(self, root, item_finder_factory):
|
||||
|
||||
self._root = root
|
||||
self.item_finder_factory = item_finder_factory
|
||||
|
||||
def filter_(self, filter_, matches):
|
||||
"""Adds all nodes which match the filter into the matches list"""
|
||||
|
||||
item_finder = self.item_finder_factory.create_finder(self._root)
|
||||
item_finder.filter_([FakeParentNode()], filter_, matches)
|
||||
|
||||
def root(self):
|
||||
|
||||
return self._root
|
||||
|
||||
|
||||
class FinderFactory(object):
|
||||
|
||||
def __init__(self, parser, item_finder_factory_creator):
|
||||
|
||||
self.parser = parser
|
||||
self.item_finder_factory_creator = item_finder_factory_creator
|
||||
|
||||
def create_finder(self, project_info):
|
||||
|
||||
root = self.parser.parse(project_info)
|
||||
item_finder_factory = self.item_finder_factory_creator.create_factory(project_info)
|
||||
|
||||
return Finder(root, item_finder_factory)
|
||||
|
||||
def create_finder_from_root(self, root, project_info):
|
||||
|
||||
item_finder_factory = self.item_finder_factory_creator.create_factory(project_info)
|
||||
|
||||
return Finder(root, item_finder_factory)
|
||||
|
||||
|
||||
Binary file not shown.
@ -1 +0,0 @@
|
||||
|
||||
Binary file not shown.
@ -1,18 +0,0 @@
|
||||
|
||||
class ItemFinder(object):
|
||||
|
||||
def __init__(self, project_info, data_object, item_finder_factory):
|
||||
|
||||
self.data_object = data_object
|
||||
self.item_finder_factory = item_finder_factory
|
||||
self.project_info = project_info
|
||||
|
||||
|
||||
def stack(element, list_):
|
||||
"""Stack an element on to the start of a list and return as a new list"""
|
||||
|
||||
# Copy list first so we have a new list to insert into
|
||||
output = list_[:]
|
||||
output.insert(0, element)
|
||||
return output
|
||||
|
||||
Binary file not shown.
@ -1,75 +0,0 @@
|
||||
|
||||
from .base import ItemFinder, stack
|
||||
|
||||
|
||||
class DoxygenTypeSubItemFinder(ItemFinder):
|
||||
|
||||
def filter_(self, ancestors, filter_, matches):
|
||||
"""Find nodes which match the filter. Doesn't test this node, only its children"""
|
||||
|
||||
node_stack = stack(self.data_object, ancestors)
|
||||
|
||||
compound_finder = self.item_finder_factory.create_finder(self.data_object.compounddef)
|
||||
compound_finder.filter_(node_stack, filter_, matches)
|
||||
|
||||
|
||||
class CompoundDefTypeSubItemFinder(ItemFinder):
|
||||
|
||||
def filter_(self, ancestors, filter_, matches):
|
||||
"""Finds nodes which match the filter and continues checks to children"""
|
||||
|
||||
node_stack = stack(self.data_object, ancestors)
|
||||
|
||||
if filter_.allow(node_stack):
|
||||
matches.append(node_stack)
|
||||
|
||||
for sectiondef in self.data_object.sectiondef:
|
||||
finder = self.item_finder_factory.create_finder(sectiondef)
|
||||
finder.filter_(node_stack, filter_, matches)
|
||||
|
||||
for innerclass in self.data_object.innerclass:
|
||||
finder = self.item_finder_factory.create_finder(innerclass)
|
||||
finder.filter_(node_stack, filter_, matches)
|
||||
|
||||
|
||||
class SectionDefTypeSubItemFinder(ItemFinder):
|
||||
|
||||
def filter_(self, ancestors, filter_, matches):
|
||||
"""Find nodes which match the filter. Doesn't test this node, only its children"""
|
||||
|
||||
node_stack = stack(self.data_object, ancestors)
|
||||
|
||||
if filter_.allow(node_stack):
|
||||
matches.append(node_stack)
|
||||
|
||||
for memberdef in self.data_object.memberdef:
|
||||
finder = self.item_finder_factory.create_finder(memberdef)
|
||||
finder.filter_(node_stack, filter_, matches)
|
||||
|
||||
|
||||
class MemberDefTypeSubItemFinder(ItemFinder):
|
||||
|
||||
def filter_(self, ancestors, filter_, matches):
|
||||
|
||||
data_object = self.data_object
|
||||
node_stack = stack(data_object, ancestors)
|
||||
|
||||
if filter_.allow(node_stack):
|
||||
matches.append(node_stack)
|
||||
|
||||
if data_object.kind == 'enum':
|
||||
for value in data_object.enumvalue:
|
||||
value_stack = stack(value, node_stack)
|
||||
if filter_.allow(value_stack):
|
||||
matches.append(value_stack)
|
||||
|
||||
|
||||
class RefTypeSubItemFinder(ItemFinder):
|
||||
|
||||
def filter_(self, ancestors, filter_, matches):
|
||||
|
||||
node_stack = stack(self.data_object, ancestors)
|
||||
|
||||
if filter_.allow(node_stack):
|
||||
matches.append(node_stack)
|
||||
|
||||
Binary file not shown.
@ -1,55 +0,0 @@
|
||||
|
||||
from . import index as indexfinder
|
||||
from . import compound as compoundfinder
|
||||
|
||||
|
||||
class CreateCompoundTypeSubFinder(object):
|
||||
|
||||
def __init__(self, parser_factory, matcher_factory):
|
||||
|
||||
self.parser_factory = parser_factory
|
||||
self.matcher_factory = matcher_factory
|
||||
|
||||
def __call__(self, project_info, *args):
|
||||
|
||||
compound_parser = self.parser_factory.create_compound_parser(project_info)
|
||||
return indexfinder.CompoundTypeSubItemFinder(self.matcher_factory, compound_parser,
|
||||
project_info, *args)
|
||||
|
||||
|
||||
class DoxygenItemFinderFactory(object):
|
||||
|
||||
def __init__(self, finders, project_info):
|
||||
|
||||
self.finders = finders
|
||||
self.project_info = project_info
|
||||
|
||||
def create_finder(self, data_object):
|
||||
|
||||
return self.finders[data_object.node_type](self.project_info, data_object, self)
|
||||
|
||||
|
||||
class DoxygenItemFinderFactoryCreator(object):
|
||||
|
||||
def __init__(self, parser_factory, filter_factory):
|
||||
|
||||
self.parser_factory = parser_factory
|
||||
self.filter_factory = filter_factory
|
||||
|
||||
def create_factory(self, project_info):
|
||||
|
||||
finders = {
|
||||
"doxygen": indexfinder.DoxygenTypeSubItemFinder,
|
||||
"compound": CreateCompoundTypeSubFinder(self.parser_factory, self.filter_factory),
|
||||
"member": indexfinder.MemberTypeSubItemFinder,
|
||||
"doxygendef": compoundfinder.DoxygenTypeSubItemFinder,
|
||||
"compounddef": compoundfinder.CompoundDefTypeSubItemFinder,
|
||||
"sectiondef": compoundfinder.SectionDefTypeSubItemFinder,
|
||||
"memberdef": compoundfinder.MemberDefTypeSubItemFinder,
|
||||
"ref": compoundfinder.RefTypeSubItemFinder,
|
||||
}
|
||||
|
||||
return DoxygenItemFinderFactory(finders, project_info)
|
||||
|
||||
|
||||
|
||||
Binary file not shown.
@ -1,79 +0,0 @@
|
||||
|
||||
from .base import ItemFinder, stack
|
||||
|
||||
|
||||
class DoxygenTypeSubItemFinder(ItemFinder):
|
||||
|
||||
def filter_(self, ancestors, filter_, matches):
|
||||
"""Find nodes which match the filter. Doesn't test this node, only its children"""
|
||||
|
||||
compounds = self.data_object.get_compound()
|
||||
|
||||
node_stack = stack(self.data_object, ancestors)
|
||||
|
||||
for compound in compounds:
|
||||
|
||||
compound_finder = self.item_finder_factory.create_finder(compound)
|
||||
compound_finder.filter_(node_stack, filter_, matches)
|
||||
|
||||
|
||||
class CompoundTypeSubItemFinder(ItemFinder):
|
||||
|
||||
def __init__(self, filter_factory, compound_parser, *args):
|
||||
ItemFinder.__init__(self, *args)
|
||||
|
||||
self.filter_factory = filter_factory
|
||||
self.compound_parser = compound_parser
|
||||
|
||||
def filter_(self, ancestors, filter_, matches):
|
||||
"""Finds nodes which match the filter and continues checks to children
|
||||
|
||||
Requires parsing the xml files referenced by the children for which we use the compound
|
||||
parser and continue at the top level of that pretending that this node is the parent of the
|
||||
top level node of the compound file.
|
||||
"""
|
||||
|
||||
node_stack = stack(self.data_object, ancestors)
|
||||
|
||||
# Match against compound object
|
||||
if filter_.allow(node_stack):
|
||||
matches.append(node_stack)
|
||||
|
||||
# Descend to member children
|
||||
members = self.data_object.get_member()
|
||||
member_matches = []
|
||||
for member in members:
|
||||
member_finder = self.item_finder_factory.create_finder(member)
|
||||
member_finder.filter_(node_stack, filter_, member_matches)
|
||||
|
||||
results = []
|
||||
|
||||
# If there are members in this compound that match the criteria
|
||||
# then load up the file for this compound and get the member data objects
|
||||
if member_matches:
|
||||
|
||||
file_data = self.compound_parser.parse(self.data_object.refid)
|
||||
finder = self.item_finder_factory.create_finder(file_data)
|
||||
|
||||
for member_stack in member_matches:
|
||||
ref_filter = self.filter_factory.create_id_filter('memberdef', member_stack[0].refid)
|
||||
finder.filter_(node_stack, ref_filter, matches)
|
||||
|
||||
else:
|
||||
|
||||
# Read in the xml file referenced by the compound and descend into that as well
|
||||
file_data = self.compound_parser.parse(self.data_object.refid)
|
||||
finder = self.item_finder_factory.create_finder(file_data)
|
||||
|
||||
finder.filter_(node_stack, filter_, matches)
|
||||
|
||||
|
||||
class MemberTypeSubItemFinder(ItemFinder):
|
||||
|
||||
def filter_(self, ancestors, filter_, matches):
|
||||
|
||||
node_stack = stack(self.data_object, ancestors)
|
||||
|
||||
# Match against member object
|
||||
if filter_.allow(node_stack):
|
||||
matches.append(node_stack)
|
||||
Binary file not shown.
@ -1,118 +0,0 @@
|
||||
|
||||
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
|
||||
)
|
||||
|
||||
|
||||
|
||||
Binary file not shown.
Binary file not shown.
@ -1,964 +0,0 @@
|
||||
#!/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
|
||||
|
||||
|
||||
Binary file not shown.
File diff suppressed because it is too large
Load Diff
Binary file not shown.
@ -1,63 +0,0 @@
|
||||
#!/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
|
||||
|
||||
Binary file not shown.
@ -1,362 +0,0 @@
|
||||
#!/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('&', '&')
|
||||
s1 = s1.replace('<', '<')
|
||||
s1 = s1.replace('>', '>')
|
||||
return s1
|
||||
|
||||
def quote_attrib(inStr):
|
||||
s1 = (isinstance(inStr, basestring) and inStr or
|
||||
'%s' % inStr)
|
||||
s1 = s1.replace('&', '&')
|
||||
s1 = s1.replace('<', '<')
|
||||
s1 = s1.replace('>', '>')
|
||||
if '"' in s1:
|
||||
if "'" in s1:
|
||||
s1 = '"%s"' % s1.replace('"', """)
|
||||
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()')
|
||||
|
||||
Binary file not shown.
@ -1,87 +0,0 @@
|
||||
|
||||
AUTOCFG_TEMPLATE = r"""
|
||||
PROJECT_NAME = "{project_name}"
|
||||
OUTPUT_DIRECTORY = {output_dir}
|
||||
GENERATE_LATEX = NO
|
||||
GENERATE_MAN = NO
|
||||
GENERATE_RTF = NO
|
||||
CASE_SENSE_NAMES = NO
|
||||
INPUT = {input}
|
||||
ENABLE_PREPROCESSING = YES
|
||||
QUIET = YES
|
||||
JAVADOC_AUTOBRIEF = YES
|
||||
JAVADOC_AUTOBRIEF = NO
|
||||
GENERATE_HTML = NO
|
||||
GENERATE_XML = YES
|
||||
ALIASES = "rst=\verbatim embed:rst"
|
||||
ALIASES += "endrst=\endverbatim"
|
||||
""".strip()
|
||||
|
||||
|
||||
class ProjectData(object):
|
||||
"Simple handler for the files and project_info for each project"
|
||||
|
||||
def __init__(self, auto_project_info, files):
|
||||
|
||||
self.auto_project_info = auto_project_info
|
||||
self.files = files
|
||||
|
||||
|
||||
class AutoDoxygenProcessHandle(object):
|
||||
|
||||
def __init__(self, path_handler, run_process, write_file, project_info_factory):
|
||||
|
||||
self.path_handler = path_handler
|
||||
self.run_process = run_process
|
||||
self.write_file = write_file
|
||||
self.project_info_factory = project_info_factory
|
||||
|
||||
def generate_xml(self, app):
|
||||
|
||||
project_files = {}
|
||||
|
||||
# First collect together all the files which need to be doxygen processed for each project
|
||||
for project_name, file_structure in app.config.breathe_projects_source.items():
|
||||
|
||||
folder = file_structure[0]
|
||||
contents = file_structure[1]
|
||||
|
||||
auto_project_info = self.project_info_factory.create_auto_project_info(
|
||||
project_name, folder)
|
||||
|
||||
project_files[project_name] = ProjectData(auto_project_info, contents)
|
||||
|
||||
# Iterate over the projects and generate doxygen xml output for the files for each one into
|
||||
# a directory in the Sphinx build area
|
||||
for project_name, data in project_files.items():
|
||||
|
||||
project_path = self.process(data.auto_project_info, data.files)
|
||||
|
||||
project_info = data.auto_project_info.create_project_info(project_path)
|
||||
|
||||
self.project_info_factory.store_project_info_for_auto(project_name, project_info)
|
||||
|
||||
def process(self, auto_project_info, files):
|
||||
|
||||
name = auto_project_info.name()
|
||||
cfgfile = "%s.cfg" % name
|
||||
|
||||
full_paths = map(lambda x: auto_project_info.abs_path_to_source_file(x), files)
|
||||
|
||||
cfg = AUTOCFG_TEMPLATE.format(
|
||||
project_name=name,
|
||||
output_dir=name,
|
||||
input=" ".join(full_paths)
|
||||
)
|
||||
|
||||
build_dir = self.path_handler.join(
|
||||
auto_project_info.build_dir(),
|
||||
"breathe",
|
||||
"doxygen"
|
||||
)
|
||||
|
||||
self.write_file(build_dir, cfgfile, cfg)
|
||||
|
||||
self.run_process(['doxygen', cfgfile], cwd=build_dir)
|
||||
|
||||
return self.path_handler.join(build_dir, name, "xml")
|
||||
Binary file not shown.
@ -1,306 +0,0 @@
|
||||
|
||||
from .exception import BreatheError
|
||||
|
||||
import os
|
||||
|
||||
|
||||
class ProjectError(BreatheError):
|
||||
pass
|
||||
|
||||
|
||||
class NoDefaultProjectError(ProjectError):
|
||||
pass
|
||||
|
||||
|
||||
class AutoProjectInfo(object):
|
||||
"""Created as a temporary step in the automatic xml generation process"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
name,
|
||||
source_path,
|
||||
build_dir,
|
||||
reference,
|
||||
source_dir,
|
||||
config_dir,
|
||||
domain_by_extension,
|
||||
domain_by_file_pattern,
|
||||
match
|
||||
):
|
||||
|
||||
self._name = name
|
||||
self._source_path = source_path
|
||||
self._build_dir = build_dir
|
||||
self._reference = reference
|
||||
self._source_dir = source_dir
|
||||
self._config_dir = config_dir
|
||||
self._domain_by_extension = domain_by_extension
|
||||
self._domain_by_file_pattern = domain_by_file_pattern
|
||||
self._match = match
|
||||
|
||||
def name(self):
|
||||
return self._name
|
||||
|
||||
def build_dir(self):
|
||||
return self._build_dir
|
||||
|
||||
def abs_path_to_source_file(self, file_):
|
||||
"""
|
||||
Returns full path to the provide file assuming that the provided path is relative to the
|
||||
projects conf.py directory as specified in the breathe_projects_source config variable.
|
||||
"""
|
||||
|
||||
# os.path.join does the appropriate handling if _source_path is an absolute path
|
||||
return os.path.join(self._config_dir, self._source_path, file_)
|
||||
|
||||
def create_project_info(self, project_path):
|
||||
"""Creates a proper ProjectInfo object based on the information in this AutoProjectInfo"""
|
||||
|
||||
return ProjectInfo(
|
||||
self._name,
|
||||
project_path,
|
||||
self._source_path,
|
||||
self._reference,
|
||||
self._source_dir,
|
||||
self._config_dir,
|
||||
self._domain_by_extension,
|
||||
self._domain_by_file_pattern,
|
||||
self._match
|
||||
)
|
||||
|
||||
|
||||
class ProjectInfo(object):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
name,
|
||||
path,
|
||||
source_path,
|
||||
reference,
|
||||
source_dir,
|
||||
config_dir,
|
||||
domain_by_extension,
|
||||
domain_by_file_pattern,
|
||||
match
|
||||
):
|
||||
|
||||
self._name = name
|
||||
self._project_path = path
|
||||
self._source_path = source_path
|
||||
self._reference = reference
|
||||
self._source_dir = source_dir
|
||||
self._config_dir = config_dir
|
||||
self._domain_by_extension = domain_by_extension
|
||||
self._domain_by_file_pattern = domain_by_file_pattern
|
||||
self._match = match
|
||||
|
||||
def name(self):
|
||||
return self._name
|
||||
|
||||
def project_path(self):
|
||||
return self._project_path
|
||||
|
||||
def source_path(self):
|
||||
return self._source_path
|
||||
|
||||
def relative_path_to_xml_file(self, file_):
|
||||
"""
|
||||
Returns relative path from Sphinx documentation top-level source directory to the specified
|
||||
file assuming that the specified file is a path relative to the doxygen xml output
|
||||
directory.
|
||||
"""
|
||||
|
||||
# os.path.join does the appropriate handling if _project_path is an absolute path
|
||||
full_xml_project_path = os.path.join(self._config_dir, self._project_path, file_)
|
||||
|
||||
return os.path.relpath(
|
||||
full_xml_project_path,
|
||||
self._source_dir
|
||||
)
|
||||
|
||||
def sphinx_abs_path_to_file(self, file_):
|
||||
"""
|
||||
Prepends os.path.sep to the value returned by relative_path_to_file.
|
||||
|
||||
This is to match Sphinx's concept of an absolute path which starts from the top-level source
|
||||
directory of the project.
|
||||
"""
|
||||
return os.path.sep + self.relative_path_to_xml_file(file_)
|
||||
|
||||
def reference(self):
|
||||
return self._reference
|
||||
|
||||
def domain_for_file(self, file_):
|
||||
|
||||
domain = ""
|
||||
extension = file_.split(".")[-1]
|
||||
|
||||
try:
|
||||
domain = self._domain_by_extension[extension]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
for pattern, pattern_domain in self._domain_by_file_pattern.items():
|
||||
if self._match(file_, pattern):
|
||||
domain = pattern_domain
|
||||
|
||||
return domain
|
||||
|
||||
|
||||
class ProjectInfoFactory(object):
|
||||
|
||||
def __init__(self, source_dir, build_dir, config_dir, match):
|
||||
|
||||
self.source_dir = source_dir
|
||||
self.build_dir = build_dir
|
||||
self.config_dir = config_dir
|
||||
self.match = match
|
||||
|
||||
self.projects = {}
|
||||
self.default_project = None
|
||||
self.domain_by_extension = {}
|
||||
self.domain_by_file_pattern = {}
|
||||
|
||||
self.project_count = 0
|
||||
self.project_info_store = {}
|
||||
self.project_info_for_auto_store = {}
|
||||
self.auto_project_info_store = {}
|
||||
|
||||
def update(
|
||||
self,
|
||||
projects,
|
||||
default_project,
|
||||
domain_by_extension,
|
||||
domain_by_file_pattern,
|
||||
projects_source,
|
||||
build_dir
|
||||
):
|
||||
|
||||
self.projects = projects
|
||||
self.default_project = default_project
|
||||
self.domain_by_extension = domain_by_extension
|
||||
self.domain_by_file_pattern = domain_by_file_pattern
|
||||
self.projects_source = projects_source
|
||||
|
||||
# If the breathe config values has a non-empty value for build_dir then use that otherwise
|
||||
# stick with the default
|
||||
if build_dir:
|
||||
self.build_dir = build_dir
|
||||
|
||||
def default_path(self):
|
||||
|
||||
if not self.default_project:
|
||||
raise NoDefaultProjectError(
|
||||
"No breathe_default_project config setting to fall back on "
|
||||
"for directive with no 'project' or 'path' specified."
|
||||
)
|
||||
|
||||
try:
|
||||
return self.projects[self.default_project]
|
||||
except KeyError:
|
||||
raise ProjectError(
|
||||
("breathe_default_project value '%s' does not seem to be a valid key for the "
|
||||
"breathe_projects dictionary") % self.default_project
|
||||
)
|
||||
|
||||
def create_project_info(self, options):
|
||||
|
||||
name = ""
|
||||
|
||||
if "project" in options:
|
||||
try:
|
||||
path = self.projects[options["project"]]
|
||||
name = options["project"]
|
||||
except KeyError:
|
||||
raise ProjectError("Unable to find project '%s' in breathe_projects dictionary"
|
||||
% options["project"])
|
||||
|
||||
elif "path" in options:
|
||||
path = options["path"]
|
||||
|
||||
else:
|
||||
path = self.default_path()
|
||||
|
||||
try:
|
||||
return self.project_info_store[path]
|
||||
except KeyError:
|
||||
|
||||
reference = name
|
||||
|
||||
if not name:
|
||||
name = "project%s" % self.project_count
|
||||
reference = path
|
||||
self.project_count += 1
|
||||
|
||||
project_info = ProjectInfo(
|
||||
name,
|
||||
path,
|
||||
"NoSourcePath",
|
||||
reference,
|
||||
self.source_dir,
|
||||
self.config_dir,
|
||||
self.domain_by_extension,
|
||||
self.domain_by_file_pattern,
|
||||
self.match
|
||||
)
|
||||
|
||||
self.project_info_store[path] = project_info
|
||||
|
||||
return project_info
|
||||
|
||||
def store_project_info_for_auto(self, name, project_info):
|
||||
"""Stores the project info by name for later extraction by the auto directives.
|
||||
|
||||
Stored separately to the non-auto project info objects as they should never overlap.
|
||||
"""
|
||||
|
||||
self.project_info_for_auto_store[name] = project_info
|
||||
|
||||
def retrieve_project_info_for_auto(self, options):
|
||||
"""Retrieves the project info by name for later extraction by the auto directives.
|
||||
|
||||
Looks for the 'project' entry in the options dictionary. This is a less than ideal API but
|
||||
it is designed to match the use of 'create_project_info' above for which it makes much more
|
||||
sense.
|
||||
"""
|
||||
|
||||
name = options.get('project', self.default_project)
|
||||
|
||||
if name is None:
|
||||
raise NoDefaultProjectError(
|
||||
"No breathe_default_project config setting to fall back on "
|
||||
"for directive with no 'project' or 'path' specified."
|
||||
)
|
||||
|
||||
return self.project_info_for_auto_store[name]
|
||||
|
||||
def create_auto_project_info(self, name, source_path):
|
||||
|
||||
key = source_path
|
||||
|
||||
try:
|
||||
return self.auto_project_info_store[key]
|
||||
except KeyError:
|
||||
|
||||
reference = name
|
||||
|
||||
if not name:
|
||||
name = "project%s" % self.project_count
|
||||
reference = source_path
|
||||
self.project_count += 1
|
||||
|
||||
auto_project_info = AutoProjectInfo(
|
||||
name,
|
||||
source_path,
|
||||
self.build_dir,
|
||||
reference,
|
||||
self.source_dir,
|
||||
self.config_dir,
|
||||
self.domain_by_extension,
|
||||
self.domain_by_file_pattern,
|
||||
self.match
|
||||
)
|
||||
|
||||
self.auto_project_info_store[key] = auto_project_info
|
||||
|
||||
return auto_project_info
|
||||
Binary file not shown.
Binary file not shown.
@ -1,2 +0,0 @@
|
||||
|
||||
|
||||
Binary file not shown.
@ -1,383 +0,0 @@
|
||||
|
||||
from .base import Renderer, RenderContext
|
||||
from . import index as indexrenderer
|
||||
from . import compound as compoundrenderer
|
||||
|
||||
from docutils import nodes
|
||||
import textwrap
|
||||
|
||||
class RstContentCreator(object):
|
||||
|
||||
def __init__(self, list_type, dedent):
|
||||
|
||||
self.list_type = list_type
|
||||
self.dedent = dedent
|
||||
|
||||
def __call__(self, text):
|
||||
|
||||
# Remove the first line which is "embed:rst[:leading-asterisk]"
|
||||
text = "\n".join(text.split(u"\n")[1:])
|
||||
|
||||
# Remove starting whitespace
|
||||
text = self.dedent(text)
|
||||
|
||||
# Inspired by autodoc.py in Sphinx
|
||||
result = self.list_type()
|
||||
for line in text.split("\n"):
|
||||
result.append(line, "<breathe>")
|
||||
|
||||
return result
|
||||
|
||||
class UnicodeRenderer(Renderer):
|
||||
|
||||
def render(self):
|
||||
|
||||
# Skip any nodes that are pure whitespace
|
||||
# Probably need a better way to do this as currently we're only doing
|
||||
# it skip whitespace between higher-level nodes, but this will also
|
||||
# skip any pure whitespace entries in actual content nodes
|
||||
#
|
||||
# We counter that second issue slightly by allowing through single white spaces
|
||||
#
|
||||
if self.data_object.strip():
|
||||
return [self.node_factory.Text(self.data_object)]
|
||||
elif self.data_object == unicode(" "):
|
||||
return [self.node_factory.Text(self.data_object)]
|
||||
else:
|
||||
return []
|
||||
|
||||
class NullRenderer(Renderer):
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def render(self):
|
||||
return []
|
||||
|
||||
|
||||
class DoxygenToRstRendererFactory(object):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
node_type,
|
||||
renderers,
|
||||
renderer_factory_creator,
|
||||
node_factory,
|
||||
project_info,
|
||||
state,
|
||||
document,
|
||||
rst_content_creator,
|
||||
filter_,
|
||||
target_handler,
|
||||
domain_directive_factory
|
||||
):
|
||||
|
||||
self.node_type = node_type
|
||||
self.node_factory = node_factory
|
||||
self.project_info = project_info
|
||||
self.renderers = renderers
|
||||
self.renderer_factory_creator = renderer_factory_creator
|
||||
self.state = state
|
||||
self.document = document
|
||||
self.rst_content_creator = rst_content_creator
|
||||
self.filter_ = filter_
|
||||
self.target_handler = target_handler
|
||||
self.domain_directive_factory = domain_directive_factory
|
||||
|
||||
def create_renderer(
|
||||
self,
|
||||
context
|
||||
):
|
||||
|
||||
parent_data_object = context.node_stack[1]
|
||||
data_object = context.node_stack[0]
|
||||
|
||||
if not self.filter_.allow(context.node_stack):
|
||||
return NullRenderer()
|
||||
|
||||
child_renderer_factory = self.renderer_factory_creator.create_child_factory(
|
||||
self.project_info,
|
||||
data_object,
|
||||
self
|
||||
)
|
||||
|
||||
try:
|
||||
node_type = data_object.node_type
|
||||
except AttributeError as e:
|
||||
|
||||
# Horrible hack to silence errors on filtering unicode objects
|
||||
# until we fix the parsing
|
||||
if type(data_object) == unicode:
|
||||
node_type = "unicode"
|
||||
else:
|
||||
raise e
|
||||
|
||||
Renderer = self.renderers[node_type]
|
||||
|
||||
common_args = [
|
||||
self.project_info,
|
||||
context,
|
||||
child_renderer_factory,
|
||||
self.node_factory,
|
||||
self.state,
|
||||
self.document,
|
||||
self.target_handler,
|
||||
self.domain_directive_factory
|
||||
]
|
||||
|
||||
if node_type == "docmarkup":
|
||||
|
||||
creator = self.node_factory.inline
|
||||
if data_object.type_ == "emphasis":
|
||||
creator = self.node_factory.emphasis
|
||||
elif data_object.type_ == "computeroutput":
|
||||
creator = self.node_factory.literal
|
||||
elif data_object.type_ == "bold":
|
||||
creator = self.node_factory.strong
|
||||
elif data_object.type_ == "superscript":
|
||||
creator = self.node_factory.superscript
|
||||
elif data_object.type_ == "subscript":
|
||||
creator = self.node_factory.subscript
|
||||
elif data_object.type_ == "center":
|
||||
print("Warning: does not currently handle 'center' text display")
|
||||
elif data_object.type_ == "small":
|
||||
print("Warning: does not currently handle 'small' text display")
|
||||
|
||||
return Renderer(
|
||||
creator,
|
||||
*common_args
|
||||
)
|
||||
|
||||
if node_type == "verbatim":
|
||||
|
||||
return Renderer(
|
||||
self.rst_content_creator,
|
||||
*common_args
|
||||
)
|
||||
|
||||
if node_type == "compound":
|
||||
|
||||
kind = data_object.kind
|
||||
if kind in ["file", "dir", "page", "example", "group"]:
|
||||
return Renderer(indexrenderer.FileRenderer, *common_args)
|
||||
|
||||
class_ = indexrenderer.CompoundTypeSubRenderer
|
||||
|
||||
# For compound node types Renderer is CreateCompoundTypeSubRenderer
|
||||
# as defined below. This could be cleaner
|
||||
return Renderer(
|
||||
class_,
|
||||
*common_args
|
||||
)
|
||||
|
||||
if node_type == "memberdef":
|
||||
|
||||
if data_object.kind in ("function", "slot") or (data_object.kind == 'friend' and data_object.argsstring):
|
||||
Renderer = compoundrenderer.FuncMemberDefTypeSubRenderer
|
||||
elif data_object.kind == "enum":
|
||||
Renderer = compoundrenderer.EnumMemberDefTypeSubRenderer
|
||||
elif data_object.kind == "typedef":
|
||||
Renderer = compoundrenderer.TypedefMemberDefTypeSubRenderer
|
||||
elif data_object.kind == "variable":
|
||||
Renderer = compoundrenderer.VariableMemberDefTypeSubRenderer
|
||||
elif data_object.kind == "define":
|
||||
Renderer = compoundrenderer.DefineMemberDefTypeSubRenderer
|
||||
|
||||
if node_type == "param":
|
||||
return Renderer(
|
||||
parent_data_object.node_type != "templateparamlist",
|
||||
*common_args
|
||||
)
|
||||
|
||||
if node_type == "docsimplesect":
|
||||
if data_object.kind == "par":
|
||||
Renderer = compoundrenderer.ParDocSimpleSectTypeSubRenderer
|
||||
|
||||
return Renderer(
|
||||
*common_args
|
||||
)
|
||||
|
||||
class CreateCompoundTypeSubRenderer(object):
|
||||
|
||||
def __init__(self, parser_factory):
|
||||
|
||||
self.parser_factory = parser_factory
|
||||
|
||||
def __call__(self, class_, project_info, *args):
|
||||
|
||||
compound_parser = self.parser_factory.create_compound_parser(project_info)
|
||||
return class_(compound_parser, project_info, *args)
|
||||
|
||||
|
||||
class CreateRefTypeSubRenderer(object):
|
||||
|
||||
def __init__(self, parser_factory):
|
||||
|
||||
self.parser_factory = parser_factory
|
||||
|
||||
def __call__(self, project_info, *args):
|
||||
|
||||
compound_parser = self.parser_factory.create_compound_parser(project_info)
|
||||
return compoundrenderer.RefTypeSubRenderer(compound_parser, project_info, *args)
|
||||
|
||||
|
||||
class DoxygenToRstRendererFactoryCreator(object):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
node_factory,
|
||||
parser_factory,
|
||||
domain_directive_factory,
|
||||
rst_content_creator,
|
||||
project_info
|
||||
):
|
||||
|
||||
self.node_factory = node_factory
|
||||
self.parser_factory = parser_factory
|
||||
self.domain_directive_factory = domain_directive_factory
|
||||
self.rst_content_creator = rst_content_creator
|
||||
self.project_info = project_info
|
||||
|
||||
def create_factory(self, node_stack, state, document, filter_, target_handler):
|
||||
|
||||
data_object = node_stack[0]
|
||||
|
||||
renderers = {
|
||||
"doxygen" : indexrenderer.DoxygenTypeSubRenderer,
|
||||
"compound" : CreateCompoundTypeSubRenderer(self.parser_factory),
|
||||
"doxygendef" : compoundrenderer.DoxygenTypeSubRenderer,
|
||||
"compounddef" : compoundrenderer.CompoundDefTypeSubRenderer,
|
||||
"sectiondef" : compoundrenderer.SectionDefTypeSubRenderer,
|
||||
"memberdef" : compoundrenderer.MemberDefTypeSubRenderer,
|
||||
"enumvalue" : compoundrenderer.EnumvalueTypeSubRenderer,
|
||||
"linkedtext" : compoundrenderer.LinkedTextTypeSubRenderer,
|
||||
"description" : compoundrenderer.DescriptionTypeSubRenderer,
|
||||
"param" : compoundrenderer.ParamTypeSubRenderer,
|
||||
"docreftext" : compoundrenderer.DocRefTextTypeSubRenderer,
|
||||
"docheading" : compoundrenderer.DocHeadingTypeSubRenderer,
|
||||
"docpara" : compoundrenderer.DocParaTypeSubRenderer,
|
||||
"docmarkup" : compoundrenderer.DocMarkupTypeSubRenderer,
|
||||
"docparamlist" : compoundrenderer.DocParamListTypeSubRenderer,
|
||||
"docparamlistitem" : compoundrenderer.DocParamListItemSubRenderer,
|
||||
"docparamnamelist" : compoundrenderer.DocParamNameListSubRenderer,
|
||||
"docparamname" : compoundrenderer.DocParamNameSubRenderer,
|
||||
"docsect1" : compoundrenderer.DocSect1TypeSubRenderer,
|
||||
"docsimplesect" : compoundrenderer.DocSimpleSectTypeSubRenderer,
|
||||
"doctitle" : compoundrenderer.DocTitleTypeSubRenderer,
|
||||
"docformula" : compoundrenderer.DocForumlaTypeSubRenderer,
|
||||
"docimage" : compoundrenderer.DocImageTypeSubRenderer,
|
||||
"docurllink" : compoundrenderer.DocURLLinkSubRenderer,
|
||||
"listing" : compoundrenderer.ListingTypeSubRenderer,
|
||||
"codeline" : compoundrenderer.CodeLineTypeSubRenderer,
|
||||
"highlight" : compoundrenderer.HighlightTypeSubRenderer,
|
||||
"templateparamlist" : compoundrenderer.TemplateParamListRenderer,
|
||||
"inc" : compoundrenderer.IncTypeSubRenderer,
|
||||
"ref" : CreateRefTypeSubRenderer(self.parser_factory),
|
||||
"verbatim" : compoundrenderer.VerbatimTypeSubRenderer,
|
||||
"mixedcontainer" : compoundrenderer.MixedContainerRenderer,
|
||||
"unicode" : UnicodeRenderer,
|
||||
"doclist": compoundrenderer.DocListTypeSubRenderer,
|
||||
"doclistitem": compoundrenderer.DocListItemTypeSubRenderer,
|
||||
}
|
||||
|
||||
try:
|
||||
node_type = data_object.node_type
|
||||
except AttributeError as e:
|
||||
|
||||
# Horrible hack to silence errors on filtering unicode objects
|
||||
# until we fix the parsing
|
||||
if type(data_object) == unicode:
|
||||
node_type = "unicode"
|
||||
else:
|
||||
raise e
|
||||
|
||||
return DoxygenToRstRendererFactory(
|
||||
"root",
|
||||
renderers,
|
||||
self,
|
||||
self.node_factory,
|
||||
self.project_info,
|
||||
state,
|
||||
document,
|
||||
self.rst_content_creator,
|
||||
filter_,
|
||||
target_handler,
|
||||
self.domain_directive_factory
|
||||
)
|
||||
|
||||
def create_child_factory( self, project_info, data_object, parent_renderer_factory ):
|
||||
|
||||
try:
|
||||
node_type = data_object.node_type
|
||||
except AttributeError as e:
|
||||
|
||||
# Horrible hack to silence errors on filtering unicode objects
|
||||
# until we fix the parsing
|
||||
if type(data_object) == unicode:
|
||||
node_type = "unicode"
|
||||
else:
|
||||
raise e
|
||||
|
||||
return DoxygenToRstRendererFactory(
|
||||
node_type,
|
||||
parent_renderer_factory.renderers,
|
||||
self,
|
||||
self.node_factory,
|
||||
parent_renderer_factory.project_info,
|
||||
parent_renderer_factory.state,
|
||||
parent_renderer_factory.document,
|
||||
self.rst_content_creator,
|
||||
parent_renderer_factory.filter_,
|
||||
parent_renderer_factory.target_handler,
|
||||
parent_renderer_factory.domain_directive_factory
|
||||
)
|
||||
|
||||
|
||||
# FactoryFactoryFactory. Ridiculous but necessary.
|
||||
class DoxygenToRstRendererFactoryCreatorConstructor(object):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
node_factory,
|
||||
parser_factory,
|
||||
domain_directive_factory,
|
||||
rst_content_creator
|
||||
):
|
||||
|
||||
self.node_factory = node_factory
|
||||
self.parser_factory = parser_factory
|
||||
self.domain_directive_factory = domain_directive_factory
|
||||
self.rst_content_creator = rst_content_creator
|
||||
|
||||
def create_factory_creator(self, project_info, document, options, target_handler):
|
||||
|
||||
return DoxygenToRstRendererFactoryCreator(
|
||||
self.node_factory,
|
||||
self.parser_factory,
|
||||
self.domain_directive_factory,
|
||||
self.rst_content_creator,
|
||||
project_info,
|
||||
)
|
||||
|
||||
|
||||
def format_parser_error(name, error, filename, state, lineno, do_unicode_warning):
|
||||
|
||||
warning = '%s: Unable to parse xml file "%s". ' % (name, filename)
|
||||
explanation = 'Reported error: %s. ' % error
|
||||
|
||||
unicode_explanation_text = ""
|
||||
unicode_explanation = []
|
||||
if do_unicode_warning:
|
||||
unicode_explanation_text = textwrap.dedent("""
|
||||
Parsing errors are often due to unicode errors associated with the encoding of the original
|
||||
source files. Doxygen propagates invalid characters from the input source files to the
|
||||
output xml.""").strip().replace("\n", " ")
|
||||
unicode_explanation = [nodes.paragraph("", "", nodes.Text(unicode_explanation_text))]
|
||||
|
||||
return [nodes.warning("",
|
||||
nodes.paragraph("", "", nodes.Text(warning)),
|
||||
nodes.paragraph("", "", nodes.Text(explanation)),
|
||||
*unicode_explanation
|
||||
),
|
||||
state.document.reporter.warning(warning + explanation + unicode_explanation_text, line=lineno)
|
||||
]
|
||||
Binary file not shown.
@ -1,127 +0,0 @@
|
||||
|
||||
class Renderer(object):
|
||||
|
||||
def __init__(self,
|
||||
project_info,
|
||||
context,
|
||||
renderer_factory,
|
||||
node_factory,
|
||||
state,
|
||||
document,
|
||||
target_handler,
|
||||
domain_directive_factory,
|
||||
):
|
||||
|
||||
self.project_info = project_info
|
||||
self.context = context
|
||||
self.data_object = context.node_stack[0]
|
||||
self.renderer_factory = renderer_factory
|
||||
self.node_factory = node_factory
|
||||
self.state = state
|
||||
self.document = document
|
||||
self.target_handler = target_handler
|
||||
self.domain_directive_factory = domain_directive_factory
|
||||
|
||||
if self.context.domain == '':
|
||||
self.context.domain = self.get_domain()
|
||||
|
||||
def get_domain(self):
|
||||
"""Returns the domain for the current node."""
|
||||
|
||||
def get_filename(node):
|
||||
"""Returns the name of a file where the declaration represented by node is located."""
|
||||
try:
|
||||
return node.location.file
|
||||
except AttributeError:
|
||||
return None
|
||||
|
||||
node_stack = self.context.node_stack
|
||||
node = node_stack[0]
|
||||
# An enumvalue node doesn't have location, so use its parent node for detecting the domain instead.
|
||||
if type(node) == unicode or node.node_type == "enumvalue":
|
||||
node = node_stack[1]
|
||||
filename = get_filename(node)
|
||||
if not filename and node.node_type == "compound":
|
||||
file_data = self.compound_parser.parse(node.refid)
|
||||
filename = get_filename(file_data.compounddef)
|
||||
return self.project_info.domain_for_file(filename) if filename else ''
|
||||
|
||||
def get_fully_qualified_name(self):
|
||||
|
||||
names = []
|
||||
node_stack = self.context.node_stack
|
||||
node = node_stack[0]
|
||||
if node.node_type == 'enumvalue':
|
||||
names.append(node.name)
|
||||
# Skip the name of the containing enum because it is not a part of the fully qualified name.
|
||||
node_stack = node_stack[2:]
|
||||
|
||||
# If the node is a namespace, use its name because namespaces are skipped in the main loop.
|
||||
if node.node_type == 'compound' and node.kind == 'namespace':
|
||||
names.append(node.name)
|
||||
|
||||
for node in node_stack:
|
||||
if node.node_type == 'ref' and len(names) == 0:
|
||||
return node.valueOf_
|
||||
if (node.node_type == 'compound' and node.kind not in ['file', 'namespace']) or \
|
||||
node.node_type == 'memberdef':
|
||||
# We skip the 'file' entries because the file name doesn't form part of the
|
||||
# qualified name for the identifier. We skip the 'namespace' entries because if we
|
||||
# find an object through the namespace 'compound' entry in the index.xml then we'll
|
||||
# also have the 'compounddef' entry in our node stack and we'll get it from that. We
|
||||
# need the 'compounddef' entry because if we find the object through the 'file'
|
||||
# entry in the index.xml file then we need to get the namespace name from somewhere
|
||||
names.insert(0, node.name)
|
||||
if (node.node_type == 'compounddef' and node.kind == 'namespace'):
|
||||
# Nested namespaces include their parent namespace(s) in compoundname. ie,
|
||||
# compoundname is 'foo::bar' instead of just 'bar' for namespace 'bar' nested in
|
||||
# namespace 'foo'. We need full compoundname because node_stack doesn't necessarily
|
||||
# include parent namespaces and we stop here in case it does.
|
||||
names.insert(0, node.compoundname)
|
||||
break
|
||||
|
||||
return '::'.join(names)
|
||||
|
||||
def create_template_node(self, decl):
|
||||
"""Creates a node for the ``template <...>`` part of the declaration."""
|
||||
if not decl.templateparamlist:
|
||||
return None
|
||||
context = self.context.create_child_context(decl.templateparamlist)
|
||||
renderer = self.renderer_factory.create_renderer(context)
|
||||
nodes = [self.node_factory.Text("template <")]
|
||||
nodes.extend(renderer.render())
|
||||
nodes.append(self.node_factory.Text(">"))
|
||||
signode = self.node_factory.desc_signature()
|
||||
signode.extend(nodes)
|
||||
return signode
|
||||
|
||||
def run_domain_directive(self, kind, names):
|
||||
domain_directive = self.renderer_factory.domain_directive_factory.create(
|
||||
self.context.domain, [kind, names] + self.context.directive_args[2:])
|
||||
|
||||
# Translate Breathe's no-link option into the standard noindex option.
|
||||
if 'no-link' in self.context.directive_args[2]:
|
||||
domain_directive.options['noindex'] = True
|
||||
nodes = domain_directive.run()
|
||||
|
||||
# Filter out outer class names if we are rendering a member as a part of a class content.
|
||||
signode = nodes[1].children[0]
|
||||
if len(names) > 0 and self.context.child:
|
||||
signode.children = [n for n in signode.children if not n.tagname == 'desc_addname']
|
||||
return nodes
|
||||
|
||||
|
||||
class RenderContext(object):
|
||||
|
||||
def __init__(self, node_stack, mask_factory, directive_args, domain='', child=False):
|
||||
self.node_stack = node_stack
|
||||
self.mask_factory = mask_factory
|
||||
self.directive_args = directive_args
|
||||
self.domain = domain
|
||||
self.child = child
|
||||
|
||||
def create_child_context(self, data_object):
|
||||
|
||||
node_stack = self.node_stack[:]
|
||||
node_stack.insert(0, self.mask_factory.mask(data_object))
|
||||
return RenderContext(node_stack, self.mask_factory, self.directive_args, self.domain, True)
|
||||
Binary file not shown.
File diff suppressed because it is too large
Load Diff
Binary file not shown.
File diff suppressed because it is too large
Load Diff
Binary file not shown.
@ -1,115 +0,0 @@
|
||||
|
||||
from .base import Renderer
|
||||
|
||||
class DoxygenTypeSubRenderer(Renderer):
|
||||
|
||||
def render(self):
|
||||
|
||||
nodelist = []
|
||||
|
||||
# Process all the compound children
|
||||
for compound in self.data_object.get_compound():
|
||||
context = self.context.create_child_context(compound)
|
||||
compound_renderer = self.renderer_factory.create_renderer(context)
|
||||
nodelist.extend(compound_renderer.render())
|
||||
|
||||
return nodelist
|
||||
|
||||
|
||||
class CompoundRenderer(Renderer):
|
||||
"""Base class for CompoundTypeSubRenderer and RefTypeSubRenderer."""
|
||||
|
||||
def __init__(self, compound_parser, render_empty_node, *args):
|
||||
self.compound_parser = compound_parser
|
||||
self.render_empty_node = render_empty_node
|
||||
Renderer.__init__(self, *args)
|
||||
|
||||
def create_doxygen_target(self):
|
||||
"""Can be overridden to create a target node which uses the doxygen refid information
|
||||
which can be used for creating links between internal doxygen elements.
|
||||
|
||||
The default implementation should suffice most of the time.
|
||||
"""
|
||||
|
||||
refid = "%s%s" % (self.project_info.name(), self.data_object.refid)
|
||||
return self.target_handler.create_target(refid)
|
||||
|
||||
def render_signature(self, file_data, doxygen_target):
|
||||
# Defer to domains specific directive.
|
||||
name, kind = self.get_node_info(file_data)
|
||||
self.context.directive_args[1] = [self.get_fully_qualified_name()]
|
||||
nodes = self.run_domain_directive(kind, self.context.directive_args[1])
|
||||
node = nodes[1]
|
||||
signode, contentnode = node.children
|
||||
|
||||
# The cpp domain in Sphinx doesn't support structs at the moment, so change the text from "class "
|
||||
# to the correct kind which can be "class " or "struct ".
|
||||
signode[0] = self.node_factory.desc_annotation(kind + ' ', kind + ' ')
|
||||
|
||||
# Check if there is template information and format it as desired
|
||||
template_signode = self.create_template_node(file_data.compounddef)
|
||||
if template_signode:
|
||||
node.insert(0, template_signode)
|
||||
node.children[0].insert(0, doxygen_target)
|
||||
return nodes, contentnode
|
||||
|
||||
def render(self):
|
||||
|
||||
# Read in the corresponding xml file and process
|
||||
file_data = self.compound_parser.parse(self.data_object.refid)
|
||||
|
||||
parent_context = self.context.create_child_context(file_data)
|
||||
data_renderer = self.renderer_factory.create_renderer(parent_context)
|
||||
rendered_data = data_renderer.render()
|
||||
|
||||
if not rendered_data and not self.render_empty_node:
|
||||
return []
|
||||
|
||||
file_data = parent_context.node_stack[0]
|
||||
new_context = parent_context.create_child_context(file_data.compounddef)
|
||||
|
||||
nodes, contentnode = self.render_signature(file_data, self.create_doxygen_target())
|
||||
|
||||
if file_data.compounddef.includes:
|
||||
for include in file_data.compounddef.includes:
|
||||
context = new_context.create_child_context(include)
|
||||
renderer = self.renderer_factory.create_renderer(context)
|
||||
contentnode.extend(renderer.render())
|
||||
|
||||
contentnode.extend(rendered_data)
|
||||
return nodes
|
||||
|
||||
|
||||
class CompoundTypeSubRenderer(CompoundRenderer):
|
||||
|
||||
def __init__(self, compound_parser, *args):
|
||||
CompoundRenderer.__init__(self, compound_parser, True, *args)
|
||||
|
||||
def get_node_info(self, file_data):
|
||||
return self.data_object.name, self.data_object.kind
|
||||
|
||||
|
||||
class FileRenderer(CompoundTypeSubRenderer):
|
||||
|
||||
def render_signature(self, file_data, doxygen_target):
|
||||
# Build targets for linking
|
||||
targets = []
|
||||
targets.extend(doxygen_target)
|
||||
|
||||
title_signode = self.node_factory.desc_signature()
|
||||
title_signode.extend(targets)
|
||||
|
||||
# Set up the title
|
||||
name, kind = self.get_node_info(file_data)
|
||||
title_signode.append(self.node_factory.emphasis(text=kind))
|
||||
title_signode.append(self.node_factory.Text(" "))
|
||||
title_signode.append(self.node_factory.desc_name(text=name))
|
||||
|
||||
contentnode = self.node_factory.desc_content()
|
||||
|
||||
node = self.node_factory.desc()
|
||||
node.document = self.state.document
|
||||
node['objtype'] = kind
|
||||
node.append(title_signode)
|
||||
node.append(contentnode)
|
||||
return [node], contentnode
|
||||
Binary file not shown.
@ -1,62 +0,0 @@
|
||||
"""
|
||||
Masks
|
||||
=====
|
||||
|
||||
Masks are related to filters. Filters can block the processing of particular parts of the xml
|
||||
hierarchy but they can only work on node level. If the part of the xml hierarchy that you want to
|
||||
filter out is read in as an instance of one of the classes in parser/doxygen/*.py then you can use
|
||||
the filters. However, if you want to filter out an attribute from one of the nodes (and some of the
|
||||
xml child nodes are read in as attributes on their parents) then you can't use a filter.
|
||||
|
||||
We introduce the Mask's to fulfil this need. The masks are designed to be applied to a particular
|
||||
node type and to limit the access to particular attributes on the node. For example, then
|
||||
NoParameterNamesMask wraps a node a returns all its standard attributes but returns None for the
|
||||
'declname' and 'defname' attributes.
|
||||
|
||||
Currently the Mask functionality is only used for the text signature rendering for doing function
|
||||
matching.
|
||||
|
||||
"""
|
||||
|
||||
class NoParameterNamesMask(object):
|
||||
|
||||
def __init__(self, data_object):
|
||||
self.data_object = data_object
|
||||
|
||||
def __getattr__(self, attr):
|
||||
|
||||
if attr in ['declname', 'defname', 'defval']:
|
||||
return None
|
||||
|
||||
return getattr(self.data_object, attr)
|
||||
|
||||
class MaskFactory(object):
|
||||
|
||||
def __init__(self, lookup):
|
||||
self.lookup = lookup
|
||||
|
||||
def mask(self, data_object):
|
||||
|
||||
try:
|
||||
node_type = data_object.node_type
|
||||
except AttributeError as e:
|
||||
|
||||
# Horrible hack to silence errors on filtering unicode objects
|
||||
# until we fix the parsing
|
||||
if type(data_object) == unicode:
|
||||
node_type = "unicode"
|
||||
else:
|
||||
raise e
|
||||
|
||||
if node_type in self.lookup:
|
||||
Mask = self.lookup[node_type]
|
||||
return Mask(data_object)
|
||||
|
||||
return data_object
|
||||
|
||||
|
||||
class NullMaskFactory(object):
|
||||
|
||||
def mask(self, data_object):
|
||||
return data_object
|
||||
|
||||
Binary file not shown.
@ -1,40 +0,0 @@
|
||||
|
||||
class TargetHandler(object):
|
||||
|
||||
def __init__(self, project_info, node_factory, document):
|
||||
|
||||
self.project_info = project_info
|
||||
self.node_factory = node_factory
|
||||
self.document = document
|
||||
|
||||
def create_target(self, id_):
|
||||
"""Creates a target node and registers it with the document and returns it in a list"""
|
||||
|
||||
target = self.node_factory.target(ids=[id_], names=[id_])
|
||||
|
||||
try:
|
||||
self.document.note_explicit_target(target)
|
||||
except Exception:
|
||||
# TODO: We should really return a docutils warning node here
|
||||
print("Warning: Duplicate target detected: %s" % id_)
|
||||
|
||||
return [target]
|
||||
|
||||
class NullTargetHandler(object):
|
||||
|
||||
def create_target(self, refid):
|
||||
return []
|
||||
|
||||
class TargetHandlerFactory(object):
|
||||
|
||||
def __init__(self, node_factory):
|
||||
|
||||
self.node_factory = node_factory
|
||||
|
||||
def create_target_handler(self, options, project_info, document):
|
||||
|
||||
if options.has_key("no-link"):
|
||||
return NullTargetHandler()
|
||||
|
||||
return TargetHandler(project_info, self.node_factory, document)
|
||||
|
||||
Binary file not shown.
Reference in New Issue
Block a user