mirror of
https://github.com/sphinx-doc/sphinx.git
synced 2025-02-25 18:55:22 -06:00
Avoid using camelCase names in sphinx.domains.c
This commit is contained in:
Adam Turner
parent
0d88c8c06a
commit
8bc797b635
@ -80,18 +80,18 @@ class ASTIdentifier(ASTBaseBase):
|
||||
else:
|
||||
node = addnodes.desc_sig_name(self.name, self.name)
|
||||
if mode == 'markType':
|
||||
targetText = prefix + self.name
|
||||
target_text = prefix + self.name
|
||||
pnode = addnodes.pending_xref('', refdomain='c',
|
||||
reftype='identifier',
|
||||
reftarget=targetText, modname=None,
|
||||
reftarget=target_text, modname=None,
|
||||
classname=None)
|
||||
pnode['c:parent_key'] = symbol.get_lookup_key()
|
||||
pnode += node
|
||||
signode += pnode
|
||||
elif mode == 'lastIsName':
|
||||
nameNode = addnodes.desc_name()
|
||||
nameNode += node
|
||||
signode += nameNode
|
||||
name_node = addnodes.desc_name()
|
||||
name_node += node
|
||||
signode += name_node
|
||||
elif mode == 'noneIsName':
|
||||
signode += node
|
||||
else:
|
||||
@ -952,9 +952,9 @@ class ASTDeclSpecsSimple(ASTBaseBase):
|
||||
|
||||
if len(modifiers) != 0 and len(self.attrs) != 0:
|
||||
modifiers.append(addnodes.desc_sig_space())
|
||||
tempNode = nodes.TextElement()
|
||||
self.attrs.describe_signature(tempNode)
|
||||
modifiers.extend(tempNode.children)
|
||||
temp_node = nodes.TextElement()
|
||||
self.attrs.describe_signature(temp_node)
|
||||
modifiers.extend(temp_node.children)
|
||||
if self.storage:
|
||||
_add(modifiers, self.storage)
|
||||
if self.threadLocal:
|
||||
@ -1097,26 +1097,26 @@ class ASTArray(ASTBase):
|
||||
env: BuildEnvironment, symbol: Symbol) -> None:
|
||||
verify_description_mode(mode)
|
||||
signode += addnodes.desc_sig_punctuation('[', '[')
|
||||
addSpace = False
|
||||
add_space = False
|
||||
|
||||
def _add(signode: TextElement, text: str) -> bool:
|
||||
if addSpace:
|
||||
if add_space:
|
||||
signode += addnodes.desc_sig_space()
|
||||
signode += addnodes.desc_sig_keyword(text, text)
|
||||
return True
|
||||
|
||||
if self.static:
|
||||
addSpace = _add(signode, 'static')
|
||||
add_space = _add(signode, 'static')
|
||||
if self.restrict:
|
||||
addSpace = _add(signode, 'restrict')
|
||||
add_space = _add(signode, 'restrict')
|
||||
if self.volatile:
|
||||
addSpace = _add(signode, 'volatile')
|
||||
add_space = _add(signode, 'volatile')
|
||||
if self.const:
|
||||
addSpace = _add(signode, 'const')
|
||||
add_space = _add(signode, 'const')
|
||||
if self.vla:
|
||||
signode += addnodes.desc_sig_punctuation('*', '*')
|
||||
elif self.size:
|
||||
if addSpace:
|
||||
if add_space:
|
||||
signode += addnodes.desc_sig_space()
|
||||
self.size.describe_signature(signode, 'markType', env, symbol)
|
||||
signode += addnodes.desc_sig_punctuation(']', ']')
|
||||
@ -1405,8 +1405,8 @@ class ASTBracedInitList(ASTBase):
|
||||
|
||||
def _stringify(self, transform: StringifyTransform) -> str:
|
||||
exprs = ', '.join(transform(e) for e in self.exprs)
|
||||
trailingComma = ',' if self.trailingComma else ''
|
||||
return f'{{{exprs}{trailingComma}}}'
|
||||
trailing_comma = ',' if self.trailingComma else ''
|
||||
return f'{{{exprs}{trailing_comma}}}'
|
||||
|
||||
def describe_signature(self, signode: TextElement, mode: str,
|
||||
env: BuildEnvironment, symbol: Symbol) -> None:
|
||||
@ -1484,9 +1484,9 @@ class ASTType(ASTBase):
|
||||
|
||||
def _stringify(self, transform: StringifyTransform) -> str:
|
||||
res = []
|
||||
declSpecs = transform(self.declSpecs)
|
||||
res.append(declSpecs)
|
||||
if self.decl.require_space_after_declSpecs() and len(declSpecs) > 0:
|
||||
decl_specs = transform(self.declSpecs)
|
||||
res.append(decl_specs)
|
||||
if self.decl.require_space_after_declSpecs() and len(decl_specs) > 0:
|
||||
res.append(' ')
|
||||
res.append(transform(self.decl))
|
||||
return ''.join(res)
|
||||
@ -1831,32 +1831,32 @@ class ASTDeclaration(ASTBaseBase):
|
||||
# Always enable multiline:
|
||||
signode['is_multiline'] = True
|
||||
# Put each line in a desc_signature_line node.
|
||||
mainDeclNode = addnodes.desc_signature_line()
|
||||
mainDeclNode.sphinx_line_type = 'declarator'
|
||||
mainDeclNode['add_permalink'] = not self.symbol.isRedeclaration
|
||||
signode += mainDeclNode
|
||||
main_decl_node = addnodes.desc_signature_line()
|
||||
main_decl_node.sphinx_line_type = 'declarator'
|
||||
main_decl_node['add_permalink'] = not self.symbol.isRedeclaration
|
||||
signode += main_decl_node
|
||||
|
||||
if self.objectType in {'member', 'function', 'macro'}:
|
||||
pass
|
||||
elif self.objectType == 'struct':
|
||||
mainDeclNode += addnodes.desc_sig_keyword('struct', 'struct')
|
||||
mainDeclNode += addnodes.desc_sig_space()
|
||||
main_decl_node += addnodes.desc_sig_keyword('struct', 'struct')
|
||||
main_decl_node += addnodes.desc_sig_space()
|
||||
elif self.objectType == 'union':
|
||||
mainDeclNode += addnodes.desc_sig_keyword('union', 'union')
|
||||
mainDeclNode += addnodes.desc_sig_space()
|
||||
main_decl_node += addnodes.desc_sig_keyword('union', 'union')
|
||||
main_decl_node += addnodes.desc_sig_space()
|
||||
elif self.objectType == 'enum':
|
||||
mainDeclNode += addnodes.desc_sig_keyword('enum', 'enum')
|
||||
mainDeclNode += addnodes.desc_sig_space()
|
||||
main_decl_node += addnodes.desc_sig_keyword('enum', 'enum')
|
||||
main_decl_node += addnodes.desc_sig_space()
|
||||
elif self.objectType == 'enumerator':
|
||||
mainDeclNode += addnodes.desc_sig_keyword('enumerator', 'enumerator')
|
||||
mainDeclNode += addnodes.desc_sig_space()
|
||||
main_decl_node += addnodes.desc_sig_keyword('enumerator', 'enumerator')
|
||||
main_decl_node += addnodes.desc_sig_space()
|
||||
elif self.objectType == 'type':
|
||||
decl = cast('ASTType', self.declaration)
|
||||
prefix = decl.get_type_declaration_prefix()
|
||||
mainDeclNode += addnodes.desc_sig_keyword(prefix, prefix)
|
||||
mainDeclNode += addnodes.desc_sig_space()
|
||||
main_decl_node += addnodes.desc_sig_keyword(prefix, prefix)
|
||||
main_decl_node += addnodes.desc_sig_space()
|
||||
else:
|
||||
raise AssertionError
|
||||
self.declaration.describe_signature(mainDeclNode, mode, env, self.symbol)
|
||||
self.declaration.describe_signature(main_decl_node, mode, env, self.symbol)
|
||||
if self.semicolon:
|
||||
mainDeclNode += addnodes.desc_sig_punctuation(';', ';')
|
||||
main_decl_node += addnodes.desc_sig_punctuation(';', ';')
|
||||
|
||||
@ -100,7 +100,7 @@ class DefinitionParser(BaseParser):
|
||||
def _parse_string(self) -> str | None:
|
||||
if self.current_char != '"':
|
||||
return None
|
||||
startPos = self.pos
|
||||
start_pos = self.pos
|
||||
self.pos += 1
|
||||
escape = False
|
||||
while True:
|
||||
@ -114,7 +114,7 @@ class DefinitionParser(BaseParser):
|
||||
else:
|
||||
escape = False
|
||||
self.pos += 1
|
||||
return self.definition[startPos:self.pos]
|
||||
return self.definition[start_pos:self.pos]
|
||||
|
||||
def _parse_literal(self) -> ASTLiteral | None:
|
||||
# -> integer-literal
|
||||
@ -194,7 +194,7 @@ class DefinitionParser(BaseParser):
|
||||
return [], False
|
||||
|
||||
exprs = []
|
||||
trailingComma = False
|
||||
trailing_comma = False
|
||||
while True:
|
||||
self.skip_ws()
|
||||
expr = self._parse_expression()
|
||||
@ -207,9 +207,9 @@ class DefinitionParser(BaseParser):
|
||||
self.fail(f"Error in {name}, expected ',' or '{close}'.")
|
||||
if self.current_char == close == '}':
|
||||
self.pos += 1
|
||||
trailingComma = True
|
||||
trailing_comma = True
|
||||
break
|
||||
return exprs, trailingComma
|
||||
return exprs, trailing_comma
|
||||
|
||||
def _parse_paren_expression_list(self) -> ASTParenExprList | None:
|
||||
# -> '(' expression-list ')'
|
||||
@ -218,7 +218,7 @@ class DefinitionParser(BaseParser):
|
||||
#
|
||||
# expression-list
|
||||
# -> initializer-list
|
||||
exprs, trailingComma = self._parse_initializer_list("parenthesized expression-list",
|
||||
exprs, trailing_comma = self._parse_initializer_list("parenthesized expression-list",
|
||||
'(', ')')
|
||||
if exprs is None:
|
||||
return None
|
||||
@ -227,10 +227,10 @@ class DefinitionParser(BaseParser):
|
||||
def _parse_braced_init_list(self) -> ASTBracedInitList | None:
|
||||
# -> '{' initializer-list ','[opt] '}'
|
||||
# | '{' '}'
|
||||
exprs, trailingComma = self._parse_initializer_list("braced-init-list", '{', '}')
|
||||
exprs, trailing_comma = self._parse_initializer_list("braced-init-list", '{', '}')
|
||||
if exprs is None:
|
||||
return None
|
||||
return ASTBracedInitList(exprs, trailingComma)
|
||||
return ASTBracedInitList(exprs, trailing_comma)
|
||||
|
||||
def _parse_postfix_expression(self) -> ASTPostfixExpr:
|
||||
# -> primary
|
||||
@ -245,7 +245,7 @@ class DefinitionParser(BaseParser):
|
||||
prefix = self._parse_primary_expression()
|
||||
|
||||
# and now parse postfixes
|
||||
postFixes: list[ASTPostfixOp] = []
|
||||
post_fixes: list[ASTPostfixOp] = []
|
||||
while True:
|
||||
self.skip_ws()
|
||||
if self.skip_string_and_ws('['):
|
||||
@ -253,7 +253,7 @@ class DefinitionParser(BaseParser):
|
||||
self.skip_ws()
|
||||
if not self.skip_string(']'):
|
||||
self.fail("Expected ']' in end of postfix expression.")
|
||||
postFixes.append(ASTPostfixArray(expr))
|
||||
post_fixes.append(ASTPostfixArray(expr))
|
||||
continue
|
||||
if self.skip_string('->'):
|
||||
if self.skip_string('*'):
|
||||
@ -261,20 +261,20 @@ class DefinitionParser(BaseParser):
|
||||
self.pos -= 3
|
||||
else:
|
||||
name = self._parse_nested_name()
|
||||
postFixes.append(ASTPostfixMemberOfPointer(name))
|
||||
post_fixes.append(ASTPostfixMemberOfPointer(name))
|
||||
continue
|
||||
if self.skip_string('++'):
|
||||
postFixes.append(ASTPostfixInc())
|
||||
post_fixes.append(ASTPostfixInc())
|
||||
continue
|
||||
if self.skip_string('--'):
|
||||
postFixes.append(ASTPostfixDec())
|
||||
post_fixes.append(ASTPostfixDec())
|
||||
continue
|
||||
lst = self._parse_paren_expression_list()
|
||||
if lst is not None:
|
||||
postFixes.append(ASTPostfixCallExpr(lst))
|
||||
post_fixes.append(ASTPostfixCallExpr(lst))
|
||||
continue
|
||||
break
|
||||
return ASTPostfixExpr(prefix, postFixes)
|
||||
return ASTPostfixExpr(prefix, post_fixes)
|
||||
|
||||
def _parse_unary_expression(self) -> ASTExpression:
|
||||
# -> postfix
|
||||
@ -325,16 +325,16 @@ class DefinitionParser(BaseParser):
|
||||
self.fail("Expected ')' in cast expression.")
|
||||
expr = self._parse_cast_expression()
|
||||
return ASTCastExpr(typ, expr)
|
||||
except DefinitionError as exCast:
|
||||
except DefinitionError as ex_cast:
|
||||
self.pos = pos
|
||||
try:
|
||||
return self._parse_unary_expression()
|
||||
except DefinitionError as exUnary:
|
||||
except DefinitionError as ex_unary:
|
||||
errs = []
|
||||
errs.append((exCast, "If type cast expression"))
|
||||
errs.append((exUnary, "If unary expression"))
|
||||
errs.append((ex_cast, "If type cast expression"))
|
||||
errs.append((ex_unary, "If unary expression"))
|
||||
raise self._make_multi_error(errs,
|
||||
"Error in cast expression.") from exUnary
|
||||
"Error in cast expression.") from ex_unary
|
||||
else:
|
||||
return self._parse_unary_expression()
|
||||
|
||||
@ -350,21 +350,21 @@ class DefinitionParser(BaseParser):
|
||||
# additive = multiplicative +, -
|
||||
# multiplicative = pm *, /, %
|
||||
# pm = cast .*, ->*
|
||||
def _parse_bin_op_expr(self: DefinitionParser, opId: int) -> ASTExpression:
|
||||
if opId + 1 == len(_expression_bin_ops):
|
||||
def _parse_bin_op_expr(self: DefinitionParser, op_id: int) -> ASTExpression:
|
||||
if op_id + 1 == len(_expression_bin_ops):
|
||||
def parser() -> ASTExpression:
|
||||
return self._parse_cast_expression()
|
||||
else:
|
||||
def parser() -> ASTExpression:
|
||||
return _parse_bin_op_expr(self, opId + 1)
|
||||
return _parse_bin_op_expr(self, op_id + 1)
|
||||
exprs = []
|
||||
ops = []
|
||||
exprs.append(parser())
|
||||
while True:
|
||||
self.skip_ws()
|
||||
pos = self.pos
|
||||
oneMore = False
|
||||
for op in _expression_bin_ops[opId]:
|
||||
one_more = False
|
||||
for op in _expression_bin_ops[op_id]:
|
||||
if op[0] in 'abcnox':
|
||||
if not self.skip_word(op):
|
||||
continue
|
||||
@ -380,16 +380,16 @@ class DefinitionParser(BaseParser):
|
||||
expr = parser()
|
||||
exprs.append(expr)
|
||||
ops.append(op)
|
||||
oneMore = True
|
||||
one_more = True
|
||||
break
|
||||
except DefinitionError:
|
||||
self.pos = pos
|
||||
if not oneMore:
|
||||
if not one_more:
|
||||
break
|
||||
return ASTBinOpExpr(exprs, ops) # type: ignore[return-value]
|
||||
return _parse_bin_op_expr(self, 0)
|
||||
|
||||
def _parse_conditional_expression_tail(self, orExprHead: Any) -> ASTExpression | None:
|
||||
def _parse_conditional_expression_tail(self, or_expr_head: Any) -> ASTExpression | None:
|
||||
# -> "?" expression ":" assignment-expression
|
||||
return None
|
||||
|
||||
@ -402,11 +402,11 @@ class DefinitionParser(BaseParser):
|
||||
# | logical-or-expression assignment-operator initializer-clause
|
||||
exprs = []
|
||||
ops = []
|
||||
orExpr = self._parse_logical_or_expression()
|
||||
exprs.append(orExpr)
|
||||
or_expr = self._parse_logical_or_expression()
|
||||
exprs.append(or_expr)
|
||||
# TODO: handle ternary with _parse_conditional_expression_tail
|
||||
while True:
|
||||
oneMore = False
|
||||
one_more = False
|
||||
self.skip_ws()
|
||||
for op in _expression_assignment_ops:
|
||||
if op[0] in 'abcnox':
|
||||
@ -418,16 +418,16 @@ class DefinitionParser(BaseParser):
|
||||
expr = self._parse_logical_or_expression()
|
||||
exprs.append(expr)
|
||||
ops.append(op)
|
||||
oneMore = True
|
||||
if not oneMore:
|
||||
one_more = True
|
||||
if not one_more:
|
||||
break
|
||||
return ASTAssignmentExpr(exprs, ops)
|
||||
|
||||
def _parse_constant_expression(self) -> ASTExpression:
|
||||
# -> conditional-expression
|
||||
orExpr = self._parse_logical_or_expression()
|
||||
or_expr = self._parse_logical_or_expression()
|
||||
# TODO: use _parse_conditional_expression_tail
|
||||
return orExpr
|
||||
return or_expr
|
||||
|
||||
def _parse_expression(self) -> ASTExpression:
|
||||
# -> assignment-expression
|
||||
@ -443,7 +443,7 @@ class DefinitionParser(BaseParser):
|
||||
# 'end' should be a list of characters which ends the expression.
|
||||
|
||||
# first try to use the provided parser
|
||||
prevPos = self.pos
|
||||
prev_pos = self.pos
|
||||
try:
|
||||
return parser()
|
||||
except DefinitionError as e:
|
||||
@ -453,11 +453,11 @@ class DefinitionParser(BaseParser):
|
||||
raise
|
||||
self.warn("Parsing of expression failed. Using fallback parser."
|
||||
" Error was:\n%s" % e)
|
||||
self.pos = prevPos
|
||||
self.pos = prev_pos
|
||||
# and then the fallback scanning
|
||||
assert end is not None
|
||||
self.skip_ws()
|
||||
startPos = self.pos
|
||||
start_pos = self.pos
|
||||
if self.match(_string_re):
|
||||
value = self.matched_text
|
||||
else:
|
||||
@ -474,8 +474,8 @@ class DefinitionParser(BaseParser):
|
||||
self.pos += 1
|
||||
if len(end) > 0 and self.eof:
|
||||
self.fail("Could not find end of expression starting at %d."
|
||||
% startPos)
|
||||
value = self.definition[startPos:self.pos].strip()
|
||||
% start_pos)
|
||||
value = self.definition[start_pos:self.pos].strip()
|
||||
return ASTFallbackExpr(value.strip())
|
||||
|
||||
def _parse_nested_name(self) -> ASTNestedName:
|
||||
@ -549,13 +549,13 @@ class DefinitionParser(BaseParser):
|
||||
prefix = k
|
||||
break
|
||||
|
||||
nestedName = self._parse_nested_name()
|
||||
return ASTTrailingTypeSpecName(prefix, nestedName)
|
||||
nested_name = self._parse_nested_name()
|
||||
return ASTTrailingTypeSpecName(prefix, nested_name)
|
||||
|
||||
def _parse_parameters(self, paramMode: str) -> ASTParameters | None:
|
||||
def _parse_parameters(self, param_mode: str) -> ASTParameters | None:
|
||||
self.skip_ws()
|
||||
if not self.skip_string('('):
|
||||
if paramMode == 'function':
|
||||
if param_mode == 'function':
|
||||
self.fail('Expecting "(" in parameters.')
|
||||
else:
|
||||
return None
|
||||
@ -592,7 +592,7 @@ class DefinitionParser(BaseParser):
|
||||
) -> ASTDeclSpecsSimple:
|
||||
"""Just parse the simple ones."""
|
||||
storage = None
|
||||
threadLocal = None
|
||||
thread_local = None
|
||||
inline = None
|
||||
restrict = None
|
||||
volatile = None
|
||||
@ -615,12 +615,12 @@ class DefinitionParser(BaseParser):
|
||||
if self.skip_word('extern'):
|
||||
storage = 'extern'
|
||||
continue
|
||||
if outer == 'member' and not threadLocal:
|
||||
if outer == 'member' and not thread_local:
|
||||
if self.skip_word('thread_local'):
|
||||
threadLocal = 'thread_local'
|
||||
thread_local = 'thread_local'
|
||||
continue
|
||||
if self.skip_word('_Thread_local'):
|
||||
threadLocal = '_Thread_local'
|
||||
thread_local = '_Thread_local'
|
||||
continue
|
||||
if outer == 'function' and not inline:
|
||||
inline = self.skip_word('inline')
|
||||
@ -644,25 +644,25 @@ class DefinitionParser(BaseParser):
|
||||
attrs.append(attr)
|
||||
continue
|
||||
break
|
||||
return ASTDeclSpecsSimple(storage, threadLocal, inline,
|
||||
return ASTDeclSpecsSimple(storage, thread_local, inline,
|
||||
restrict, volatile, const, ASTAttributeList(attrs))
|
||||
|
||||
def _parse_decl_specs(self, outer: str | None, typed: bool = True) -> ASTDeclSpecs:
|
||||
if outer:
|
||||
if outer not in {'type', 'member', 'function'}:
|
||||
raise Exception('Internal error, unknown outer "%s".' % outer)
|
||||
leftSpecs = self._parse_decl_specs_simple(outer, typed)
|
||||
rightSpecs = None
|
||||
left_specs = self._parse_decl_specs_simple(outer, typed)
|
||||
right_specs = None
|
||||
|
||||
if typed:
|
||||
trailing = self._parse_trailing_type_spec()
|
||||
rightSpecs = self._parse_decl_specs_simple(outer, typed)
|
||||
right_specs = self._parse_decl_specs_simple(outer, typed)
|
||||
else:
|
||||
trailing = None
|
||||
return ASTDeclSpecs(outer, leftSpecs, rightSpecs, trailing)
|
||||
return ASTDeclSpecs(outer, left_specs, right_specs, trailing)
|
||||
|
||||
def _parse_declarator_name_suffix(
|
||||
self, named: bool | str, paramMode: str, typed: bool,
|
||||
self, named: bool | str, param_mode: str, typed: bool,
|
||||
) -> ASTDeclarator:
|
||||
assert named in {True, False, 'single'}
|
||||
# now we should parse the name, and then suffixes
|
||||
@ -680,14 +680,14 @@ class DefinitionParser(BaseParser):
|
||||
self.fail(msg % (self.matched_text,
|
||||
str(self.config.c_extra_keywords)))
|
||||
identifier = ASTIdentifier(self.matched_text)
|
||||
declId = ASTNestedName([identifier], rooted=False)
|
||||
decl_id = ASTNestedName([identifier], rooted=False)
|
||||
else:
|
||||
declId = None
|
||||
decl_id = None
|
||||
elif named:
|
||||
declId = self._parse_nested_name()
|
||||
decl_id = self._parse_nested_name()
|
||||
else:
|
||||
declId = None
|
||||
arrayOps = []
|
||||
decl_id = None
|
||||
array_ops = []
|
||||
while 1:
|
||||
self.skip_ws()
|
||||
if typed and self.skip_string('['):
|
||||
@ -730,27 +730,27 @@ class DefinitionParser(BaseParser):
|
||||
self.skip_ws()
|
||||
if not self.skip_string(']'):
|
||||
self.fail("Expected ']' in end of array operator.")
|
||||
arrayOps.append(ASTArray(static, const, volatile, restrict, vla, size))
|
||||
array_ops.append(ASTArray(static, const, volatile, restrict, vla, size))
|
||||
else:
|
||||
break
|
||||
param = self._parse_parameters(paramMode)
|
||||
if param is None and len(arrayOps) == 0:
|
||||
param = self._parse_parameters(param_mode)
|
||||
if param is None and len(array_ops) == 0:
|
||||
# perhaps a bit-field
|
||||
if named and paramMode == 'type' and typed:
|
||||
if named and param_mode == 'type' and typed:
|
||||
self.skip_ws()
|
||||
if self.skip_string(':'):
|
||||
size = self._parse_constant_expression()
|
||||
return ASTDeclaratorNameBitField(declId=declId, size=size)
|
||||
return ASTDeclaratorNameParam(declId=declId, arrayOps=arrayOps,
|
||||
return ASTDeclaratorNameBitField(declId=decl_id, size=size)
|
||||
return ASTDeclaratorNameParam(declId=decl_id, arrayOps=array_ops,
|
||||
param=param)
|
||||
|
||||
def _parse_declarator(self, named: bool | str, paramMode: str,
|
||||
def _parse_declarator(self, named: bool | str, param_mode: str,
|
||||
typed: bool = True) -> ASTDeclarator:
|
||||
# 'typed' here means 'parse return type stuff'
|
||||
if paramMode not in {'type', 'function'}:
|
||||
if param_mode not in {'type', 'function'}:
|
||||
raise Exception(
|
||||
"Internal error, unknown paramMode '%s'." % paramMode)
|
||||
prevErrors = []
|
||||
"Internal error, unknown param_mode '%s'." % param_mode)
|
||||
prev_errors = []
|
||||
self.skip_ws()
|
||||
if typed and self.skip_string('*'):
|
||||
self.skip_ws()
|
||||
@ -776,7 +776,7 @@ class DefinitionParser(BaseParser):
|
||||
attrs.append(attr)
|
||||
continue
|
||||
break
|
||||
next = self._parse_declarator(named, paramMode, typed)
|
||||
next = self._parse_declarator(named, param_mode, typed)
|
||||
return ASTDeclaratorPtr(next=next,
|
||||
restrict=restrict, volatile=volatile, const=const,
|
||||
attrs=ASTAttributeList(attrs))
|
||||
@ -786,14 +786,14 @@ class DefinitionParser(BaseParser):
|
||||
pos = self.pos
|
||||
try:
|
||||
# assume this is params
|
||||
res = self._parse_declarator_name_suffix(named, paramMode,
|
||||
res = self._parse_declarator_name_suffix(named, param_mode,
|
||||
typed)
|
||||
return res
|
||||
except DefinitionError as exParamQual:
|
||||
except DefinitionError as ex_param_qual:
|
||||
msg = "If declarator-id with parameters"
|
||||
if paramMode == 'function':
|
||||
if param_mode == 'function':
|
||||
msg += " (e.g., 'void f(int arg)')"
|
||||
prevErrors.append((exParamQual, msg))
|
||||
prev_errors.append((ex_param_qual, msg))
|
||||
self.pos = pos
|
||||
try:
|
||||
assert self.current_char == '('
|
||||
@ -801,49 +801,49 @@ class DefinitionParser(BaseParser):
|
||||
# TODO: hmm, if there is a name, it must be in inner, right?
|
||||
# TODO: hmm, if there must be parameters, they must b
|
||||
# inside, right?
|
||||
inner = self._parse_declarator(named, paramMode, typed)
|
||||
inner = self._parse_declarator(named, param_mode, typed)
|
||||
if not self.skip_string(')'):
|
||||
self.fail("Expected ')' in \"( ptr-declarator )\"")
|
||||
next = self._parse_declarator(named=False,
|
||||
paramMode="type",
|
||||
param_mode="type",
|
||||
typed=typed)
|
||||
return ASTDeclaratorParen(inner=inner, next=next)
|
||||
except DefinitionError as exNoPtrParen:
|
||||
except DefinitionError as ex_no_ptr_paren:
|
||||
self.pos = pos
|
||||
msg = "If parenthesis in noptr-declarator"
|
||||
if paramMode == 'function':
|
||||
if param_mode == 'function':
|
||||
msg += " (e.g., 'void (*f(int arg))(double)')"
|
||||
prevErrors.append((exNoPtrParen, msg))
|
||||
prev_errors.append((ex_no_ptr_paren, msg))
|
||||
header = "Error in declarator"
|
||||
raise self._make_multi_error(prevErrors, header) from exNoPtrParen
|
||||
raise self._make_multi_error(prev_errors, header) from ex_no_ptr_paren
|
||||
pos = self.pos
|
||||
try:
|
||||
return self._parse_declarator_name_suffix(named, paramMode, typed)
|
||||
return self._parse_declarator_name_suffix(named, param_mode, typed)
|
||||
except DefinitionError as e:
|
||||
self.pos = pos
|
||||
prevErrors.append((e, "If declarator-id"))
|
||||
prev_errors.append((e, "If declarator-id"))
|
||||
header = "Error in declarator or parameters"
|
||||
raise self._make_multi_error(prevErrors, header) from e
|
||||
raise self._make_multi_error(prev_errors, header) from e
|
||||
|
||||
def _parse_initializer(self, outer: str | None = None, allowFallback: bool = True,
|
||||
def _parse_initializer(self, outer: str | None = None, allow_fallback: bool = True,
|
||||
) -> ASTInitializer | None:
|
||||
self.skip_ws()
|
||||
if outer == 'member' and False: # NoQA: SIM223 # TODO
|
||||
bracedInit = self._parse_braced_init_list()
|
||||
if bracedInit is not None:
|
||||
return ASTInitializer(bracedInit, hasAssign=False)
|
||||
braced_init = self._parse_braced_init_list()
|
||||
if braced_init is not None:
|
||||
return ASTInitializer(braced_init, hasAssign=False)
|
||||
|
||||
if not self.skip_string('='):
|
||||
return None
|
||||
|
||||
bracedInit = self._parse_braced_init_list()
|
||||
if bracedInit is not None:
|
||||
return ASTInitializer(bracedInit)
|
||||
braced_init = self._parse_braced_init_list()
|
||||
if braced_init is not None:
|
||||
return ASTInitializer(braced_init)
|
||||
|
||||
if outer == 'member':
|
||||
fallbackEnd: list[str] = []
|
||||
fallback_end: list[str] = []
|
||||
elif outer is None: # function parameter
|
||||
fallbackEnd = [',', ')']
|
||||
fallback_end = [',', ')']
|
||||
else:
|
||||
self.fail("Internal error, initializer for outer '%s' not "
|
||||
"implemented." % outer)
|
||||
@ -851,7 +851,7 @@ class DefinitionParser(BaseParser):
|
||||
def parser() -> ASTExpression:
|
||||
return self._parse_assignment_expression()
|
||||
|
||||
value = self._parse_expression_fallback(fallbackEnd, parser, allow=allowFallback)
|
||||
value = self._parse_expression_fallback(fallback_end, parser, allow=allow_fallback)
|
||||
return ASTInitializer(value)
|
||||
|
||||
def _parse_type(self, named: bool | str, outer: str | None = None) -> ASTType:
|
||||
@ -866,52 +866,52 @@ class DefinitionParser(BaseParser):
|
||||
|
||||
if outer == 'type':
|
||||
# We allow type objects to just be a name.
|
||||
prevErrors = []
|
||||
startPos = self.pos
|
||||
prev_errors = []
|
||||
start_pos = self.pos
|
||||
# first try without the type
|
||||
try:
|
||||
declSpecs = self._parse_decl_specs(outer=outer, typed=False)
|
||||
decl = self._parse_declarator(named=True, paramMode=outer,
|
||||
decl_specs = self._parse_decl_specs(outer=outer, typed=False)
|
||||
decl = self._parse_declarator(named=True, param_mode=outer,
|
||||
typed=False)
|
||||
self.assert_end(allowSemicolon=True)
|
||||
except DefinitionError as exUntyped:
|
||||
except DefinitionError as ex_untyped:
|
||||
desc = "If just a name"
|
||||
prevErrors.append((exUntyped, desc))
|
||||
self.pos = startPos
|
||||
prev_errors.append((ex_untyped, desc))
|
||||
self.pos = start_pos
|
||||
try:
|
||||
declSpecs = self._parse_decl_specs(outer=outer)
|
||||
decl = self._parse_declarator(named=True, paramMode=outer)
|
||||
except DefinitionError as exTyped:
|
||||
self.pos = startPos
|
||||
decl_specs = self._parse_decl_specs(outer=outer)
|
||||
decl = self._parse_declarator(named=True, param_mode=outer)
|
||||
except DefinitionError as ex_typed:
|
||||
self.pos = start_pos
|
||||
desc = "If typedef-like declaration"
|
||||
prevErrors.append((exTyped, desc))
|
||||
prev_errors.append((ex_typed, desc))
|
||||
# Retain the else branch for easier debugging.
|
||||
# TODO: it would be nice to save the previous stacktrace
|
||||
# and output it here.
|
||||
if True:
|
||||
header = "Type must be either just a name or a "
|
||||
header += "typedef-like declaration."
|
||||
raise self._make_multi_error(prevErrors, header) from exTyped
|
||||
raise self._make_multi_error(prev_errors, header) from ex_typed
|
||||
else: # NoQA: RET506
|
||||
# For testing purposes.
|
||||
# do it again to get the proper traceback (how do you
|
||||
# reliably save a traceback when an exception is
|
||||
# constructed?)
|
||||
self.pos = startPos
|
||||
self.pos = start_pos
|
||||
typed = True
|
||||
declSpecs = self._parse_decl_specs(outer=outer, typed=typed)
|
||||
decl = self._parse_declarator(named=True, paramMode=outer,
|
||||
decl_specs = self._parse_decl_specs(outer=outer, typed=typed)
|
||||
decl = self._parse_declarator(named=True, param_mode=outer,
|
||||
typed=typed)
|
||||
elif outer == 'function':
|
||||
declSpecs = self._parse_decl_specs(outer=outer)
|
||||
decl = self._parse_declarator(named=True, paramMode=outer)
|
||||
decl_specs = self._parse_decl_specs(outer=outer)
|
||||
decl = self._parse_declarator(named=True, param_mode=outer)
|
||||
else:
|
||||
paramMode = 'type'
|
||||
param_mode = 'type'
|
||||
if outer == 'member': # i.e., member
|
||||
named = True
|
||||
declSpecs = self._parse_decl_specs(outer=outer)
|
||||
decl = self._parse_declarator(named=named, paramMode=paramMode)
|
||||
return ASTType(declSpecs, decl)
|
||||
decl_specs = self._parse_decl_specs(outer=outer)
|
||||
decl = self._parse_declarator(named=named, param_mode=param_mode)
|
||||
return ASTType(decl_specs, decl)
|
||||
|
||||
def _parse_type_with_init(self, named: bool | str, outer: str | None) -> ASTTypeWithInit:
|
||||
if outer:
|
||||
@ -982,43 +982,45 @@ class DefinitionParser(BaseParser):
|
||||
def parser() -> ASTExpression:
|
||||
return self._parse_constant_expression()
|
||||
|
||||
initVal = self._parse_expression_fallback([], parser)
|
||||
init = ASTInitializer(initVal)
|
||||
init_val = self._parse_expression_fallback([], parser)
|
||||
init = ASTInitializer(init_val)
|
||||
return ASTEnumerator(name, init, attrs)
|
||||
|
||||
def parse_declaration(self, objectType: str, directiveType: str) -> ASTDeclaration:
|
||||
if objectType not in {'function', 'member',
|
||||
object_type = objectType
|
||||
directive_type = directiveType
|
||||
if object_type not in {'function', 'member',
|
||||
'macro', 'struct', 'union', 'enum', 'enumerator', 'type'}:
|
||||
raise Exception('Internal error, unknown objectType "%s".' % objectType)
|
||||
if directiveType not in {'function', 'member', 'var',
|
||||
raise Exception('Internal error, unknown objectType "%s".' % object_type)
|
||||
if directive_type not in {'function', 'member', 'var',
|
||||
'macro', 'struct', 'union', 'enum', 'enumerator', 'type'}:
|
||||
raise Exception('Internal error, unknown directiveType "%s".' % directiveType)
|
||||
raise Exception('Internal error, unknown directiveType "%s".' % directive_type)
|
||||
|
||||
declaration: DeclarationType | None = None
|
||||
if objectType == 'member':
|
||||
if object_type == 'member':
|
||||
declaration = self._parse_type_with_init(named=True, outer='member')
|
||||
elif objectType == 'function':
|
||||
elif object_type == 'function':
|
||||
declaration = self._parse_type(named=True, outer='function')
|
||||
elif objectType == 'macro':
|
||||
elif object_type == 'macro':
|
||||
declaration = self._parse_macro()
|
||||
elif objectType == 'struct':
|
||||
elif object_type == 'struct':
|
||||
declaration = self._parse_struct()
|
||||
elif objectType == 'union':
|
||||
elif object_type == 'union':
|
||||
declaration = self._parse_union()
|
||||
elif objectType == 'enum':
|
||||
elif object_type == 'enum':
|
||||
declaration = self._parse_enum()
|
||||
elif objectType == 'enumerator':
|
||||
elif object_type == 'enumerator':
|
||||
declaration = self._parse_enumerator()
|
||||
elif objectType == 'type':
|
||||
elif object_type == 'type':
|
||||
declaration = self._parse_type(named=True, outer='type')
|
||||
else:
|
||||
raise AssertionError
|
||||
if objectType != 'macro':
|
||||
if object_type != 'macro':
|
||||
self.skip_ws()
|
||||
semicolon = self.skip_string(';')
|
||||
else:
|
||||
semicolon = False
|
||||
return ASTDeclaration(objectType, directiveType, declaration, semicolon)
|
||||
return ASTDeclaration(object_type, directive_type, declaration, semicolon)
|
||||
|
||||
def parse_namespace_object(self) -> ASTNestedName:
|
||||
return self._parse_nested_name()
|
||||
@ -1038,16 +1040,16 @@ class DefinitionParser(BaseParser):
|
||||
res = self._parse_expression()
|
||||
self.skip_ws()
|
||||
self.assert_end()
|
||||
except DefinitionError as exExpr:
|
||||
except DefinitionError as ex_expr:
|
||||
self.pos = pos
|
||||
try:
|
||||
res = self._parse_type(False)
|
||||
self.skip_ws()
|
||||
self.assert_end()
|
||||
except DefinitionError as exType:
|
||||
except DefinitionError as ex_type:
|
||||
header = "Error when parsing (type) expression."
|
||||
errs = []
|
||||
errs.append((exExpr, "If expression"))
|
||||
errs.append((exType, "If type"))
|
||||
raise self._make_multi_error(errs, header) from exType
|
||||
errs.append((ex_expr, "If expression"))
|
||||
errs.append((ex_type, "If type"))
|
||||
raise self._make_multi_error(errs, header) from ex_type
|
||||
return res
|
||||
|
||||
Loading…
Reference in New Issue
Block a user