338 lines
11 KiB
Plaintext
338 lines
11 KiB
Plaintext
import t, c
|
|
from stdint import *
|
|
import memhub
|
|
import string
|
|
from .base import (
|
|
AST, ASTKind,
|
|
_init_ast, _copy_str, _set_parent_list,
|
|
_emit, _emit_str, _emit_int, _dump_list,
|
|
)
|
|
|
|
|
|
# ============================================================
|
|
# ExceptHandler Node
|
|
# ============================================================
|
|
|
|
class ExceptHandler(AST):
|
|
"""ExceptHandler(type: AST, name: str)"""
|
|
type: rowptr[AST]
|
|
name: str
|
|
|
|
def __new__(self, pool: rowptr[memhub.MemManager],
|
|
type: rowptr[AST], name: str):
|
|
ptr: rowptr[ExceptHandler] = pool.alloc(ExceptHandler.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, ExceptHandler.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rowptr[memhub.MemManager],
|
|
type: rowptr[AST], name: str):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.type = type
|
|
self.name = _copy_str(pool, name)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.ExceptHandler
|
|
|
|
def type_name(self) -> str:
|
|
return "ExceptHandler"
|
|
|
|
def dump(self, buf: bytes, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "ExceptHandler(type=")
|
|
if self.type is not None:
|
|
pos = self.type.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", name='")
|
|
pos = _emit_str(buf, size, pos, self.name)
|
|
pos = _emit(buf, size, pos, "', body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Arguments Node
|
|
# ============================================================
|
|
|
|
class Arguments(AST):
|
|
"""Arguments(args: list[AST | CPtr], vararg: AST, kwarg: AST,
|
|
defaults: list[AST | CPtr], kw_defaults: list[AST | CPtr])"""
|
|
args: rowptr[list[rowptr[AST]]]
|
|
vararg: rowptr[AST]
|
|
kwarg: rowptr[AST]
|
|
defaults: rowptr[list[rowptr[AST]]]
|
|
kw_defaults: rowptr[list[rowptr[AST]]]
|
|
|
|
def __new__(self, pool: rowptr[memhub.MemManager],
|
|
args: rowptr[list[rowptr[AST]]],
|
|
vararg: rowptr[AST], kwarg: rowptr[AST],
|
|
defaults: rowptr[list[rowptr[AST]]],
|
|
kw_defaults: rowptr[list[rowptr[AST]]]):
|
|
ptr: rowptr[Arguments] = pool.alloc(Arguments.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, Arguments.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rowptr[memhub.MemManager],
|
|
args: rowptr[list[rowptr[AST]]],
|
|
vararg: rowptr[AST], kwarg: rowptr[AST],
|
|
defaults: rowptr[list[rowptr[AST]]],
|
|
kw_defaults: rowptr[list[rowptr[AST]]]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.args = args
|
|
self.vararg = vararg
|
|
self.kwarg = kwarg
|
|
self.defaults = defaults
|
|
self.kw_defaults = kw_defaults
|
|
_set_parent_list(args, self)
|
|
_set_parent_list(defaults, self)
|
|
_set_parent_list(kw_defaults, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Arguments
|
|
|
|
def type_name(self) -> str:
|
|
return "Arguments"
|
|
|
|
def dump(self, buf: bytes, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "Arguments(args=")
|
|
pos = _dump_list(self.args, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", vararg=")
|
|
if self.vararg is not None:
|
|
pos = self.vararg.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", kwarg=")
|
|
if self.kwarg is not None:
|
|
pos = self.kwarg.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", defaults=")
|
|
pos = _dump_list(self.defaults, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", kw_defaults=")
|
|
pos = _dump_list(self.kw_defaults, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Arg Node
|
|
# ============================================================
|
|
|
|
class Arg(AST):
|
|
"""Arg(arg: str, annotation: AST)"""
|
|
arg: str
|
|
annotation: rowptr[AST]
|
|
|
|
def __new__(self, pool: rowptr[memhub.MemManager],
|
|
arg: str, annotation: rowptr[AST]):
|
|
ptr: rowptr[Arg] = pool.alloc(Arg.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, Arg.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rowptr[memhub.MemManager],
|
|
arg: str, annotation: rowptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.arg = _copy_str(pool, arg)
|
|
self.annotation = annotation
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Arg
|
|
|
|
def type_name(self) -> str:
|
|
return "Arg"
|
|
|
|
def dump(self, buf: bytes, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "Arg(arg='")
|
|
pos = _emit_str(buf, size, pos, self.arg)
|
|
pos = _emit(buf, size, pos, "', annotation=")
|
|
if self.annotation is not None:
|
|
pos = self.annotation.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Keyword Node
|
|
# ============================================================
|
|
|
|
class Keyword(AST):
|
|
"""Keyword(arg: str, value: AST)"""
|
|
arg: str
|
|
value: rowptr[AST]
|
|
|
|
def __new__(self, pool: rowptr[memhub.MemManager],
|
|
arg: str, value: rowptr[AST]):
|
|
ptr: rowptr[Keyword] = pool.alloc(Keyword.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, Keyword.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rowptr[memhub.MemManager],
|
|
arg: str, value: rowptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.arg = _copy_str(pool, arg)
|
|
self.value = value
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Keyword
|
|
|
|
def type_name(self) -> str:
|
|
return "Keyword"
|
|
|
|
def dump(self, buf: bytes, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "Keyword(arg='")
|
|
pos = _emit_str(buf, size, pos, self.arg)
|
|
pos = _emit(buf, size, pos, "', value=")
|
|
if self.value is not None:
|
|
pos = self.value.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Alias Node
|
|
# ============================================================
|
|
|
|
class Alias(AST):
|
|
"""Alias(name: str, asname: str)"""
|
|
name: str
|
|
asname: str
|
|
|
|
def __new__(self, pool: rowptr[memhub.MemManager],
|
|
name: str, asname: str):
|
|
ptr: rowptr[Alias] = pool.alloc(Alias.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, Alias.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rowptr[memhub.MemManager],
|
|
name: str, asname: str):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.name = _copy_str(pool, name)
|
|
self.asname = _copy_str(pool, asname)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Alias
|
|
|
|
def type_name(self) -> str:
|
|
return "Alias"
|
|
|
|
def dump(self, buf: bytes, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "Alias(name='")
|
|
pos = _emit_str(buf, size, pos, self.name)
|
|
pos = _emit(buf, size, pos, "', asname='")
|
|
pos = _emit_str(buf, size, pos, self.asname)
|
|
pos = _emit(buf, size, pos, "')")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# WithItem Node
|
|
# ============================================================
|
|
|
|
class WithItem(AST):
|
|
"""WithItem(context_expr: AST, optional_vars: AST)"""
|
|
context_expr: rowptr[AST]
|
|
optional_vars: rowptr[AST]
|
|
|
|
def __new__(self, pool: rowptr[memhub.MemManager],
|
|
context_expr: rowptr[AST], optional_vars: rowptr[AST]):
|
|
ptr: rowptr[WithItem] = pool.alloc(WithItem.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, WithItem.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rowptr[memhub.MemManager],
|
|
context_expr: rowptr[AST], optional_vars: rowptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.context_expr = context_expr
|
|
self.optional_vars = optional_vars
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.WithItem
|
|
|
|
def type_name(self) -> str:
|
|
return "WithItem"
|
|
|
|
def dump(self, buf: bytes, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "WithItem(context_expr=")
|
|
if self.context_expr is not None:
|
|
pos = self.context_expr.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", optional_vars=")
|
|
if self.optional_vars is not None:
|
|
pos = self.optional_vars.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Comprehension Node
|
|
# ============================================================
|
|
|
|
class Comprehension(AST):
|
|
"""Comprehension(target: AST, iter: AST, ifs: list[AST | CPtr], is_async: CInt)"""
|
|
target: rowptr[AST]
|
|
iter: rowptr[AST]
|
|
ifs: rowptr[list[rowptr[AST]]]
|
|
is_async: int
|
|
|
|
def __new__(self, pool: rowptr[memhub.MemManager],
|
|
target: rowptr[AST], iter: rowptr[AST],
|
|
ifs: rowptr[list[rowptr[AST]]], is_async: int):
|
|
ptr: rowptr[Comprehension] = pool.alloc(Comprehension.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, Comprehension.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rowptr[memhub.MemManager],
|
|
target: rowptr[AST], iter: rowptr[AST],
|
|
ifs: rowptr[list[rowptr[AST]]], is_async: int):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.target = target
|
|
self.iter = iter
|
|
self.ifs = ifs
|
|
self.is_async = is_async
|
|
_set_parent_list(ifs, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Comprehension
|
|
|
|
def type_name(self) -> str:
|
|
return "Comprehension"
|
|
|
|
def dump(self, buf: bytes, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "Comprehension(target=")
|
|
if self.target is not None:
|
|
pos = self.target.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", iter=")
|
|
if self.iter is not None:
|
|
pos = self.iter.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", ifs=")
|
|
pos = _dump_list(self.ifs, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", is_async=")
|
|
pos = _emit_int(buf, size, pos, int64(self.is_async))
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|