1151 lines
37 KiB
Python
1151 lines
37 KiB
Python
import t, c
|
||
from stdint import *
|
||
import memhub
|
||
import string
|
||
from .base import (
|
||
AST, ASTKind, ASTCtx, OpKind,
|
||
_init_ast, _copy_str, _set_parent_list,
|
||
_emit, _emit_str, _emit_int, _dump_list,
|
||
FLAG_IS_ASYNC,
|
||
)
|
||
|
||
|
||
# ============================================================
|
||
# Module 节点
|
||
# ============================================================
|
||
|
||
@t.CVTable
|
||
class Module(AST):
|
||
"""Module(children: list[AST | t.CPtr])"""
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr):
|
||
ptr: Module | t.CPtr = pool.alloc(Module.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Module.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Module
|
||
|
||
def type_name(self) -> str:
|
||
return "Module"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
pos = _emit(buf, size, pos, "Module(body=")
|
||
pos = _dump_list(self.children, buf, size, pos)
|
||
pos = _emit(buf, size, pos, ")")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# Assign 节点
|
||
# ============================================================
|
||
|
||
class Assign(AST):
|
||
"""Assign(targets: list[AST | t.CPtr], value: AST)"""
|
||
targets: list[AST | t.CPtr] | t.CPtr
|
||
value: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
targets: list[AST | t.CPtr] | t.CPtr, value: AST | t.CPtr):
|
||
ptr: Assign | t.CPtr = pool.alloc(Assign.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Assign.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
targets: list[AST | t.CPtr] | t.CPtr, value: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.targets = targets
|
||
self.value = value
|
||
_set_parent_list(targets, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Assign
|
||
|
||
def type_name(self) -> str:
|
||
return "Assign"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class If(AST):
|
||
"""If(test: AST, orelse: list[AST | t.CPtr])"""
|
||
test: AST | t.CPtr
|
||
orelse: list[AST | t.CPtr] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
test: AST | t.CPtr,
|
||
orelse: list[AST | t.CPtr] | t.CPtr):
|
||
ptr: If | t.CPtr = pool.alloc(If.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, If.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
test: AST | t.CPtr,
|
||
orelse: list[AST | t.CPtr] | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.test = test
|
||
self.orelse = orelse
|
||
_set_parent_list(orelse, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.If
|
||
|
||
def type_name(self) -> str:
|
||
return "If"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class For(AST):
|
||
"""For(target: AST, iter: AST, orelse: list[AST | t.CPtr], is_async: CInt)"""
|
||
target: AST | t.CPtr
|
||
iter: AST | t.CPtr
|
||
orelse: list[AST | t.CPtr] | t.CPtr
|
||
flags: t.CInt
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
target: AST | t.CPtr, iter: AST | t.CPtr,
|
||
orelse: list[AST | t.CPtr] | t.CPtr,
|
||
is_async: t.CInt):
|
||
ptr: For | t.CPtr = pool.alloc(For.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, For.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
target: AST | t.CPtr, iter: AST | t.CPtr,
|
||
orelse: list[AST | t.CPtr] | t.CPtr,
|
||
is_async: t.CInt):
|
||
_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) -> t.CInt:
|
||
return ASTKind.For
|
||
|
||
def type_name(self) -> str:
|
||
return "For"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class While(AST):
|
||
"""While(test: AST, orelse: list[AST | t.CPtr])"""
|
||
test: AST | t.CPtr
|
||
orelse: list[AST | t.CPtr] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
test: AST | t.CPtr,
|
||
orelse: list[AST | t.CPtr] | t.CPtr):
|
||
ptr: While | t.CPtr = pool.alloc(While.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, While.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
test: AST | t.CPtr,
|
||
orelse: list[AST | t.CPtr] | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.test = test
|
||
self.orelse = orelse
|
||
_set_parent_list(orelse, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.While
|
||
|
||
def type_name(self) -> str:
|
||
return "While"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class Return(AST):
|
||
"""Return(value: AST | None)"""
|
||
value: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr):
|
||
ptr: Return | t.CPtr = pool.alloc(Return.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Return.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.value = value
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Return
|
||
|
||
def type_name(self) -> str:
|
||
return "Return"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点（表达式语句）
|
||
# ============================================================
|
||
|
||
class Expr(AST):
|
||
"""Expr(value: AST)"""
|
||
value: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr):
|
||
ptr: Expr | t.CPtr = pool.alloc(Expr.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Expr.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.value = value
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Expr
|
||
|
||
def type_name(self) -> str:
|
||
return "Expr"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class FunctionDef(AST):
|
||
"""FunctionDef(name: str, args: AST,
|
||
decorator_list: list[AST | t.CPtr], returns: AST, flags: CInt)"""
|
||
name: str
|
||
args: AST | t.CPtr
|
||
decorator_list: list[AST | t.CPtr] | t.CPtr
|
||
returns: AST | t.CPtr
|
||
flags: t.CInt
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
name: str, args: AST | t.CPtr,
|
||
decorator_list: list[AST | t.CPtr] | t.CPtr,
|
||
returns: AST | t.CPtr, is_async: t.CInt):
|
||
ptr: FunctionDef | t.CPtr = pool.alloc(FunctionDef.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, FunctionDef.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
name: str, args: AST | t.CPtr,
|
||
decorator_list: list[AST | t.CPtr] | t.CPtr,
|
||
returns: AST | t.CPtr, is_async: t.CInt):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.name = _copy_str(pool, name)
|
||
self.args = args
|
||
self.decorator_list = decorator_list
|
||
self.returns = returns
|
||
if is_async:
|
||
self.flags = FLAG_IS_ASYNC
|
||
else:
|
||
self.flags = 0
|
||
_set_parent_list(decorator_list, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.FunctionDef
|
||
|
||
def type_name(self) -> str:
|
||
return "FunctionDef"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class Expression(AST):
|
||
"""Expression(body: AST)"""
|
||
body: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
body: AST | t.CPtr):
|
||
ptr: Expression | t.CPtr = pool.alloc(Expression.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Expression.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
body: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.body = body
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Expression
|
||
|
||
def type_name(self) -> str:
|
||
return "Expression"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class Interactive(AST):
|
||
"""Interactive(body: AST)"""
|
||
body: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
body: AST | t.CPtr):
|
||
ptr: Interactive | t.CPtr = pool.alloc(Interactive.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Interactive.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
body: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.body = body
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Interactive
|
||
|
||
def type_name(self) -> str:
|
||
return "Interactive"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class FunctionType(AST):
|
||
"""FunctionType(argtypes: list[AST | t.CPtr], returns: AST)"""
|
||
argtypes: list[AST | t.CPtr] | t.CPtr
|
||
returns: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
argtypes: list[AST | t.CPtr] | t.CPtr,
|
||
returns: AST | t.CPtr):
|
||
ptr: FunctionType | t.CPtr = pool.alloc(FunctionType.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, FunctionType.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
argtypes: list[AST | t.CPtr] | t.CPtr,
|
||
returns: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.argtypes = argtypes
|
||
self.returns = returns
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.FunctionType
|
||
|
||
def type_name(self) -> str:
|
||
return "FunctionType"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class ClassDef(AST):
|
||
"""ClassDef(name: str, bases: list[AST | t.CPtr], keywords: list[AST | t.CPtr],
|
||
decorator_list: list[AST | t.CPtr], type_params: list[str] | t.CPtr)
|
||
|
||
type_params: 泛型类型参数名列表（PEP 695 class list[T]: 中的 [T]），
|
||
None 表示非泛型类。"""
|
||
name: str
|
||
bases: list[AST | t.CPtr] | t.CPtr
|
||
keywords: list[AST | t.CPtr] | t.CPtr
|
||
decorator_list: list[AST | t.CPtr] | t.CPtr
|
||
type_params: list[str] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
name: str,
|
||
bases: list[AST | t.CPtr] | t.CPtr,
|
||
keywords: list[AST | t.CPtr] | t.CPtr,
|
||
decorator_list: list[AST | t.CPtr] | t.CPtr,
|
||
type_params: list[str] | t.CPtr = None):
|
||
ptr: ClassDef | t.CPtr = pool.alloc(ClassDef.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, ClassDef.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
name: str,
|
||
bases: list[AST | t.CPtr] | t.CPtr,
|
||
keywords: list[AST | t.CPtr] | t.CPtr,
|
||
decorator_list: list[AST | t.CPtr] | t.CPtr,
|
||
type_params: list[str] | t.CPtr = 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) -> t.CInt:
|
||
return ASTKind.ClassDef
|
||
|
||
def type_name(self) -> str:
|
||
return "ClassDef"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class Delete(AST):
|
||
"""Delete(targets: list[AST | t.CPtr])"""
|
||
targets: list[AST | t.CPtr] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
targets: list[AST | t.CPtr] | t.CPtr):
|
||
ptr: Delete | t.CPtr = pool.alloc(Delete.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Delete.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
targets: list[AST | t.CPtr] | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.targets = targets
|
||
_set_parent_list(targets, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Delete
|
||
|
||
def type_name(self) -> str:
|
||
return "Delete"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
pos = _emit(buf, size, pos, "Delete(targets=")
|
||
pos = _dump_list(self.targets, buf, size, pos)
|
||
pos = _emit(buf, size, pos, ")")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# AugAssign 节点
|
||
# ============================================================
|
||
|
||
class AugAssign(AST):
|
||
"""AugAssign(target: AST, op: CInt, value: AST)"""
|
||
target: AST | t.CPtr
|
||
op: t.CInt
|
||
value: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
target: AST | t.CPtr, op: t.CInt, value: AST | t.CPtr):
|
||
ptr: AugAssign | t.CPtr = pool.alloc(AugAssign.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, AugAssign.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
target: AST | t.CPtr, op: t.CInt, value: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.target = target
|
||
self.op = op
|
||
self.value = value
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.AugAssign
|
||
|
||
def type_name(self) -> str:
|
||
return "AugAssign"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class AnnAssign(AST):
|
||
"""AnnAssign(target: AST, annotation: AST, value: AST, simple: CInt)"""
|
||
target: AST | t.CPtr
|
||
annotation: AST | t.CPtr
|
||
value: AST | t.CPtr
|
||
simple: t.CInt
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
target: AST | t.CPtr, annotation: AST | t.CPtr,
|
||
value: AST | t.CPtr, simple: t.CInt):
|
||
ptr: AnnAssign | t.CPtr = pool.alloc(AnnAssign.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, AnnAssign.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
target: AST | t.CPtr, annotation: AST | t.CPtr,
|
||
value: AST | t.CPtr, simple: t.CInt):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.target = target
|
||
self.annotation = annotation
|
||
self.value = value
|
||
self.simple = simple
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.AnnAssign
|
||
|
||
def type_name(self) -> str:
|
||
return "AnnAssign"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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, t.CInt64T(self.simple))
|
||
pos = _emit(buf, size, pos, ")")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# With 节点
|
||
# ============================================================
|
||
|
||
class With(AST):
|
||
"""With(items: list[AST | t.CPtr], is_async: CInt)"""
|
||
items: list[AST | t.CPtr] | t.CPtr
|
||
flags: t.CInt
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
items: list[AST | t.CPtr] | t.CPtr,
|
||
is_async: t.CInt):
|
||
ptr: With | t.CPtr = pool.alloc(With.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, With.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
items: list[AST | t.CPtr] | t.CPtr,
|
||
is_async: t.CInt):
|
||
_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) -> t.CInt:
|
||
return ASTKind.With
|
||
|
||
def type_name(self) -> str:
|
||
return "With"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class Raise(AST):
|
||
"""Raise(exc: AST, cause: AST)"""
|
||
exc: AST | t.CPtr
|
||
cause: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
exc: AST | t.CPtr, cause: AST | t.CPtr):
|
||
ptr: Raise | t.CPtr = pool.alloc(Raise.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Raise.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
exc: AST | t.CPtr, cause: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.exc = exc
|
||
self.cause = cause
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Raise
|
||
|
||
def type_name(self) -> str:
|
||
return "Raise"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class Try(AST):
|
||
"""Try(handlers: list[AST | t.CPtr],
|
||
orelse: list[AST | t.CPtr], finalbody: list[AST | t.CPtr])"""
|
||
handlers: list[AST | t.CPtr] | t.CPtr
|
||
orelse: list[AST | t.CPtr] | t.CPtr
|
||
finalbody: list[AST | t.CPtr] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
handlers: list[AST | t.CPtr] | t.CPtr,
|
||
orelse: list[AST | t.CPtr] | t.CPtr,
|
||
finalbody: list[AST | t.CPtr] | t.CPtr):
|
||
ptr: Try | t.CPtr = pool.alloc(Try.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Try.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
handlers: list[AST | t.CPtr] | t.CPtr,
|
||
orelse: list[AST | t.CPtr] | t.CPtr,
|
||
finalbody: list[AST | t.CPtr] | t.CPtr):
|
||
_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) -> t.CInt:
|
||
return ASTKind.Try
|
||
|
||
def type_name(self) -> str:
|
||
return "Try"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class Assert(AST):
|
||
"""Assert(test: AST, msg: AST)"""
|
||
test: AST | t.CPtr
|
||
msg: AST | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
test: AST | t.CPtr, msg: AST | t.CPtr):
|
||
ptr: Assert | t.CPtr = pool.alloc(Assert.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Assert.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
test: AST | t.CPtr, msg: AST | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.test = test
|
||
self.msg = msg
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Assert
|
||
|
||
def type_name(self) -> str:
|
||
return "Assert"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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 节点
|
||
# ============================================================
|
||
|
||
class Global(AST):
|
||
"""Global(names: list[AST | t.CPtr])"""
|
||
names: list[AST | t.CPtr] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
names: list[AST | t.CPtr] | t.CPtr):
|
||
ptr: Global | t.CPtr = pool.alloc(Global.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Global.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
names: list[AST | t.CPtr] | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.names = names
|
||
_set_parent_list(names, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Global
|
||
|
||
def type_name(self) -> str:
|
||
return "Global"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
pos = _emit(buf, size, pos, "Global(names=")
|
||
pos = _dump_list(self.names, buf, size, pos)
|
||
pos = _emit(buf, size, pos, ")")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# Nonlocal 节点
|
||
# ============================================================
|
||
|
||
class Nonlocal(AST):
|
||
"""Nonlocal(names: list[AST | t.CPtr])"""
|
||
names: list[AST | t.CPtr] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
names: list[AST | t.CPtr] | t.CPtr):
|
||
ptr: Nonlocal | t.CPtr = pool.alloc(Nonlocal.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Nonlocal.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
names: list[AST | t.CPtr] | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.names = names
|
||
_set_parent_list(names, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Nonlocal
|
||
|
||
def type_name(self) -> str:
|
||
return "Nonlocal"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
pos = _emit(buf, size, pos, "Nonlocal(names=")
|
||
pos = _dump_list(self.names, buf, size, pos)
|
||
pos = _emit(buf, size, pos, ")")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# Pass 节点
|
||
# ============================================================
|
||
|
||
class Pass(AST):
|
||
"""Pass()"""
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr):
|
||
ptr: Pass | t.CPtr = pool.alloc(Pass.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Pass.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Pass
|
||
|
||
def type_name(self) -> str:
|
||
return "Pass"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
pos = _emit(buf, size, pos, "Pass()")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# Break 节点
|
||
# ============================================================
|
||
|
||
class Break(AST):
|
||
"""Break()"""
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr):
|
||
ptr: Break | t.CPtr = pool.alloc(Break.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Break.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Break
|
||
|
||
def type_name(self) -> str:
|
||
return "Break"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
pos = _emit(buf, size, pos, "Break()")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# Continue 节点
|
||
# ============================================================
|
||
|
||
class Continue(AST):
|
||
"""Continue()"""
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr):
|
||
ptr: Continue | t.CPtr = pool.alloc(Continue.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Continue.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Continue
|
||
|
||
def type_name(self) -> str:
|
||
return "Continue"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
pos = _emit(buf, size, pos, "Continue()")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# Import 节点
|
||
# ============================================================
|
||
|
||
class Import(AST):
|
||
"""Import(names: list[AST | t.CPtr])"""
|
||
names: list[AST | t.CPtr] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
names: list[AST | t.CPtr] | t.CPtr):
|
||
ptr: Import | t.CPtr = pool.alloc(Import.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Import.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
names: list[AST | t.CPtr] | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.names = names
|
||
_set_parent_list(names, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Import
|
||
|
||
def type_name(self) -> str:
|
||
return "Import"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
pos = _emit(buf, size, pos, "Import(names=")
|
||
pos = _dump_list(self.names, buf, size, pos)
|
||
pos = _emit(buf, size, pos, ")")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# ImportFrom 节点
|
||
# ============================================================
|
||
|
||
class ImportFrom(AST):
|
||
"""ImportFrom(module: str, names: list[AST | t.CPtr], level: CInt)"""
|
||
module: str
|
||
names: list[AST | t.CPtr] | t.CPtr
|
||
level: t.CInt
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
module: str,
|
||
names: list[AST | t.CPtr] | t.CPtr,
|
||
level: t.CInt):
|
||
ptr: ImportFrom | t.CPtr = pool.alloc(ImportFrom.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, ImportFrom.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
module: str,
|
||
names: list[AST | t.CPtr] | t.CPtr,
|
||
level: t.CInt):
|
||
_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) -> t.CInt:
|
||
return ASTKind.ImportFrom
|
||
|
||
def type_name(self) -> str:
|
||
return "ImportFrom"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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, t.CInt64T(self.level))
|
||
pos = _emit(buf, size, pos, ")")
|
||
return pos
|
||
|
||
|
||
# ============================================================
|
||
# Match 节点
|
||
# ============================================================
|
||
|
||
class Match(AST):
|
||
"""Match(subject: AST, cases: list[AST | t.CPtr])"""
|
||
subject: AST | t.CPtr
|
||
cases: list[AST | t.CPtr] | t.CPtr
|
||
|
||
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
||
subject: AST | t.CPtr,
|
||
cases: list[AST | t.CPtr] | t.CPtr):
|
||
ptr: Match | t.CPtr = pool.alloc(Match.__sizeof__())
|
||
if ptr:
|
||
string.memset(ptr, 0, Match.__sizeof__())
|
||
return ptr
|
||
|
||
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
||
subject: AST | t.CPtr,
|
||
cases: list[AST | t.CPtr] | t.CPtr):
|
||
_init_ast(self, pool, 0, 0)
|
||
self.subject = subject
|
||
self.cases = cases
|
||
_set_parent_list(cases, self)
|
||
|
||
def kind(self) -> t.CInt:
|
||
return ASTKind.Match
|
||
|
||
def type_name(self) -> str:
|
||
return "Match"
|
||
|
||
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
||
pos: t.CSizeT) -> t.CSizeT:
|
||
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, ")")
|
||
return pos
|