def parse_definition(self, parser):
# add the base classes
ast = parser.parse_declaration("class", "class")
bases = []
for base in self.__bases:
namestr = base.content_[0].value
# build a name object
# TODO: work out if we can use base.refid in a pending_xref somewhere
try:
parser = cpp.DefinitionParser(namestr, self, self.env.config)
except TypeError:
# sphinx < 1.5
parser = cpp.DefinitionParser(namestr, self)
name = parser._parse_nested_name()
parser.assert_end()
bases.append(
cpp.ASTBaseClass(name, base.prot, base.virt == 'virtual',
False))
ast.declaration.bases = bases
return ast
def _parse_args(
self, function_description: str
) -> Optional[cpp.ASTParametersQualifiers]:
# Note: the caller must catch cpp.DefinitionError
if function_description == "":
return None
parser = cpp.DefinitionParser(function_description,
location=self.get_source_info(),
config=self.config)
paramQual = parser._parse_parameters_and_qualifiers(
paramMode="function")
# strip everything that doesn't contribute to overloading
def stripParamQual(paramQual):
paramQual.exceptionSpec = None
paramQual.final = None
paramQual.override = None
# TODO: strip attrs when Doxygen handles them
paramQual.initializer = None
paramQual.trailingReturn = None
for p in paramQual.args:
if p.arg is None:
assert p.ellipsis
continue
p.arg.init = None
declarator = p.arg.type.decl
def stripDeclarator(declarator):
if hasattr(declarator, "next"):
stripDeclarator(declarator.next)
if isinstance(declarator, cpp.ASTDeclaratorParen):
assert hasattr(declarator, "inner")
stripDeclarator(declarator.inner)
else:
assert isinstance(declarator,
cpp.ASTDeclaratorNameParamQual)
assert hasattr(declarator, "declId")
declarator.declId = None
if declarator.paramQual is not None:
stripParamQual(declarator.paramQual)
stripDeclarator(declarator)
stripParamQual(paramQual)
return paramQual
def _parse_args(self, function_description: str) -> Optional[cpp.ASTParametersQualifiers]:
if function_description == '':
return None
parser = cpp.DefinitionParser(function_description,
location=self.get_source_info(),
config=self.config)
paramQual = parser._parse_parameters_and_qualifiers(paramMode='function')
# now erase the parameter names
for p in paramQual.args:
if p.arg is None:
assert p.ellipsis
continue
declarator = p.arg.type.decl
while hasattr(declarator, 'next'):
declarator = declarator.next # type: ignore
assert hasattr(declarator, 'declId')
declarator.declId = None # type: ignore
p.arg.init = None # type: ignore
return paramQual
def create_function_signature(self, node_stack, project_info, filter_,
target_handler, mask_factory,
directive_args):
"Standard render process used by subclasses"
try:
object_renderer = SphinxRenderer(
self.parser_factory.app,
project_info,
node_stack,
self.state,
self.state.document,
target_handler,
self.parser_factory.create_compound_parser(project_info),
filter_,
)
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, directive_args)
node = node_stack[0]
with WithContext(object_renderer, context):
# this part should be kept in sync with visit_function in sphinxrenderer
name = node.get_name()
# assume we are only doing this for C++ declarations
declaration = ' '.join([
object_renderer.create_template_prefix(node),
''.join(n.astext()
for n in object_renderer.render(node.get_type())),
name,
node.get_argsstring()
])
parser = cpp.DefinitionParser(declaration,
location=self.get_source_info(),
config=self.config)
ast = parser.parse_declaration('function', 'function')
return str(ast)
