TermiNexus
e71daeea0e
按规范「注释只讲解作用，不掺杂历史原因，尽量英文」：把 includes 下 75 个 .vp 的中文 # 注释与三引号 docstring 改写为英文，每个注释块压到 2 行以内。 保留要点：作用、约束、危险警告（不得/必须/注意）、ABI 与类型约定（如 BYTEPTR | t.CPtr = i8** 的跨模块坍缩坑）、位宽/长度约定、fail-fast 要求、内存与句柄所有权。 未动：文件头注释（规范豁免，仍是中文）、运行时中文字符串常量（printf / fatal_error / MlirFail 等用户可见消息，属代码字面量）。 验证：独立脚本比对 HEAD 与工作区的代码骨架（剥离 # 注释与三引号 docstring 后的非空行）——75 个文件逐字节一致；行尾 CRLF/LF 未被改动；全文剩余中文仅 547 行头注释、0 条行尾注释。bootstrap 三重重编 SUCCESS；全量 77/77 顺序回归通过。
1138 lines
38 KiB
Plaintext
1138 lines
38 KiB
Plaintext
import t, c
|
|
from stdint import *
|
|
import memhub
|
|
import string
|
|
from .base import (
|
|
AST, Stmt, ASTKind, ASTCtx, OpKind,
|
|
_init_ast, _copy_str, _set_parent_list,
|
|
_emit, _emit_str, _emit_int, _dump_list,
|
|
FLAG_IS_ASYNC, _op_name
|
|
)
|
|
|
|
|
|
# ============================================================
|
|
# Module Node
|
|
# ============================================================
|
|
virtual class Module(AST):
|
|
"""Module(children: list[rawptr[AST]])"""
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager]):
|
|
ptr: rawptr[Module] = pool.alloc(Module.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Module.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager]):
|
|
_init_ast(self, pool, 0, 0)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Module
|
|
|
|
def type_name(self) -> str:
|
|
return "Module"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Module(body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Assign Node
|
|
# ============================================================
|
|
|
|
class Assign(Stmt):
|
|
"""Assign(targets: list[rawptr[AST]], value: AST)"""
|
|
targets: rawptr[list[rawptr[AST]]]
|
|
value: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
targets: rawptr[list[rawptr[AST]]], value: rawptr[AST]):
|
|
ptr: rawptr[Assign] = pool.alloc(Assign.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Assign.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
targets: rawptr[list[rawptr[AST]]], value: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.targets = targets
|
|
self.value = value
|
|
_set_parent_list(targets, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Assign
|
|
|
|
def type_name(self) -> str:
|
|
return "Assign"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Assign(targets=")
|
|
pos = _dump_list(self.targets, buf, size, pos)
|
|
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
|
|
|
|
|
|
# ============================================================
|
|
# If Node
|
|
# ============================================================
|
|
|
|
class If(Stmt):
|
|
"""If(test: AST, orelse: list[rawptr[AST]])"""
|
|
test: rawptr[AST]
|
|
orelse: rawptr[list[rawptr[AST]]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
test: rawptr[AST],
|
|
orelse: rawptr[list[rawptr[AST]]]):
|
|
ptr: rawptr[If] = pool.alloc(If.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, If.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
test: rawptr[AST],
|
|
orelse: rawptr[list[rawptr[AST]]]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.test = test
|
|
self.orelse = orelse
|
|
_set_parent_list(orelse, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.If
|
|
|
|
def type_name(self) -> str:
|
|
return "If"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "If(test=")
|
|
if self.test is not None:
|
|
pos = self.test.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", orelse=")
|
|
pos = _dump_list(self.orelse, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# For Node
|
|
# ============================================================
|
|
|
|
class For(Stmt):
|
|
"""For(target: AST, iter: AST, orelse: list[rawptr[AST]], is_async: CInt)"""
|
|
target: rawptr[AST]
|
|
iter: rawptr[AST]
|
|
orelse: rawptr[list[rawptr[AST]]]
|
|
flags: int
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
target: rawptr[AST], iter: rawptr[AST],
|
|
orelse: rawptr[list[rawptr[AST]]],
|
|
is_async: int):
|
|
ptr: rawptr[For] = pool.alloc(For.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, For.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
target: rawptr[AST], iter: rawptr[AST],
|
|
orelse: rawptr[list[rawptr[AST]]],
|
|
is_async: int):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.target = target
|
|
self.iter = iter
|
|
self.orelse = orelse
|
|
if is_async:
|
|
self.flags = FLAG_IS_ASYNC
|
|
else:
|
|
self.flags = 0
|
|
_set_parent_list(orelse, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.For
|
|
|
|
def type_name(self) -> str:
|
|
return "For"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "For(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, ", body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# While Node
|
|
# ============================================================
|
|
|
|
class While(Stmt):
|
|
"""While(test: AST, orelse: list[rawptr[AST]])"""
|
|
test: rawptr[AST]
|
|
orelse: rawptr[list[rawptr[AST]]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
test: rawptr[AST],
|
|
orelse: rawptr[list[rawptr[AST]]]):
|
|
ptr: rawptr[While] = pool.alloc(While.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, While.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
test: rawptr[AST],
|
|
orelse: rawptr[list[rawptr[AST]]]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.test = test
|
|
self.orelse = orelse
|
|
_set_parent_list(orelse, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.While
|
|
|
|
def type_name(self) -> str:
|
|
return "While"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "While(test=")
|
|
if self.test is not None:
|
|
pos = self.test.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Return Node
|
|
# ============================================================
|
|
|
|
class Return(Stmt):
|
|
"""Return(value: AST | None)"""
|
|
value: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]):
|
|
ptr: rawptr[Return] = pool.alloc(Return.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Return.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.value = value
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Return
|
|
|
|
def type_name(self) -> str:
|
|
return "Return"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Return(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
|
|
|
|
|
|
# ============================================================
|
|
# Expr Node (expression statement)
|
|
# ============================================================
|
|
|
|
class Expr(Stmt):
|
|
"""Expr(value: AST)"""
|
|
value: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]):
|
|
ptr: rawptr[Expr] = pool.alloc(Expr.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Expr.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.value = value
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Expr
|
|
|
|
def type_name(self) -> str:
|
|
return "Expr"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Expr(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
|
|
|
|
|
|
# ============================================================
|
|
# FunctionDef Node
|
|
# ============================================================
|
|
|
|
class FunctionDef(Stmt):
|
|
"""FunctionDef(name: str, args: AST,
|
|
decorator_list: list[rawptr[AST]], returns: AST, flags: CInt,
|
|
type_params: rawptr[list[str]] = None)
|
|
|
|
type_params: generic function type-parameter name list (the [T] in PEP 695 def f[T](...)),
|
|
None means a non-generic function."""
|
|
name: str
|
|
args: rawptr[AST]
|
|
decorator_list: rawptr[list[rawptr[AST]]]
|
|
returns: rawptr[AST]
|
|
flags: int
|
|
type_params: rawptr[list[str]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
name: str, args: rawptr[AST],
|
|
decorator_list: rawptr[list[rawptr[AST]]],
|
|
returns: rawptr[AST], is_async: int):
|
|
ptr: rawptr[FunctionDef] = pool.alloc(FunctionDef.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, FunctionDef.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
name: str, args: rawptr[AST],
|
|
decorator_list: rawptr[list[rawptr[AST]]],
|
|
returns: rawptr[AST], is_async: int,
|
|
type_params: rawptr[list[str]] = None):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.name = _copy_str(pool, name)
|
|
self.args = args
|
|
self.decorator_list = decorator_list
|
|
self.returns = returns
|
|
self.type_params = type_params
|
|
if is_async:
|
|
self.flags = FLAG_IS_ASYNC
|
|
else:
|
|
self.flags = 0
|
|
_set_parent_list(decorator_list, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.FunctionDef
|
|
|
|
def type_name(self) -> str:
|
|
return "FunctionDef"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "FunctionDef(name='")
|
|
pos = _emit_str(buf, size, pos, self.name)
|
|
pos = _emit(buf, size, pos, "', args=")
|
|
if self.args is not None:
|
|
pos = self.args.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", decorator_list=")
|
|
pos = _dump_list(self.decorator_list, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", returns=")
|
|
if self.returns is not None:
|
|
pos = self.returns.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Expression Node
|
|
# ============================================================
|
|
|
|
class Expression(AST):
|
|
"""Expression(body: AST)"""
|
|
body: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
body: rawptr[AST]):
|
|
ptr: rawptr[Expression] = pool.alloc(Expression.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Expression.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
body: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.body = body
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Expression
|
|
|
|
def type_name(self) -> str:
|
|
return "Expression"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Expression(body=")
|
|
if self.body is not None:
|
|
pos = self.body.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Interactive Node
|
|
# ============================================================
|
|
|
|
class Interactive(AST):
|
|
"""Interactive(body: AST)"""
|
|
body: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
body: rawptr[AST]):
|
|
ptr: rawptr[Interactive] = pool.alloc(Interactive.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Interactive.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
body: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.body = body
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Interactive
|
|
|
|
def type_name(self) -> str:
|
|
return "Interactive"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Interactive(body=")
|
|
if self.body is not None:
|
|
pos = self.body.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# FunctionType Node
|
|
# ============================================================
|
|
|
|
class FunctionType(AST):
|
|
"""FunctionType(argtypes: list[rawptr[AST]], returns: AST)"""
|
|
argtypes: rawptr[list[rawptr[AST]]]
|
|
returns: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
argtypes: rawptr[list[rawptr[AST]]],
|
|
returns: rawptr[AST]):
|
|
ptr: rawptr[FunctionType] = pool.alloc(FunctionType.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, FunctionType.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
argtypes: rawptr[list[rawptr[AST]]],
|
|
returns: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.argtypes = argtypes
|
|
self.returns = returns
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.FunctionType
|
|
|
|
def type_name(self) -> str:
|
|
return "FunctionType"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "FunctionType(argtypes=")
|
|
pos = _dump_list(self.argtypes, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", returns=")
|
|
if self.returns is not None:
|
|
pos = self.returns.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# ClassDef Node
|
|
# ============================================================
|
|
|
|
class ClassDef(Stmt):
|
|
"""ClassDef(name: str, bases: list[rawptr[AST]], keywords: list[rawptr[AST]],
|
|
decorator_list: list[rawptr[AST]], type_params: rawptr[list[str]])
|
|
|
|
type_params: generic type-parameter name list (the [T] in PEP 695 class list[T]:),
|
|
None means a non-generic class."""
|
|
name: str
|
|
bases: rawptr[list[rawptr[AST]]]
|
|
keywords: rawptr[list[rawptr[AST]]]
|
|
decorator_list: rawptr[list[rawptr[AST]]]
|
|
type_params: rawptr[list[str]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
name: str,
|
|
bases: rawptr[list[rawptr[AST]]],
|
|
keywords: rawptr[list[rawptr[AST]]],
|
|
decorator_list: rawptr[list[rawptr[AST]]],
|
|
type_params: rawptr[list[str]] = None):
|
|
ptr: rawptr[ClassDef] = pool.alloc(ClassDef.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, ClassDef.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
name: str,
|
|
bases: rawptr[list[rawptr[AST]]],
|
|
keywords: rawptr[list[rawptr[AST]]],
|
|
decorator_list: rawptr[list[rawptr[AST]]],
|
|
type_params: rawptr[list[str]] = None):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.name = _copy_str(pool, name)
|
|
self.bases = bases
|
|
self.keywords = keywords
|
|
self.decorator_list = decorator_list
|
|
self.type_params = type_params
|
|
_set_parent_list(decorator_list, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.ClassDef
|
|
|
|
def type_name(self) -> str:
|
|
return "ClassDef"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "ClassDef(name='")
|
|
pos = _emit_str(buf, size, pos, self.name)
|
|
pos = _emit(buf, size, pos, "', bases=")
|
|
pos = _dump_list(self.bases, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", keywords=")
|
|
pos = _dump_list(self.keywords, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", decorator_list=")
|
|
pos = _dump_list(self.decorator_list, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Delete Node
|
|
# ============================================================
|
|
|
|
class Delete(Stmt):
|
|
"""Delete(targets: list[rawptr[AST]])"""
|
|
targets: rawptr[list[rawptr[AST]]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
targets: rawptr[list[rawptr[AST]]]):
|
|
ptr: rawptr[Delete] = pool.alloc(Delete.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Delete.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
targets: rawptr[list[rawptr[AST]]]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.targets = targets
|
|
_set_parent_list(targets, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Delete
|
|
|
|
def type_name(self) -> str:
|
|
return "Delete"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Delete(targets=")
|
|
pos = _dump_list(self.targets, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# AugAssign Node
|
|
# ============================================================
|
|
|
|
class AugAssign(Stmt):
|
|
"""AugAssign(target: AST, op: CInt, value: AST)"""
|
|
target: rawptr[AST]
|
|
op: int
|
|
value: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
target: rawptr[AST], op: int, value: rawptr[AST]):
|
|
ptr: rawptr[AugAssign] = pool.alloc(AugAssign.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, AugAssign.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
target: rawptr[AST], op: int, value: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.target = target
|
|
self.op = op
|
|
self.value = value
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.AugAssign
|
|
|
|
def type_name(self) -> str:
|
|
return "AugAssign"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "AugAssign(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, ", op=")
|
|
pos = _emit(buf, size, pos, _op_name(self.op))
|
|
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
|
|
|
|
|
|
# ============================================================
|
|
# AnnAssign Node
|
|
# ============================================================
|
|
|
|
class AnnAssign(Stmt):
|
|
"""AnnAssign(target: AST, annotation: AST, value: AST, simple: CInt)"""
|
|
target: rawptr[AST]
|
|
annotation: rawptr[AST]
|
|
value: rawptr[AST]
|
|
simple: int
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
target: rawptr[AST], annotation: rawptr[AST],
|
|
value: rawptr[AST], simple: int):
|
|
ptr: rawptr[AnnAssign] = pool.alloc(AnnAssign.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, AnnAssign.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
target: rawptr[AST], annotation: rawptr[AST],
|
|
value: rawptr[AST], simple: int):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.target = target
|
|
self.annotation = annotation
|
|
self.value = value
|
|
self.simple = simple
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.AnnAssign
|
|
|
|
def type_name(self) -> str:
|
|
return "AnnAssign"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "AnnAssign(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, ", 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, ", 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, ", simple=")
|
|
pos = _emit_int(buf, size, pos, int64(self.simple))
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# With Node
|
|
# ============================================================
|
|
|
|
class With(Stmt):
|
|
"""With(items: list[rawptr[AST]], is_async: CInt)"""
|
|
items: rawptr[list[rawptr[AST]]]
|
|
flags: int
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
items: rawptr[list[rawptr[AST]]],
|
|
is_async: int):
|
|
ptr: rawptr[With] = pool.alloc(With.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, With.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
items: rawptr[list[rawptr[AST]]],
|
|
is_async: int):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.items = items
|
|
if is_async:
|
|
self.flags = FLAG_IS_ASYNC
|
|
else:
|
|
self.flags = 0
|
|
_set_parent_list(items, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.With
|
|
|
|
def type_name(self) -> str:
|
|
return "With"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "With(items=")
|
|
pos = _dump_list(self.items, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Raise Node
|
|
# ============================================================
|
|
|
|
class Raise(Stmt):
|
|
"""Raise(exc: AST, cause: AST)"""
|
|
exc: rawptr[AST]
|
|
cause: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
exc: rawptr[AST], cause: rawptr[AST]):
|
|
ptr: rawptr[Raise] = pool.alloc(Raise.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Raise.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
exc: rawptr[AST], cause: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.exc = exc
|
|
self.cause = cause
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Raise
|
|
|
|
def type_name(self) -> str:
|
|
return "Raise"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Raise(exc=")
|
|
if self.exc is not None:
|
|
pos = self.exc.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", cause=")
|
|
if self.cause is not None:
|
|
pos = self.cause.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Try Node
|
|
# ============================================================
|
|
|
|
class Try(Stmt):
|
|
"""Try(handlers: list[rawptr[AST]],
|
|
orelse: list[rawptr[AST]], finalbody: list[rawptr[AST]])"""
|
|
handlers: rawptr[list[rawptr[AST]]]
|
|
orelse: rawptr[list[rawptr[AST]]]
|
|
finalbody: rawptr[list[rawptr[AST]]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
handlers: rawptr[list[rawptr[AST]]],
|
|
orelse: rawptr[list[rawptr[AST]]],
|
|
finalbody: rawptr[list[rawptr[AST]]]):
|
|
ptr: rawptr[Try] = pool.alloc(Try.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Try.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
handlers: rawptr[list[rawptr[AST]]],
|
|
orelse: rawptr[list[rawptr[AST]]],
|
|
finalbody: rawptr[list[rawptr[AST]]]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.handlers = handlers
|
|
self.orelse = orelse
|
|
self.finalbody = finalbody
|
|
_set_parent_list(handlers, self)
|
|
_set_parent_list(orelse, self)
|
|
_set_parent_list(finalbody, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Try
|
|
|
|
def type_name(self) -> str:
|
|
return "Try"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Try(body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", handlers=")
|
|
pos = _dump_list(self.handlers, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", orelse=")
|
|
pos = _dump_list(self.orelse, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", finalbody=")
|
|
pos = _dump_list(self.finalbody, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Assert Node
|
|
# ============================================================
|
|
|
|
class Assert(Stmt):
|
|
"""Assert(test: AST, msg: AST)"""
|
|
test: rawptr[AST]
|
|
msg: rawptr[AST]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
test: rawptr[AST], msg: rawptr[AST]):
|
|
ptr: rawptr[Assert] = pool.alloc(Assert.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Assert.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
test: rawptr[AST], msg: rawptr[AST]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.test = test
|
|
self.msg = msg
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Assert
|
|
|
|
def type_name(self) -> str:
|
|
return "Assert"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Assert(test=")
|
|
if self.test is not None:
|
|
pos = self.test.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", msg=")
|
|
if self.msg is not None:
|
|
pos = self.msg.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Global Node
|
|
# ============================================================
|
|
|
|
class Global(Stmt):
|
|
"""Global(names: list[rawptr[AST]])"""
|
|
names: rawptr[list[rawptr[AST]]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
names: rawptr[list[rawptr[AST]]]):
|
|
ptr: rawptr[Global] = pool.alloc(Global.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Global.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
names: rawptr[list[rawptr[AST]]]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.names = names
|
|
_set_parent_list(names, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Global
|
|
|
|
def type_name(self) -> str:
|
|
return "Global"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Global(names=")
|
|
pos = _dump_list(self.names, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Nonlocal Node
|
|
# ============================================================
|
|
|
|
class Nonlocal(Stmt):
|
|
"""Nonlocal(names: list[rawptr[AST]])"""
|
|
names: rawptr[list[rawptr[AST]]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
names: rawptr[list[rawptr[AST]]]):
|
|
ptr: rawptr[Nonlocal] = pool.alloc(Nonlocal.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Nonlocal.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
names: rawptr[list[rawptr[AST]]]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.names = names
|
|
_set_parent_list(names, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Nonlocal
|
|
|
|
def type_name(self) -> str:
|
|
return "Nonlocal"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Nonlocal(names=")
|
|
pos = _dump_list(self.names, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Pass Node
|
|
# ============================================================
|
|
|
|
class Pass(Stmt):
|
|
"""Pass()"""
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager]):
|
|
ptr: rawptr[Pass] = pool.alloc(Pass.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Pass.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager]):
|
|
_init_ast(self, pool, 0, 0)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Pass
|
|
|
|
def type_name(self) -> str:
|
|
return "Pass"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Pass()")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Break Node
|
|
# ============================================================
|
|
|
|
class Break(Stmt):
|
|
"""Break()"""
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager]):
|
|
ptr: rawptr[Break] = pool.alloc(Break.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Break.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager]):
|
|
_init_ast(self, pool, 0, 0)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Break
|
|
|
|
def type_name(self) -> str:
|
|
return "Break"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Break()")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Continue Node
|
|
# ============================================================
|
|
|
|
class Continue(Stmt):
|
|
"""Continue()"""
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager]):
|
|
ptr: rawptr[Continue] = pool.alloc(Continue.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Continue.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager]):
|
|
_init_ast(self, pool, 0, 0)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Continue
|
|
|
|
def type_name(self) -> str:
|
|
return "Continue"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Continue()")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# FallThrough Node (keyword `fallthrough`, legal only inside a switch case body)
|
|
# ============================================================
|
|
|
|
class FallThrough(Stmt):
|
|
"""FallThrough() - a switch case body does not auto-break, so it falls through to the next case"""
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager]):
|
|
ptr: rawptr[FallThrough] = pool.alloc(FallThrough.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, FallThrough.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager]):
|
|
_init_ast(self, pool, 0, 0)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.FallThrough
|
|
|
|
def type_name(self) -> str:
|
|
return "FallThrough"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "FallThrough()")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Import Node
|
|
# ============================================================
|
|
|
|
class Import(Stmt):
|
|
"""Import(names: list[rawptr[AST]])"""
|
|
names: rawptr[list[rawptr[AST]]]
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
names: rawptr[list[rawptr[AST]]]):
|
|
ptr: rawptr[Import] = pool.alloc(Import.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Import.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
names: rawptr[list[rawptr[AST]]]):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.names = names
|
|
_set_parent_list(names, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Import
|
|
|
|
def type_name(self) -> str:
|
|
return "Import"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Import(names=")
|
|
pos = _dump_list(self.names, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# ImportFrom Node
|
|
# ============================================================
|
|
|
|
class ImportFrom(Stmt):
|
|
"""ImportFrom(module: str, names: list[rawptr[AST]], level: CInt)"""
|
|
module: str
|
|
names: rawptr[list[rawptr[AST]]]
|
|
level: int
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
module: str,
|
|
names: rawptr[list[rawptr[AST]]],
|
|
level: int):
|
|
ptr: rawptr[ImportFrom] = pool.alloc(ImportFrom.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, ImportFrom.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
module: str,
|
|
names: rawptr[list[rawptr[AST]]],
|
|
level: int):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.module = _copy_str(pool, module)
|
|
self.names = names
|
|
self.level = level
|
|
_set_parent_list(names, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.ImportFrom
|
|
|
|
def type_name(self) -> str:
|
|
return "ImportFrom"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "ImportFrom(module='")
|
|
pos = _emit_str(buf, size, pos, self.module)
|
|
pos = _emit(buf, size, pos, "', names=")
|
|
pos = _dump_list(self.names, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", level=")
|
|
pos = _emit_int(buf, size, pos, int64(self.level))
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# Match Node
|
|
# ============================================================
|
|
|
|
class Match(Stmt):
|
|
"""Match(subject: AST, cases: list[rawptr[AST]], is_switch: int)
|
|
|
|
is_switch=1: from `switch <expr>:` sugar (see _parse_switch), C semantics (no fall-through without
|
|
`fallthrough`). is_switch=0: real `match`, fallthrough is completely forbidden (fail-fast).
|
|
"""
|
|
subject: rawptr[AST]
|
|
cases: rawptr[list[rawptr[AST]]]
|
|
is_switch: int
|
|
|
|
def __new__(self, pool: rawptr[memhub.MemManager],
|
|
subject: rawptr[AST],
|
|
cases: rawptr[list[rawptr[AST]]],
|
|
is_switch: int):
|
|
ptr: rawptr[Match] = pool.alloc(Match.__sizeof__())
|
|
if ptr: string.memset(ptr, 0, Match.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: rawptr[memhub.MemManager],
|
|
subject: rawptr[AST],
|
|
cases: rawptr[list[rawptr[AST]]],
|
|
is_switch: int):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.subject = subject
|
|
self.cases = cases
|
|
self.is_switch = is_switch
|
|
_set_parent_list(cases, self)
|
|
|
|
def kind(self) -> int:
|
|
return ASTKind.Match
|
|
|
|
def type_name(self) -> str:
|
|
return "Match"
|
|
|
|
def dump(self, buf: str, size: sizet, pos: sizet) -> sizet:
|
|
pos = _emit(buf, size, pos, "Match(subject=")
|
|
if self.subject is not None:
|
|
pos = self.subject.dump(buf, size, pos)
|
|
else:
|
|
pos = _emit(buf, size, pos, "None")
|
|
pos = _emit(buf, size, pos, ", cases=")
|
|
pos = _dump_list(self.cases, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", is_switch=")
|
|
pos = _emit_int(buf, size, pos, int64(self.is_switch))
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|