def __init__(self, sym: ast.Identifier, arg_cnt: int) -> None:
super().__init__(
0, ast.Qualifier.NONE,
ast.TemplatedIdentifier(0, '@func', [
ast.FunctionType(
CAnyType.make_symbol(),
[ast.VariableDeclaration(CAnyType.make_symbol(), None)] *
arg_cnt)
]), sym)
self.declaration_type = ast.DeclarationType.C
def type_FUNCTIONPROTO(typ: Type) -> ast.Node:
args: List[ast.VariableDeclaration] = []
for a in typ.argument_types():
res: ast.Node = type_to_ehlit(a)
assert isinstance(res, ast.Symbol)
args.append(ast.VariableDeclaration(res, None))
ret_type: ast.Node = type_to_ehlit(typ.get_result())
assert isinstance(ret_type, ast.Symbol)
return ast.TemplatedIdentifier(0, '@func',
[ast.FunctionType(ret_type, args)])
def parse_FUNCTION_DECL(cursor: Cursor) -> ast.Node:
args: List[ast.VariableDeclaration] = []
for c in cursor.get_children():
if c.kind == CursorKind.PARM_DECL:
typ = type_to_ehlit(c.type)
assert isinstance(typ, ast.Symbol)
args.append(
ast.VariableDeclaration(typ, ast.Identifier(0, c.spelling)))
ret_type = type_to_ehlit(cursor.type.get_result())
assert isinstance(ret_type, ast.Symbol)
return ast.Function(
0, ast.Qualifier.NONE,
ast.TemplatedIdentifier(0, '@func', [
ast.FunctionType(ret_type, args,
cursor.type.is_function_variadic())
]), ast.Identifier(0, cursor.spelling))
def visit_function_prototype(self, node: ParseTreeNode,
children: Tuple[ast.Symbol, ast.Identifier,
Tuple[List[ast.VariableDeclaration],
Optional[ast.Symbol]]]
) -> Tuple[ast.TemplatedIdentifier, ast.Identifier]:
args: List[ast.VariableDeclaration]
variadic_type: Optional[ast.Symbol]
if len(children) == 3:
args, variadic_type = children[2]
else:
args = []
variadic_type = None
return ast.TemplatedIdentifier(
node.position,
'@func',
[ast.FunctionType(children[0], args, variadic_type is not None, variadic_type)]
), children[1]
def visit_destructor(self, node: ParseTreeNode, children: Tuple[str, ast.UnparsedContents]
) -> ast.Dtor:
qualifiers: ast.Qualifier = ast.Qualifier.NONE
i: int = 0
while isinstance(children[i], str):
if children[i] == 'inline':
qualifiers |= ast.Qualifier.INLINE
elif children[i] == 'priv':
qualifiers |= ast.Qualifier.PRIVATE
elif children[i] == 'dtor':
break
i += 1
i += 1
body = None
if len(children) > i:
body = children[i]
typ = ast.TemplatedIdentifier(node.position, '@func', [ast.FunctionType(
ast.CompoundIdentifier([ast.Identifier(node.position, '@void')]),
[]
)])
assert(body is None or isinstance(body, ast.UnparsedContents))
return ast.Dtor(node.position, qualifiers, typ, body)
def visit_constructor(self, node: ParseTreeNode,
children: Tuple[str, Tuple[List[ast.VariableDeclaration],
Optional[ast.Symbol]],
ast.UnparsedContents]
) -> ast.Ctor:
qualifiers: ast.Qualifier = ast.Qualifier.NONE
i: int = 0
while isinstance(children[i], str):
if children[i] == 'inline':
qualifiers |= ast.Qualifier.INLINE
elif children[i] == 'priv':
qualifiers |= ast.Qualifier.PRIVATE
elif children[i] == 'ctor':
break
i += 1
i += 1
args: List[ast.VariableDeclaration]
variadic_type: Optional[ast.Symbol]
body = None
if len(children) < i or isinstance(children[i], ast.UnparsedContents):
args = []
variadic_type = None
if len(children) > i:
body = children[i]
else:
child_i = children[i]
assert(isinstance(child_i, tuple))
args, variadic_type = child_i
if len(children) > i + 1:
body = children[i + 1]
typ = ast.TemplatedIdentifier(node.position, '@func', [ast.FunctionType(
ast.CompoundIdentifier([ast.Identifier(node.position, '@void')]),
args,
variadic_type is not None,
variadic_type
)])
assert(body is None or isinstance(body, ast.UnparsedContents))
return ast.Ctor(node.position, qualifiers, typ, body)
def visit_function_type(self, node: ParseTreeNode,
children: Tuple[StrMatch, ast.Symbol, Tuple[ast.Symbol, ...]]
) -> ast.TemplatedIdentifier:
args: List[ast.VariableDeclaration] = []
variadic: bool = False
variadic_type: Optional[ast.Symbol] = ast.CompoundIdentifier([ast.Identifier(0, '@any')])
if len(children) > 2:
i = 0
while i < len(children[2]):
arg = children[2][i]
if arg == '...':
variadic = True
elif len(children[2]) > i + 1 and children[2][i + 1] == '...':
assert isinstance(arg, ast.Symbol)
variadic_type = arg
variadic = True
else:
args.append(ast.VariableDeclaration(arg, None))
i += 2
return ast.TemplatedIdentifier(
node.position,
'@func',
[ast.FunctionType(children[1], args, variadic, variadic_type)]
)