'
- out += convert_node(n, 'code', {'class': 'language-cpp'})
- out += ''
+ if n.tag == "programlisting" or n.tag == "verbatim":
+ out += ""
+ out += convert_node(n, "code", {"class": "language-cpp"})
+ out += ""
continue
- if n.tag == 'ulink':
- out += convert_node(n, 'a', {'href': n.attrib['url']})
+ if n.tag == "ulink":
+ out += convert_node(n, "a", {"href": n.attrib["url"]})
continue
out += tag_text_map[n.tag]
return out
-def convert_template_params(node: ElementTree.Element) -> Optional[List[Definition]]:
- template_param_list = node.find('templateparamlist')
+def convert_template_params(node: ET.Element) -> "list[Definition] | None":
+ template_param_list = node.find("templateparamlist")
if template_param_list is None:
return None
- params = []
- for param_node in template_param_list.findall('param'):
- name = param_node.find('declname')
- param = Definition(name.text if name is not None else '', 'param')
- param.type = param_node.find('type').text
+ params: "list[Definition]" = []
+ for param_node in template_param_list.findall("param"):
+ name = param_node.find("declname")
+ if name is not None:
+ name = name.text
+ if name is None:
+ name = ""
+ param = Definition(name, "param")
+ param_type = param_node.find("type")
+ if param_type is not None:
+ param.type = param_type.text
params.append(param)
return params
-def get_description(node: ElementTree.Element) -> List[ElementTree.Element]:
- return node.findall('briefdescription/para') + \
- node.findall('detaileddescription/para')
+def get_description(node: ET.Element) -> list[ET.Element]:
+ return node.findall("briefdescription/para") + node.findall(
+ "detaileddescription/para"
+ )
def normalize_type(type_: str) -> str:
- type_ = type_.replace('< ', '<').replace(' >', '>')
- return type_.replace(' &', '&').replace(' *', '*')
+ type_ = type_.replace("< ", "<").replace(" >", ">")
+ return type_.replace(" &", "&").replace(" *", "*")
-def convert_type(type_: ElementTree.Element) -> Optional[str]:
+def convert_type(type_: "ET.Element | None") -> "str | None":
if type_ is None:
return None
- result = type_.text if type_.text else ''
+ result = type_.text if type_.text else ""
for ref in type_:
+ if ref.text is None:
+ raise ValueError
result += ref.text
if ref.tail:
result += ref.tail
+ if type_.tail is None:
+ raise ValueError
result += type_.tail.strip()
return normalize_type(result)
-def convert_params(func: ElementTree.Element) -> List[Definition]:
- params = []
- for p in func.findall('param'):
- d = Definition(p.find('declname').text, 'param')
- d.type = convert_type(p.find('type'))
+def convert_params(func: ET.Element) -> list[Definition]:
+ params: "list[Definition]" = []
+ for p in func.findall("param"):
+ declname = p.find("declname")
+ if declname is None or declname.text is None:
+ raise ValueError
+ d = Definition(declname.text, "param")
+ d.type = convert_type(p.find("type"))
params.append(d)
return params
-def convert_return_type(d: Definition, node: ElementTree.Element) -> None:
+def convert_return_type(d: Definition, node: ET.Element) -> None:
d.trailing_return_type = None
- if d.type == 'auto' or d.type == 'constexpr auto':
- parts = node.find('argsstring').text.split(' -> ')
+ if d.type == "auto" or d.type == "constexpr auto":
+ argsstring = node.find("argsstring")
+ if argsstring is None or argsstring.text is None:
+ raise ValueError
+ parts = argsstring.text.split(" -> ")
if len(parts) > 1:
d.trailing_return_type = normalize_type(parts[1])
def render_param(param: Definition) -> str:
- return param.type + (f' {param.name}' if len(param.name) > 0 else '')
+ if param.type is None:
+ raise ValueError
+ return param.type + (f" {param.name}" if len(param.name) > 0 else "")
def render_decl(d: Definition) -> str:
- text = ''
+ text = ""
if d.id is not None:
text += f'\n'
text += ''
- text += ''
+ text += ""
if d.template_params is not None:
- text += 'template <'
- text += ', '.join([render_param(p) for p in d.template_params])
- text += '>\n'
- text += ''
-
- text += ''
- end = ';'
- if d.kind == 'function' or d.kind == 'variable':
- text += d.type + ' ' if len(d.type) > 0 else ''
- elif d.kind == 'typedef':
- text += 'using '
- elif d.kind == 'define':
- end = ''
+ text += "template <"
+ text += ", ".join([render_param(p) for p in d.template_params])
+ text += ">\n"
+ text += ""
+
+ text += ""
+ end = ";"
+ if d.kind is None:
+ raise ValueError
+ if d.kind == "function" or d.kind == "variable":
+ if d.type is None:
+ raise ValueError
+ text += d.type + " " if len(d.type) > 0 else ""
+ elif d.kind == "typedef":
+ text += "using "
+ elif d.kind == "define":
+ end = ""
else:
- text += d.kind + ' '
+ text += d.kind + " "
text += d.name
if d.params is not None:
- params = ', '.join([
- (p.type + ' ' if p.type else '') + p.name for p in d.params])
- text += '(' + escape_html(params) + ')'
+ params = ", ".join([
+ (p.type + " " if p.type else "") + p.name for p in d.params
+ ])
+ text += "(" + escape_html(params) + ")"
if d.trailing_return_type:
- text += ' -> ' + escape_html(d.trailing_return_type)
- elif d.kind == 'typedef':
- text += ' = ' + escape_html(d.type)
+ text += " -> " + escape_html(d.trailing_return_type)
+ elif d.kind == "typedef":
+ if d.type is None:
+ raise ValueError
+ text += " = " + escape_html(d.type)
text += end
- text += ''
- text += '\n'
+ text += ""
+ text += "