1158 lines
37 KiB
Plaintext
1158 lines
37 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,
|
|
)
|
|
|
|
|
|
# ============================================================
|
|
# Module Node
|
|
# ============================================================
|
|
|
|
@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 Node
|
|
# ============================================================
|
|
|
|
class Assign(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class If(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class For(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class While(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Return(Stmt):
|
|
"""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 Node (expression statement)
|
|
# ============================================================
|
|
|
|
class Expr(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class FunctionDef(Stmt):
|
|
"""FunctionDef(name: str, args: AST,
|
|
decorator_list: list[AST | t.CPtr], returns: AST, flags: CInt,
|
|
type_params: list[str] | t.CPtr = None)
|
|
|
|
type_params: 泛型函数类型参数名列表（PEP 695 def f[T](...): 中的 [T]），
|
|
None 表示非泛型函数。"""
|
|
name: str
|
|
args: AST | t.CPtr
|
|
decorator_list: list[AST | t.CPtr] | t.CPtr
|
|
returns: AST | t.CPtr
|
|
flags: t.CInt
|
|
type_params: list[str] | t.CPtr
|
|
|
|
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,
|
|
type_params: list[str] | t.CPtr = 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) -> 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 Node
|
|
# ============================================================
|
|
|
|
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 Node
|
|
# ============================================================
|
|
|
|
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 Node
|
|
# ============================================================
|
|
|
|
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 Node
|
|
# ============================================================
|
|
|
|
class ClassDef(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Delete(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class AugAssign(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class AnnAssign(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class With(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Raise(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Try(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Assert(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Global(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Nonlocal(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Pass(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Break(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Continue(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Import(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class ImportFrom(Stmt):
|
|
"""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 Node
|
|
# ============================================================
|
|
|
|
class Match(Stmt):
|
|
"""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
|