GVSDS/Viper_VRTE
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: rawptr[T] -> T* 与 t.CConst 前缀迁移（R14/R16）

Browse Source 
R14：rawptr[X] -> X*（41 文件 / 2037 行改动），X 含模块限定名与嵌套下标（rawptr[GSList[NameEntry]] -> GSList[NameEntry]*）。保留 6 处 rawptr[t.CPtr]（规范例外：存纯裸指针）；# 注释与字符串里的 rawptr[...] 属元语法描述，未动。 R16（保守子集）：t.CConst | str/bytes -> const str/bytes，t.CConst | char | t.CPtr -> const str；typedef 右值位置豁免（const str 在该处无法注册，与 R1 同源）。 验证：TPC 自举三重重编 SUCCESS；TransPyV.exe 全量 77/77 顺序回归通过。
This commit is contained in:
TermiNexus committed 2026-10-05 17:38:21 +08:00
1 parent 0ef4ba9634
commit 0055ab7ea7
41 files changed
+2031 -2031
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

argparse.vp
+1 -1
View File
@@ -428,7 +428,7 @@ class ArgumentParser:
# release — Release ParsedArgs and all internal resources # release — Release ParsedArgs and all internal resources
# ============================================================ # ============================================================
def release(args: rawptr[ParsedArgs]): def release(args: ParsedArgs*):
"""Free ParsedArgs object and its inner HashTable resources.""" """Free ParsedArgs object and its inner HashTable resources."""
if args is None: return if args is None: return
if args.__mbuddy__ is None: return if args.__mbuddy__ is None: return
ast/__init__.vp
+9 -9
View File
@@ -69,7 +69,7 @@ _mbuddy: memhub.MemBuddy*
# ============================================================ # ============================================================
# Common API: parse # Common API: parse
# ============================================================ # ============================================================
def parse(src: str, pool: rawptr[memhub.MemManager]) -> rawptr[AST]: def parse(src: str, pool: memhub.MemManager*) -> AST*:
"""Parse Python source code, return the AST Module node. """Parse Python source code, return the AST Module node.
Parameters: Parameters:
@@ -81,16 +81,16 @@ def parse(src: str, pool: rawptr[memhub.MemManager]) -> rawptr[AST]:
""" """
if src is None or pool is None: return None if src is None or pool is None: return None
_init_tables(pool) _init_tables(pool)
lx: rawptr[Lexer] = new_lexer(pool) lx: Lexer* = new_lexer(pool)
if lx is None: return None if lx is None: return None
_lexer_init(lx, src, pool) _lexer_init(lx, src, pool)
tokens: rawptr[Token] = tokenize(lx) tokens: Token* = tokenize(lx)
if tokens is None: return None if tokens is None: return None
tree: rawptr[AST] = parse_tokens(pool, tokens) tree: AST* = parse_tokens(pool, tokens)
return tree return tree
def parse_expression(src: str, pool: rawptr[memhub.MemManager]) -> rawptr[Expression]: def parse_expression(src: str, pool: memhub.MemManager*) -> Expression*:
"""Parse a single expression, return the Expression node. """Parse a single expression, return the Expression node.
Parameters: Parameters:
@@ -102,13 +102,13 @@ def parse_expression(src: str, pool: rawptr[memhub.MemManager]) -> rawptr[Expres
""" """
if src is None or pool is None: return None if src is None or pool is None: return None
_init_tables(pool) _init_tables(pool)
lx: rawptr[Lexer] = new_lexer(pool) lx: Lexer* = new_lexer(pool)
if lx is None: return None if lx is None: return None
_lexer_init(lx, src, pool) _lexer_init(lx, src, pool)
tokens: rawptr[Token] = tokenize(lx) tokens: Token* = tokenize(lx)
if tokens is None: return None if tokens is None: return None
ps: rawptr[Parser] = new_parser(pool) ps: Parser* = new_parser(pool)
if ps is None: return None if ps is None: return None
_parser_init(ps, tokens, pool) _parser_init(ps, tokens, pool)
body: rawptr[AST] = _parse_test(ps) body: AST* = _parse_test(ps)
return Expression(pool, body) return Expression(pool, body)
ast/astaux.vp
+47 -47
View File
@@ -14,15 +14,15 @@ from .base import (
# ============================================================ # ============================================================
class ExceptHandler(AST): class ExceptHandler(AST):
"""ExceptHandler(type: AST, name: str)""" """ExceptHandler(type: AST, name: str)"""
type: rawptr[AST] type: AST*
name: str name: str
def __new__(self, pool: rawptr[memhub.MemManager], type: rawptr[AST], name: str): def __new__(self, pool: memhub.MemManager*, type: AST*, name: str):
ptr: rawptr[ExceptHandler] = pool.alloc(ExceptHandler.__sizeof__()) ptr: ExceptHandler* = pool.alloc(ExceptHandler.__sizeof__())
if ptr: string.memset(ptr, 0, ExceptHandler.__sizeof__()) if ptr: string.memset(ptr, 0, ExceptHandler.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], type: rawptr[AST], name: str): def __init__(self, pool: memhub.MemManager*, type: AST*, name: str):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.type = type self.type = type
self.name = _copy_str(pool, name) self.name = _copy_str(pool, name)
@@ -53,26 +53,26 @@ class ExceptHandler(AST):
class Arguments(AST): class Arguments(AST):
"""Arguments(args: list[AST | CPtr], vararg: AST, kwarg: AST, """Arguments(args: list[AST | CPtr], vararg: AST, kwarg: AST,
defaults: list[AST | CPtr], kw_defaults: list[AST | CPtr])""" defaults: list[AST | CPtr], kw_defaults: list[AST | CPtr])"""
args: rawptr[list[rawptr[AST]]] args: list[AST*]*
vararg: rawptr[AST] vararg: AST*
kwarg: rawptr[AST] kwarg: AST*
defaults: rawptr[list[rawptr[AST]]] defaults: list[AST*]*
kw_defaults: rawptr[list[rawptr[AST]]] kw_defaults: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
args: rawptr[list[rawptr[AST]]], args: list[AST*]*,
vararg: rawptr[AST], kwarg: rawptr[AST], vararg: AST*, kwarg: AST*,
defaults: rawptr[list[rawptr[AST]]], defaults: list[AST*]*,
kw_defaults: rawptr[list[rawptr[AST]]]): kw_defaults: list[AST*]*):
ptr: rawptr[Arguments] = pool.alloc(Arguments.__sizeof__()) ptr: Arguments* = pool.alloc(Arguments.__sizeof__())
if ptr: string.memset(ptr, 0, Arguments.__sizeof__()) if ptr: string.memset(ptr, 0, Arguments.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
args: rawptr[list[rawptr[AST]]], args: list[AST*]*,
vararg: rawptr[AST], kwarg: rawptr[AST], vararg: AST*, kwarg: AST*,
defaults: rawptr[list[rawptr[AST]]], defaults: list[AST*]*,
kw_defaults: rawptr[list[rawptr[AST]]]): kw_defaults: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.args = args self.args = args
self.vararg = vararg self.vararg = vararg
@@ -117,14 +117,14 @@ class Arguments(AST):
class Arg(AST): class Arg(AST):
"""Arg(arg: str, annotation: AST)""" """Arg(arg: str, annotation: AST)"""
arg: str arg: str
annotation: rawptr[AST] annotation: AST*
def __new__(self, pool: rawptr[memhub.MemManager], arg: str, annotation: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, arg: str, annotation: AST*):
ptr: rawptr[Arg] = pool.alloc(Arg.__sizeof__()) ptr: Arg* = pool.alloc(Arg.__sizeof__())
if ptr: string.memset(ptr, 0, Arg.__sizeof__()) if ptr: string.memset(ptr, 0, Arg.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], arg: str, annotation: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, arg: str, annotation: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.arg = _copy_str(pool, arg) self.arg = _copy_str(pool, arg)
self.annotation = annotation self.annotation = annotation
@@ -153,14 +153,14 @@ class Arg(AST):
class Keyword(AST): class Keyword(AST):
"""Keyword(arg: str, value: AST)""" """Keyword(arg: str, value: AST)"""
arg: str arg: str
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], arg: str, value: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, arg: str, value: AST*):
ptr: rawptr[Keyword] = pool.alloc(Keyword.__sizeof__()) ptr: Keyword* = pool.alloc(Keyword.__sizeof__())
if ptr: string.memset(ptr, 0, Keyword.__sizeof__()) if ptr: string.memset(ptr, 0, Keyword.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], arg: str, value: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, arg: str, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.arg = _copy_str(pool, arg) self.arg = _copy_str(pool, arg)
self.value = value self.value = value
@@ -191,12 +191,12 @@ class Alias(AST):
name: str name: str
asname: str asname: str
def __new__(self, pool: rawptr[memhub.MemManager], name: str, asname: str): def __new__(self, pool: memhub.MemManager*, name: str, asname: str):
ptr: rawptr[Alias] = pool.alloc(Alias.__sizeof__()) ptr: Alias* = pool.alloc(Alias.__sizeof__())
if ptr: string.memset(ptr, 0, Alias.__sizeof__()) if ptr: string.memset(ptr, 0, Alias.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
name: str, asname: str): name: str, asname: str):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.name = _copy_str(pool, name) self.name = _copy_str(pool, name)
@@ -223,16 +223,16 @@ class Alias(AST):
class WithItem(AST): class WithItem(AST):
"""WithItem(context_expr: AST, optional_vars: AST)""" """WithItem(context_expr: AST, optional_vars: AST)"""
context_expr: rawptr[AST] context_expr: AST*
optional_vars: rawptr[AST] optional_vars: AST*
def __new__(self, pool: rawptr[memhub.MemManager], context_expr: rawptr[AST], optional_vars: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, context_expr: AST*, optional_vars: AST*):
ptr: rawptr[WithItem] = pool.alloc(WithItem.__sizeof__()) ptr: WithItem* = pool.alloc(WithItem.__sizeof__())
if ptr: string.memset(ptr, 0, WithItem.__sizeof__()) if ptr: string.memset(ptr, 0, WithItem.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
context_expr: rawptr[AST], optional_vars: rawptr[AST]): context_expr: AST*, optional_vars: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.context_expr = context_expr self.context_expr = context_expr
self.optional_vars = optional_vars self.optional_vars = optional_vars
@@ -264,22 +264,22 @@ class WithItem(AST):
class Comprehension(AST): class Comprehension(AST):
"""Comprehension(target: AST, iter: AST, ifs: list[AST | CPtr], is_async: CInt)""" """Comprehension(target: AST, iter: AST, ifs: list[AST | CPtr], is_async: CInt)"""
target: rawptr[AST] target: AST*
iter: rawptr[AST] iter: AST*
ifs: rawptr[list[rawptr[AST]]] ifs: list[AST*]*
is_async: int is_async: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
target: rawptr[AST], iter: rawptr[AST], target: AST*, iter: AST*,
ifs: rawptr[list[rawptr[AST]]], is_async: int): ifs: list[AST*]*, is_async: int):
ptr: rawptr[Comprehension] = pool.alloc(Comprehension.__sizeof__()) ptr: Comprehension* = pool.alloc(Comprehension.__sizeof__())
if ptr: if ptr:
string.memset(ptr, 0, Comprehension.__sizeof__()) string.memset(ptr, 0, Comprehension.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
target: rawptr[AST], iter: rawptr[AST], target: AST*, iter: AST*,
ifs: rawptr[list[rawptr[AST]]], is_async: int): ifs: list[AST*]*, is_async: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.target = target self.target = target
self.iter = iter self.iter = iter
ast/base.vp
+17 -17
View File
@@ -104,7 +104,7 @@ enum ASTFlag:
# ============================================================ # ============================================================
# Helper Functions # Helper Functions
# ============================================================ # ============================================================
def _copy_str(pool: rawptr[memhub.MemManager], src: str) -> str: def _copy_str(pool: memhub.MemManager*, src: str) -> str:
"""Allocate and copy a C string from pool.""" """Allocate and copy a C string from pool."""
if src is None: return None if src is None: return None
slen: sizet = string.strlen(src) slen: sizet = string.strlen(src)
@@ -114,7 +114,7 @@ def _copy_str(pool: rawptr[memhub.MemManager], src: str) -> str:
return buf return buf
def _set_pos(node: rawptr[AST], lineno: int, col_offset: int, end_lineno: int, end_col_offset: int): def _set_pos(node: AST*, lineno: int, col_offset: int, end_lineno: int, end_col_offset: int):
if node is None: return if node is None: return
node.lineno = lineno node.lineno = lineno
node.col_offset = col_offset node.col_offset = col_offset
@@ -122,7 +122,7 @@ def _set_pos(node: rawptr[AST], lineno: int, col_offset: int, end_lineno: int, e
node.end_col_offset = end_col_offset node.end_col_offset = end_col_offset
def _inherit_pos(node: rawptr[AST], ref: rawptr[AST]): def _inherit_pos(node: AST*, ref: AST*):
if node is None or ref is None: return if node is None or ref is None: return
node.lineno = ref.lineno node.lineno = ref.lineno
node.col_offset = ref.col_offset node.col_offset = ref.col_offset
@@ -130,7 +130,7 @@ def _inherit_pos(node: rawptr[AST], ref: rawptr[AST]):
node.end_col_offset = ref.end_col_offset node.end_col_offset = ref.end_col_offset
def _init_ast(node: rawptr[AST], pool: rawptr[memhub.MemManager], lineno: int, col: int): def _init_ast(node: AST*, pool: memhub.MemManager*, lineno: int, col: int):
"""Initialize AST base fields.""" """Initialize AST base fields."""
node.parent = None node.parent = None
node.pool = pool node.pool = pool
@@ -141,16 +141,16 @@ def _init_ast(node: rawptr[AST], pool: rawptr[memhub.MemManager], lineno: int, c
node.children = None node.children = None
def _set_parent_list(lst: list[rawptr[AST]]*, parent: rawptr[AST]): def _set_parent_list(lst: list[AST*]*, parent: AST*):
"""Set list children parent pointers.""" """Set list children parent pointers."""
if lst is None: return if lst is None: return
for i in range(lst.__len__()): for i in range(lst.__len__()):
child: rawptr[AST] = lst.get(i) child: AST* = lst.get(i)
if child is not None: child.parent = parent if child is not None: child.parent = parent
def _append_child(lst: list[rawptr[AST]]*, node: rawptr[AST], def _append_child(lst: list[AST*]*, node: AST*,
pool: rawptr[memhub.MemManager]): pool: memhub.MemManager*):
"""Append child nodes to a list (module-level function, to avoid conflicts with the AST.append method name). """Append child nodes to a list (module-level function, to avoid conflicts with the AST.append method name).
Call this function within the AST.append method to bypass the compiler mistaking list.append for a virtual function call to AST.append when doing type inference.""" Call this function within the AST.append method to bypass the compiler mistaking list.append for a virtual function call to AST.append when doing type inference."""
@@ -276,7 +276,7 @@ def _op_name(op: int) -> str:
return "NoneOp" return "NoneOp"
def _dump_list(lst: list[rawptr[AST]]*, buf: str, size: sizet, pos: sizet) -> sizet: def _dump_list(lst: list[AST*]*, buf: str, size: sizet, pos: sizet) -> sizet:
"""Traverse a list[AST | CPtr] container, polymorphically dump each element.""" """Traverse a list[AST | CPtr] container, polymorphically dump each element."""
if lst is None: if lst is None:
pos = _emit(buf, size, pos, "[]") pos = _emit(buf, size, pos, "[]")
@@ -284,7 +284,7 @@ def _dump_list(lst: list[rawptr[AST]]*, buf: str, size: sizet, pos: sizet) -> si
pos = _emit(buf, size, pos, "[") pos = _emit(buf, size, pos, "[")
for i in range(lst.__len__()): for i in range(lst.__len__()):
if i > 0: pos = _emit(buf, size, pos, ", ") if i > 0: pos = _emit(buf, size, pos, ", ")
child: rawptr[AST] = lst.get(i) child: AST* = lst.get(i)
if child is not None: pos = child.dump(buf, size, pos) if child is not None: pos = child.dump(buf, size, pos)
pos = _emit(buf, size, pos, "]") pos = _emit(buf, size, pos, "]")
return pos return pos
@@ -295,7 +295,7 @@ def _dump_op_list(lst: t.CPtr, buf: str, size: sizet, pos: sizet) -> sizet:
if lst is None: if lst is None:
pos = _emit(buf, size, pos, "[]") pos = _emit(buf, size, pos, "[]")
return pos return pos
ops_list: rawptr[list[int]] = (rawptr[list[int]])(lst) ops_list: list[int]* = (list[int]*)(lst)
pos = _emit(buf, size, pos, "[") pos = _emit(buf, size, pos, "[")
for i in range(ops_list.__len__()): for i in range(ops_list.__len__()):
if i > 0: pos = _emit(buf, size, pos, ", ") if i > 0: pos = _emit(buf, size, pos, ", ")
@@ -322,13 +322,13 @@ virtual class AST:
end_lineno/end_col_offset: Ending position end_lineno/end_col_offset: Ending position
children: List of child nodes (body block, added via append) children: List of child nodes (body block, added via append)
""" """
parent: rawptr[AST] parent: AST*
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
lineno: int lineno: int
col_offset: int col_offset: int
end_lineno: int end_lineno: int
end_col_offset: int end_col_offset: int
children: list[rawptr[AST]]* children: list[AST*]*
def kind(self) -> int: def kind(self) -> int:
"""Returns the node type (ASTKind value), overridden by subclasses""" """Returns the node type (ASTKind value), overridden by subclasses"""
@@ -347,7 +347,7 @@ virtual class AST:
Current implementation is empty. override this method to dispatch to visitor.visit_X(self)""" Current implementation is empty. override this method to dispatch to visitor.visit_X(self)"""
pass pass
def append(self, node: rawptr[AST]): def append(self, node: AST*):
"""Append node to the children list. """Append node to the children list.
Used for parser to build statement blocks: module.append(stmt), if_node.append(stmt), etc. Used for parser to build statement blocks: module.append(stmt), if_node.append(stmt), etc.
@@ -356,7 +356,7 @@ virtual class AST:
Note: list[AST|CPtr] is currently stored by value (compiler limitation), so you must set Note: list[AST|CPtr] is currently stored by value (compiler limitation), so you must set
node.parent before appending, so the parent in the copy is correct.""" node.parent before appending, so the parent in the copy is correct."""
if self is None or node is None: return if self is None or node is None: return
if self.children is None: self.children = list[rawptr[AST]](self.pool, 8) if self.children is None: self.children = list[AST*](self.pool, 8)
node.parent = self node.parent = self
_append_child(self.children, node, self.pool) _append_child(self.children, node, self.pool)
@@ -386,7 +386,7 @@ virtual class ExprNode(AST):
# ============================================================ # ============================================================
# Module dump function (for ast.dump(node, buf, size)) # Module dump function (for ast.dump(node, buf, size))
# ============================================================ # ============================================================
def dump(node: rawptr[AST], buf: str, size: sizet): def dump(node: AST*, buf: str, size: sizet):
"""Serialize AST node to buf (with capacity size)""" """Serialize AST node to buf (with capacity size)"""
if node is None or buf is None or size == 0: return if node is None or buf is None or size == 0: return
buf[0] = '\0' buf[0] = '\0'
ast/exprs.vp
+198 -198
View File
@@ -20,12 +20,12 @@ class Name(ExprNode):
id: str id: str
ctx: int ctx: int
def __new__(self, pool: rawptr[memhub.MemManager], id: str, ctx: int): def __new__(self, pool: memhub.MemManager*, id: str, ctx: int):
ptr: rawptr[Name] = pool.alloc(Name.__sizeof__()) ptr: Name* = pool.alloc(Name.__sizeof__())
if ptr: string.memset(ptr, 0, Name.__sizeof__()) if ptr: string.memset(ptr, 0, Name.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], id: str, ctx: int): def __init__(self, pool: memhub.MemManager*, id: str, ctx: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.id = _copy_str(pool, id) self.id = _copy_str(pool, id)
self.ctx = ctx self.ctx = ctx
@@ -50,25 +50,25 @@ class Name(ExprNode):
return pos return pos
def name_get_id(node: rawptr[Name]) -> str: def name_get_id(node: Name*) -> str:
"""Get Name.id field (cross-module accessor; guards against stub field-access pitfalls)""" """Get Name.id field (cross-module accessor; guards against stub field-access pitfalls)"""
if node is None: return None if node is None: return None
return node.id return node.id
def constant_get_str_val(node: rawptr[Constant]) -> str: def constant_get_str_val(node: Constant*) -> str:
"""Get Constant.str_val field (cross-module accessor)""" """Get Constant.str_val field (cross-module accessor)"""
if node is None: return None if node is None: return None
return node.str_val return node.str_val
def binop_get_left(node: rawptr[BinOp]) -> rawptr[AST]: def binop_get_left(node: BinOp*) -> AST*:
"""Get BinOp.left field (cross-module accessor)""" """Get BinOp.left field (cross-module accessor)"""
if node is None: return None if node is None: return None
return node.left return node.left
def binop_get_right(node: rawptr[BinOp]) -> rawptr[AST]: def binop_get_right(node: BinOp*) -> AST*:
"""Get BinOp.right field (cross-module accessor)""" """Get BinOp.right field (cross-module accessor)"""
if node is None: return None if node is None: return None
return node.right return node.right
@@ -85,16 +85,16 @@ class Constant(ExprNode):
str_val: str str_val: str
const_kind: int const_kind: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
const_kind: int, int_val: int64, const_kind: int, int_val: int64,
float_val: double, str_val: str, float_val: double, str_val: str,
lineno: int, col: int): lineno: int, col: int):
ptr: rawptr[Constant] = pool.alloc(Constant.__sizeof__()) ptr: Constant* = pool.alloc(Constant.__sizeof__())
if ptr: if ptr:
string.memset(ptr, 0, Constant.__sizeof__()) string.memset(ptr, 0, Constant.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
const_kind: int, int_val: int64, const_kind: int, int_val: int64,
float_val: double, str_val: str, float_val: double, str_val: str,
lineno: int, col: int): lineno: int, col: int):
@@ -148,18 +148,18 @@ class Constant(ExprNode):
class BinOp(ExprNode): class BinOp(ExprNode):
"""BinOp(left: AST, op: OpKind, right: AST)""" """BinOp(left: AST, op: OpKind, right: AST)"""
left: rawptr[AST] left: AST*
op: int op: int
right: rawptr[AST] right: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
left: rawptr[AST], op: int, right: rawptr[AST]): left: AST*, op: int, right: AST*):
ptr: rawptr[BinOp] = pool.alloc(BinOp.__sizeof__()) ptr: BinOp* = pool.alloc(BinOp.__sizeof__())
if ptr: string.memset(ptr, 0, BinOp.__sizeof__()) if ptr: string.memset(ptr, 0, BinOp.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
left: rawptr[AST], op: int, right: rawptr[AST]): left: AST*, op: int, right: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.left = left self.left = left
self.op = op self.op = op
@@ -195,16 +195,16 @@ class BinOp(ExprNode):
class UnaryOp(ExprNode): class UnaryOp(ExprNode):
"""UnaryOp(op: OpKind, operand: AST)""" """UnaryOp(op: OpKind, operand: AST)"""
op: int op: int
operand: rawptr[AST] operand: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
op: int, operand: rawptr[AST]): op: int, operand: AST*):
ptr: rawptr[UnaryOp] = pool.alloc(UnaryOp.__sizeof__()) ptr: UnaryOp* = pool.alloc(UnaryOp.__sizeof__())
if ptr: string.memset(ptr, 0, UnaryOp.__sizeof__()) if ptr: string.memset(ptr, 0, UnaryOp.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
op: int, operand: rawptr[AST]): op: int, operand: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.op = op self.op = op
self.operand = operand self.operand = operand
@@ -233,22 +233,22 @@ class UnaryOp(ExprNode):
class Compare(ExprNode): class Compare(ExprNode):
"""Compare(left: AST, ops: list[CInt], comparators: list[AST | CPtr])""" """Compare(left: AST, ops: list[CInt], comparators: list[AST | CPtr])"""
left: rawptr[AST] left: AST*
ops: t.CPtr ops: t.CPtr
comparators: rawptr[list[rawptr[AST]]] comparators: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
left: rawptr[AST], left: AST*,
ops: t.CPtr, ops: t.CPtr,
comparators: rawptr[list[rawptr[AST]]]): comparators: list[AST*]*):
ptr: rawptr[Compare] = pool.alloc(Compare.__sizeof__()) ptr: Compare* = pool.alloc(Compare.__sizeof__())
if ptr: string.memset(ptr, 0, Compare.__sizeof__()) if ptr: string.memset(ptr, 0, Compare.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
left: rawptr[AST], left: AST*,
ops: t.CPtr, ops: t.CPtr,
comparators: rawptr[list[rawptr[AST]]]): comparators: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.left = left self.left = left
self.ops = ops self.ops = ops
@@ -281,25 +281,25 @@ class Compare(ExprNode):
class Call(ExprNode): class Call(ExprNode):
"""Call(func: AST, args: list[AST | CPtr], keywords: list[AST | CPtr])""" """Call(func: AST, args: list[AST | CPtr], keywords: list[AST | CPtr])"""
func: rawptr[AST] func: AST*
args: rawptr[list[rawptr[AST]]] args: list[AST*]*
keywords: rawptr[list[rawptr[AST]]] keywords: list[AST*]*
# Value-position `volatile f()` / `volatile S()` prefix marker (see _IsVolatileCallPrefix): # Value-position `volatile f()` / `volatile S()` prefix marker (see _IsVolatileCallPrefix):
# 1 = result/temp slot accessed volatile (struct writes too). Appended last: offsets unchanged. # 1 = result/temp slot accessed volatile (struct writes too). Appended last: offsets unchanged.
IsVolatile: int IsVolatile: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
func: rawptr[AST], func: AST*,
args: rawptr[list[rawptr[AST]]], args: list[AST*]*,
keywords: rawptr[list[rawptr[AST]]]): keywords: list[AST*]*):
ptr: rawptr[Call] = pool.alloc(Call.__sizeof__()) ptr: Call* = pool.alloc(Call.__sizeof__())
if ptr: string.memset(ptr, 0, Call.__sizeof__()) if ptr: string.memset(ptr, 0, Call.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
func: rawptr[AST], func: AST*,
args: rawptr[list[rawptr[AST]]], args: list[AST*]*,
keywords: rawptr[list[rawptr[AST]]]): keywords: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.func = func self.func = func
self.args = args self.args = args
@@ -333,18 +333,18 @@ class Call(ExprNode):
class BoolOp(ExprNode): class BoolOp(ExprNode):
"""BoolOp(op: CInt, values: list[AST | CPtr])""" """BoolOp(op: CInt, values: list[AST | CPtr])"""
op: int op: int
values: rawptr[list[rawptr[AST]]] values: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
op: int, op: int,
values: rawptr[list[rawptr[AST]]]): values: list[AST*]*):
ptr: rawptr[BoolOp] = pool.alloc(BoolOp.__sizeof__()) ptr: BoolOp* = pool.alloc(BoolOp.__sizeof__())
if ptr: string.memset(ptr, 0, BoolOp.__sizeof__()) if ptr: string.memset(ptr, 0, BoolOp.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
op: int, op: int,
values: rawptr[list[rawptr[AST]]]): values: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.op = op self.op = op
self.values = values self.values = values
@@ -371,17 +371,17 @@ class BoolOp(ExprNode):
class Lambda(ExprNode): class Lambda(ExprNode):
"""Lambda(args: AST, body: AST)""" """Lambda(args: AST, body: AST)"""
args: rawptr[AST] args: AST*
body: rawptr[AST] body: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
args: rawptr[AST], body: rawptr[AST]): args: AST*, body: AST*):
ptr: rawptr[Lambda] = pool.alloc(Lambda.__sizeof__()) ptr: Lambda* = pool.alloc(Lambda.__sizeof__())
if ptr: string.memset(ptr, 0, Lambda.__sizeof__()) if ptr: string.memset(ptr, 0, Lambda.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
args: rawptr[AST], body: rawptr[AST]): args: AST*, body: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.args = args self.args = args
self.body = body self.body = body
@@ -413,20 +413,20 @@ class Lambda(ExprNode):
class IfExp(ExprNode): class IfExp(ExprNode):
"""IfExp(test: AST, body: AST, orelse: AST)""" """IfExp(test: AST, body: AST, orelse: AST)"""
test: rawptr[AST] test: AST*
body: rawptr[AST] body: AST*
orelse: rawptr[AST] orelse: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
test: rawptr[AST], body: rawptr[AST], test: AST*, body: AST*,
orelse: rawptr[AST]): orelse: AST*):
ptr: rawptr[IfExp] = pool.alloc(IfExp.__sizeof__()) ptr: IfExp* = pool.alloc(IfExp.__sizeof__())
if ptr: string.memset(ptr, 0, IfExp.__sizeof__()) if ptr: string.memset(ptr, 0, IfExp.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
test: rawptr[AST], body: rawptr[AST], test: AST*, body: AST*,
orelse: rawptr[AST]): orelse: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.test = test self.test = test
self.body = body self.body = body
@@ -464,19 +464,19 @@ class IfExp(ExprNode):
class Dict(ExprNode): class Dict(ExprNode):
"""Dict(keys: list[AST | CPtr], values: list[AST | CPtr])""" """Dict(keys: list[AST | CPtr], values: list[AST | CPtr])"""
keys: rawptr[list[rawptr[AST]]] keys: list[AST*]*
values: rawptr[list[rawptr[AST]]] values: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
keys: rawptr[list[rawptr[AST]]], keys: list[AST*]*,
values: rawptr[list[rawptr[AST]]]): values: list[AST*]*):
ptr: rawptr[Dict] = pool.alloc(Dict.__sizeof__()) ptr: Dict* = pool.alloc(Dict.__sizeof__())
if ptr: string.memset(ptr, 0, Dict.__sizeof__()) if ptr: string.memset(ptr, 0, Dict.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
keys: rawptr[list[rawptr[AST]]], keys: list[AST*]*,
values: rawptr[list[rawptr[AST]]]): values: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.keys = keys self.keys = keys
self.values = values self.values = values
@@ -504,16 +504,16 @@ class Dict(ExprNode):
class Set(ExprNode): class Set(ExprNode):
"""Set(elts: list[AST | CPtr])""" """Set(elts: list[AST | CPtr])"""
elts: rawptr[list[rawptr[AST]]] elts: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
elts: rawptr[list[rawptr[AST]]]): elts: list[AST*]*):
ptr: rawptr[Set] = pool.alloc(Set.__sizeof__()) ptr: Set* = pool.alloc(Set.__sizeof__())
if ptr: string.memset(ptr, 0, Set.__sizeof__()) if ptr: string.memset(ptr, 0, Set.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
elts: rawptr[list[rawptr[AST]]]): elts: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.elts = elts self.elts = elts
_set_parent_list(elts, self) _set_parent_list(elts, self)
@@ -537,19 +537,19 @@ class Set(ExprNode):
class ListComp(ExprNode): class ListComp(ExprNode):
"""ListComp(elt: AST, generators: list[AST | CPtr])""" """ListComp(elt: AST, generators: list[AST | CPtr])"""
elt: rawptr[AST] elt: AST*
generators: rawptr[list[rawptr[AST]]] generators: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
elt: rawptr[AST], elt: AST*,
generators: rawptr[list[rawptr[AST]]]): generators: list[AST*]*):
ptr: rawptr[ListComp] = pool.alloc(ListComp.__sizeof__()) ptr: ListComp* = pool.alloc(ListComp.__sizeof__())
if ptr: string.memset(ptr, 0, ListComp.__sizeof__()) if ptr: string.memset(ptr, 0, ListComp.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
elt: rawptr[AST], elt: AST*,
generators: rawptr[list[rawptr[AST]]]): generators: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.elt = elt self.elt = elt
self.generators = generators self.generators = generators
@@ -579,19 +579,19 @@ class ListComp(ExprNode):
class SetComp(ExprNode): class SetComp(ExprNode):
"""SetComp(elt: AST, generators: list[AST | CPtr])""" """SetComp(elt: AST, generators: list[AST | CPtr])"""
elt: rawptr[AST] elt: AST*
generators: rawptr[list[rawptr[AST]]] generators: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
elt: rawptr[AST], elt: AST*,
generators: rawptr[list[rawptr[AST]]]): generators: list[AST*]*):
ptr: rawptr[SetComp] = pool.alloc(SetComp.__sizeof__()) ptr: SetComp* = pool.alloc(SetComp.__sizeof__())
if ptr: string.memset(ptr, 0, SetComp.__sizeof__()) if ptr: string.memset(ptr, 0, SetComp.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
elt: rawptr[AST], elt: AST*,
generators: rawptr[list[rawptr[AST]]]): generators: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.elt = elt self.elt = elt
self.generators = generators self.generators = generators
@@ -621,20 +621,20 @@ class SetComp(ExprNode):
class DictComp(ExprNode): class DictComp(ExprNode):
"""DictComp(key: AST, value: AST, generators: list[AST | CPtr])""" """DictComp(key: AST, value: AST, generators: list[AST | CPtr])"""
key: rawptr[AST] key: AST*
value: rawptr[AST] value: AST*
generators: rawptr[list[rawptr[AST]]] generators: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
key: rawptr[AST], value: rawptr[AST], key: AST*, value: AST*,
generators: rawptr[list[rawptr[AST]]]): generators: list[AST*]*):
ptr: rawptr[DictComp] = pool.alloc(DictComp.__sizeof__()) ptr: DictComp* = pool.alloc(DictComp.__sizeof__())
if ptr: string.memset(ptr, 0, DictComp.__sizeof__()) if ptr: string.memset(ptr, 0, DictComp.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
key: rawptr[AST], value: rawptr[AST], key: AST*, value: AST*,
generators: rawptr[list[rawptr[AST]]]): generators: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.key = key self.key = key
self.value = value self.value = value
@@ -670,19 +670,19 @@ class DictComp(ExprNode):
class GeneratorExp(ExprNode): class GeneratorExp(ExprNode):
"""GeneratorExp(elt: AST, generators: list[AST | CPtr])""" """GeneratorExp(elt: AST, generators: list[AST | CPtr])"""
elt: rawptr[AST] elt: AST*
generators: rawptr[list[rawptr[AST]]] generators: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
elt: rawptr[AST], elt: AST*,
generators: rawptr[list[rawptr[AST]]]): generators: list[AST*]*):
ptr: rawptr[GeneratorExp] = pool.alloc(GeneratorExp.__sizeof__()) ptr: GeneratorExp* = pool.alloc(GeneratorExp.__sizeof__())
if ptr: string.memset(ptr, 0, GeneratorExp.__sizeof__()) if ptr: string.memset(ptr, 0, GeneratorExp.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
elt: rawptr[AST], elt: AST*,
generators: rawptr[list[rawptr[AST]]]): generators: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.elt = elt self.elt = elt
self.generators = generators self.generators = generators
@@ -712,14 +712,14 @@ class GeneratorExp(ExprNode):
class Await(ExprNode): class Await(ExprNode):
"""Await(value: AST)""" """Await(value: AST)"""
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, value: AST*):
ptr: rawptr[Await] = pool.alloc(Await.__sizeof__()) ptr: Await* = pool.alloc(Await.__sizeof__())
if ptr: string.memset(ptr, 0, Await.__sizeof__()) if ptr: string.memset(ptr, 0, Await.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
@@ -745,14 +745,14 @@ class Await(ExprNode):
class Yield(ExprNode): class Yield(ExprNode):
"""Yield(value: AST)""" """Yield(value: AST)"""
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, value: AST*):
ptr: rawptr[Yield] = pool.alloc(Yield.__sizeof__()) ptr: Yield* = pool.alloc(Yield.__sizeof__())
if ptr: string.memset(ptr, 0, Yield.__sizeof__()) if ptr: string.memset(ptr, 0, Yield.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
@@ -778,14 +778,14 @@ class Yield(ExprNode):
class YieldFrom(ExprNode): class YieldFrom(ExprNode):
"""YieldFrom(value: AST)""" """YieldFrom(value: AST)"""
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, value: AST*):
ptr: rawptr[YieldFrom] = pool.alloc(YieldFrom.__sizeof__()) ptr: YieldFrom* = pool.alloc(YieldFrom.__sizeof__())
if ptr: string.memset(ptr, 0, YieldFrom.__sizeof__()) if ptr: string.memset(ptr, 0, YieldFrom.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
@@ -811,20 +811,20 @@ class YieldFrom(ExprNode):
class FormattedValue(ExprNode): class FormattedValue(ExprNode):
"""FormattedValue(value: AST, conversion: CInt, format_spec: AST)""" """FormattedValue(value: AST, conversion: CInt, format_spec: AST)"""
value: rawptr[AST] value: AST*
conversion: int conversion: int
format_spec: rawptr[AST] format_spec: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
value: rawptr[AST], conversion: int, value: AST*, conversion: int,
format_spec: rawptr[AST]): format_spec: AST*):
ptr: rawptr[FormattedValue] = pool.alloc(FormattedValue.__sizeof__()) ptr: FormattedValue* = pool.alloc(FormattedValue.__sizeof__())
if ptr: string.memset(ptr, 0, FormattedValue.__sizeof__()) if ptr: string.memset(ptr, 0, FormattedValue.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
value: rawptr[AST], conversion: int, value: AST*, conversion: int,
format_spec: rawptr[AST]): format_spec: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
self.conversion = conversion self.conversion = conversion
@@ -859,16 +859,16 @@ class FormattedValue(ExprNode):
class JoinedStr(ExprNode): class JoinedStr(ExprNode):
"""JoinedStr(values: list[AST | CPtr])""" """JoinedStr(values: list[AST | CPtr])"""
values: rawptr[list[rawptr[AST]]] values: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], values: rawptr[list[rawptr[AST]]]): def __new__(self, pool: memhub.MemManager*, values: list[AST*]*):
ptr: rawptr[JoinedStr] = pool.alloc(JoinedStr.__sizeof__()) ptr: JoinedStr* = pool.alloc(JoinedStr.__sizeof__())
if ptr: if ptr:
string.memset(ptr, 0, JoinedStr.__sizeof__()) string.memset(ptr, 0, JoinedStr.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
values: rawptr[list[rawptr[AST]]]): values: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.values = values self.values = values
_set_parent_list(values, self) _set_parent_list(values, self)
@@ -892,18 +892,18 @@ class JoinedStr(ExprNode):
class Attribute(ExprNode): class Attribute(ExprNode):
"""Attribute(value: AST, attr: str, ctx: CInt)""" """Attribute(value: AST, attr: str, ctx: CInt)"""
value: rawptr[AST] value: AST*
attr: str attr: str
ctx: int ctx: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
value: rawptr[AST], attr: str, ctx: int): value: AST*, attr: str, ctx: int):
ptr: rawptr[Attribute] = pool.alloc(Attribute.__sizeof__()) ptr: Attribute* = pool.alloc(Attribute.__sizeof__())
if ptr: string.memset(ptr, 0, Attribute.__sizeof__()) if ptr: string.memset(ptr, 0, Attribute.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
value: rawptr[AST], attr: str, ctx: int): value: AST*, attr: str, ctx: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
self.attr = _copy_str(pool, attr) self.attr = _copy_str(pool, attr)
@@ -933,13 +933,13 @@ class Attribute(ExprNode):
# Field accessors (guard against cross-module stub field-access pitfalls): other modules reading # Field accessors (guard against cross-module stub field-access pitfalls): other modules reading
# ast.Attribute fields directly may get a wrong stub GEP and crash, so they use these accessors. # ast.Attribute fields directly may get a wrong stub GEP and crash, so they use these accessors.
# ============================================================ # ============================================================
def attribute_get_value(node: rawptr[Attribute]) -> rawptr[AST]: def attribute_get_value(node: Attribute*) -> AST*:
"""Get Attribute.value field (cross-module accessor)""" """Get Attribute.value field (cross-module accessor)"""
if node is None: return None if node is None: return None
return node.value return node.value
def attribute_get_attr(node: rawptr[Attribute]) -> str: def attribute_get_attr(node: Attribute*) -> str:
"""Get Attribute.attr field (cross-module accessor)""" """Get Attribute.attr field (cross-module accessor)"""
if node is None: return None if node is None: return None
return node.attr return node.attr
@@ -951,18 +951,18 @@ def attribute_get_attr(node: rawptr[Attribute]) -> str:
class Subscript(ExprNode): class Subscript(ExprNode):
"""Subscript(value: AST, slice: AST, ctx: CInt)""" """Subscript(value: AST, slice: AST, ctx: CInt)"""
value: rawptr[AST] value: AST*
slice: rawptr[AST] slice: AST*
ctx: int ctx: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
value: rawptr[AST], slice: rawptr[AST], ctx: int): value: AST*, slice: AST*, ctx: int):
ptr: rawptr[Subscript] = pool.alloc(Subscript.__sizeof__()) ptr: Subscript* = pool.alloc(Subscript.__sizeof__())
if ptr: string.memset(ptr, 0, Subscript.__sizeof__()) if ptr: string.memset(ptr, 0, Subscript.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
value: rawptr[AST], slice: rawptr[AST], ctx: int): value: AST*, slice: AST*, ctx: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
self.slice = slice self.slice = slice
@@ -997,17 +997,17 @@ class Subscript(ExprNode):
class Starred(ExprNode): class Starred(ExprNode):
"""Starred(value: AST, ctx: CInt)""" """Starred(value: AST, ctx: CInt)"""
value: rawptr[AST] value: AST*
ctx: int ctx: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
value: rawptr[AST], ctx: int): value: AST*, ctx: int):
ptr: rawptr[Starred] = pool.alloc(Starred.__sizeof__()) ptr: Starred* = pool.alloc(Starred.__sizeof__())
if ptr: string.memset(ptr, 0, Starred.__sizeof__()) if ptr: string.memset(ptr, 0, Starred.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
value: rawptr[AST], ctx: int): value: AST*, ctx: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
self.ctx = ctx self.ctx = ctx
@@ -1036,17 +1036,17 @@ class Starred(ExprNode):
class List(ExprNode): class List(ExprNode):
"""List(elts: list[AST | CPtr], ctx: CInt)""" """List(elts: list[AST | CPtr], ctx: CInt)"""
elts: rawptr[list[rawptr[AST]]] elts: list[AST*]*
ctx: int ctx: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
elts: rawptr[list[rawptr[AST]]], ctx: int): elts: list[AST*]*, ctx: int):
ptr: rawptr[List] = pool.alloc(List.__sizeof__()) ptr: List* = pool.alloc(List.__sizeof__())
if ptr: string.memset(ptr, 0, List.__sizeof__()) if ptr: string.memset(ptr, 0, List.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
elts: rawptr[list[rawptr[AST]]], ctx: int): elts: list[AST*]*, ctx: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.elts = elts self.elts = elts
self.ctx = ctx self.ctx = ctx
@@ -1073,17 +1073,17 @@ class List(ExprNode):
class Tuple(ExprNode): class Tuple(ExprNode):
"""Tuple(elts: list[AST | CPtr], ctx: CInt)""" """Tuple(elts: list[AST | CPtr], ctx: CInt)"""
elts: rawptr[list[rawptr[AST]]] elts: list[AST*]*
ctx: int ctx: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
elts: rawptr[list[rawptr[AST]]], ctx: int): elts: list[AST*]*, ctx: int):
ptr: rawptr[Tuple] = pool.alloc(Tuple.__sizeof__()) ptr: Tuple* = pool.alloc(Tuple.__sizeof__())
if ptr: string.memset(ptr, 0, Tuple.__sizeof__()) if ptr: string.memset(ptr, 0, Tuple.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
elts: rawptr[list[rawptr[AST]]], ctx: int): elts: list[AST*]*, ctx: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.elts = elts self.elts = elts
self.ctx = ctx self.ctx = ctx
@@ -1110,20 +1110,20 @@ class Tuple(ExprNode):
class Slice(ExprNode): class Slice(ExprNode):
"""Slice(lower: AST, upper: AST, step: AST)""" """Slice(lower: AST, upper: AST, step: AST)"""
lower: rawptr[AST] lower: AST*
upper: rawptr[AST] upper: AST*
step: rawptr[AST] step: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
lower: rawptr[AST], upper: rawptr[AST], lower: AST*, upper: AST*,
step: rawptr[AST]): step: AST*):
ptr: rawptr[Slice] = pool.alloc(Slice.__sizeof__()) ptr: Slice* = pool.alloc(Slice.__sizeof__())
if ptr: string.memset(ptr, 0, Slice.__sizeof__()) if ptr: string.memset(ptr, 0, Slice.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
lower: rawptr[AST], upper: rawptr[AST], lower: AST*, upper: AST*,
step: rawptr[AST]): step: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.lower = lower self.lower = lower
self.upper = upper self.upper = upper
@@ -1161,17 +1161,17 @@ class Slice(ExprNode):
class NamedExpr(ExprNode): class NamedExpr(ExprNode):
"""NamedExpr(target: AST, value: AST)""" """NamedExpr(target: AST, value: AST)"""
target: rawptr[AST] target: AST*
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
target: rawptr[AST], value: rawptr[AST]): target: AST*, value: AST*):
ptr: rawptr[NamedExpr] = pool.alloc(NamedExpr.__sizeof__()) ptr: NamedExpr* = pool.alloc(NamedExpr.__sizeof__())
if ptr: string.memset(ptr, 0, NamedExpr.__sizeof__()) if ptr: string.memset(ptr, 0, NamedExpr.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
target: rawptr[AST], value: rawptr[AST]): target: AST*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.target = target self.target = target
self.value = value self.value = value
@@ -1205,12 +1205,12 @@ class OpNode(AST):
"""OpNode(op: CInt)""" """OpNode(op: CInt)"""
op: int op: int
def __new__(self, pool: rawptr[memhub.MemManager], op: int): def __new__(self, pool: memhub.MemManager*, op: int):
ptr: rawptr[OpNode] = pool.alloc(OpNode.__sizeof__()) ptr: OpNode* = pool.alloc(OpNode.__sizeof__())
if ptr: string.memset(ptr, 0, OpNode.__sizeof__()) if ptr: string.memset(ptr, 0, OpNode.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], op: int): def __init__(self, pool: memhub.MemManager*, op: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.op = op self.op = op
ast/lexer.vp
+35 -35
View File
@@ -307,17 +307,17 @@ class Lexer:
len: sizet # Source code length len: sizet # Source code length
lineno: int # Current line number (1-based) lineno: int # Current line number (1-based)
col: int # Current column number (0-based) col: int # Current column number (0-based)
pool: rawptr[memhub.MemManager] # Memory pool pool: memhub.MemManager* # Memory pool
indent_stack: rawptr[int] # Indent stack (int array, allocated from pool) indent_stack: int* # Indent stack (int array, allocated from pool)
indent_top: int # Stack top (-1 for empty stack) indent_top: int # Stack top (-1 for empty stack)
paren_depth: int # Paren depth (>0 for no TokenType.NewLine) paren_depth: int # Paren depth (>0 for no TokenType.NewLine)
tokens_head: rawptr[Token] # token list head tokens_head: Token* # token list head
tokens_tail: rawptr[Token] # token list tail tokens_tail: Token* # token list tail
at_line_start: int # 1=line start (need indent) at_line_start: int # 1=line start (need indent)
error_count: int # Error count error_count: int # Error count
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
ptr: rawptr[Lexer] = pool.alloc(Lexer.__sizeof__()) ptr: Lexer* = pool.alloc(Lexer.__sizeof__())
if ptr == None: if ptr == None:
# Pool exhausted: fail-fast instead of returning NULL (downstream would treat NULL as a valid Lexer) # Pool exhausted: fail-fast instead of returning NULL (downstream would treat NULL as a valid Lexer)
stdio.printf("[AST] Lexer 分配失败：内存池已耗尽（need=%zu 字节）\n", stdio.printf("[AST] Lexer 分配失败：内存池已耗尽（need=%zu 字节）\n",
@@ -328,12 +328,12 @@ class Lexer:
return ptr return ptr
def new_lexer(pool: rawptr[memhub.MemManager]) -> rawptr[Lexer]: def new_lexer(pool: memhub.MemManager*) -> Lexer*:
"""Allocate from the pool and return a Lexer (cross-module safe wrapper)""" """Allocate from the pool and return a Lexer (cross-module safe wrapper)"""
return Lexer(pool) return Lexer(pool)
def _lexer_init(lx: rawptr[Lexer], src: str, pool: rawptr[memhub.MemManager]): def _lexer_init(lx: Lexer*, src: str, pool: memhub.MemManager*):
"""Initialize Lexer""" """Initialize Lexer"""
if lx == None: return if lx == None: return
lx.src = src lx.src = src
@@ -366,19 +366,19 @@ def _lexer_init(lx: rawptr[Lexer], src: str, pool: rawptr[memhub.MemManager]):
# Auxiliary Functions # Auxiliary Functions
# ============================================================ # ============================================================
def _peek(lx: rawptr[Lexer], offset: sizet) -> char: def _peek(lx: Lexer*, offset: sizet) -> char:
"""Peek character at position pos+offset, return '\0' if out of bounds""" """Peek character at position pos+offset, return '\0' if out of bounds"""
p: sizet = lx.pos + offset p: sizet = lx.pos + offset
if p >= lx.len: return '\0' if p >= lx.len: return '\0'
return lx.src[p] return lx.src[p]
def _peek_cur(lx: rawptr[Lexer]) -> char: def _peek_cur(lx: Lexer*) -> char:
if lx.pos >= lx.len: return '\0' if lx.pos >= lx.len: return '\0'
return lx.src[lx.pos] return lx.src[lx.pos]
def _advance(lx: rawptr[Lexer]) -> char: def _advance(lx: Lexer*) -> char:
"""Advance one character, return the character""" """Advance one character, return the character"""
if lx.pos >= lx.len: return '\0' if lx.pos >= lx.len: return '\0'
ch: char = lx.src[lx.pos] ch: char = lx.src[lx.pos]
@@ -433,7 +433,7 @@ def _is_space(ch: char) -> int:
return 0 return 0
def _emit(lx: rawptr[Lexer], tok: rawptr[Token]): def _emit(lx: Lexer*, tok: Token*):
"""Append token to token list""" """Append token to token list"""
if tok == None: return if tok == None: return
if lx.tokens_head == None: if lx.tokens_head == None:
@@ -444,9 +444,9 @@ def _emit(lx: rawptr[Lexer], tok: rawptr[Token]):
lx.tokens_tail = tok lx.tokens_tail = tok
def _make_op_token(lx: rawptr[Lexer], op_id: int, length: int, def _make_op_token(lx: Lexer*, op_id: int, length: int,
lineno: int, col: int) -> rawptr[Token]: lineno: int, col: int) -> Token*:
tok: rawptr[Token] = new_token(lx.pool, TokenType.Op, lineno, col) tok: Token* = new_token(lx.pool, TokenType.Op, lineno, col)
if tok == None: return None if tok == None: return None
tok.op_subtype = op_id tok.op_subtype = op_id
tok.end_col_offset = col + length tok.end_col_offset = col + length
@@ -457,7 +457,7 @@ def _make_op_token(lx: rawptr[Lexer], op_id: int, length: int,
# Indent Handling # Indent Handling
# ============================================================ # ============================================================
def _handle_indent(lx: rawptr[Lexer]): def _handle_indent(lx: Lexer*):
"""Handle line start indent, generate TokenType.Indent/TokenType.Dedent. """Handle line start indent, generate TokenType.Indent/TokenType.Dedent.
Skip empty lines and comment lines.""" Skip empty lines and comment lines."""
# Skip empty lines and comment lines # Skip empty lines and comment lines
@@ -544,12 +544,12 @@ def _handle_indent(lx: rawptr[Lexer]):
return return
lx.indent_top += 1 lx.indent_top += 1
lx.indent_stack[lx.indent_top] = indent lx.indent_stack[lx.indent_top] = indent
tok: rawptr[Token] = new_token(lx.pool, TokenType.Indent, lx.lineno, 0) tok: Token* = new_token(lx.pool, TokenType.Indent, lx.lineno, 0)
_emit(lx, tok) _emit(lx, tok)
else: else:
while indent < lx.indent_stack[lx.indent_top] and lx.indent_top > 0: while indent < lx.indent_stack[lx.indent_top] and lx.indent_top > 0:
lx.indent_top -= 1 lx.indent_top -= 1
tok: rawptr[Token] = new_token(lx.pool, TokenType.Dedent, lx.lineno, 0) tok: Token* = new_token(lx.pool, TokenType.Dedent, lx.lineno, 0)
_emit(lx, tok) _emit(lx, tok)
lx.at_line_start = 0 lx.at_line_start = 0
@@ -558,7 +558,7 @@ def _handle_indent(lx: rawptr[Lexer]):
# Identifier/Keyword Handling # Identifier/Keyword Handling
# ============================================================ # ============================================================
def _read_name(lx: rawptr[Lexer]): def _read_name(lx: Lexer*):
start: sizet = lx.pos start: sizet = lx.pos
start_lineno: int = lx.lineno start_lineno: int = lx.lineno
start_col: int = lx.col start_col: int = lx.col
@@ -570,7 +570,7 @@ def _read_name(lx: rawptr[Lexer]):
else: else:
break break
length: sizet = lx.pos - start length: sizet = lx.pos - start
tok: rawptr[Token] = new_token(lx.pool, TokenType.Name, start_lineno, start_col) tok: Token* = new_token(lx.pool, TokenType.Name, start_lineno, start_col)
if tok == None: return if tok == None: return
token_set_str(lx.pool, tok, lx.src, start, length) token_set_str(lx.pool, tok, lx.src, start, length)
tok.end_lineno = lx.lineno tok.end_lineno = lx.lineno
@@ -585,7 +585,7 @@ def _read_name(lx: rawptr[Lexer]):
# Number Handling # Number Handling
# ============================================================ # ============================================================
def _read_number(lx: rawptr[Lexer]): def _read_number(lx: Lexer*):
start: sizet = lx.pos start: sizet = lx.pos
start_lineno: int = lx.lineno start_lineno: int = lx.lineno
start_col: int = lx.col start_col: int = lx.col
@@ -688,11 +688,11 @@ def _read_number(lx: rawptr[Lexer]):
_emit_number(lx, start, start_lineno, start_col, is_float, is_complex, 0) _emit_number(lx, start, start_lineno, start_col, is_float, is_complex, 0)
def _emit_number(lx: rawptr[Lexer], start: sizet, def _emit_number(lx: Lexer*, start: sizet,
start_lineno: int, start_col: int, start_lineno: int, start_col: int,
is_float: int, is_complex: int, is_hex: int): is_float: int, is_complex: int, is_hex: int):
length: sizet = lx.pos - start length: sizet = lx.pos - start
tok: rawptr[Token] = new_token(lx.pool, TokenType.Number, start_lineno, start_col) tok: Token* = new_token(lx.pool, TokenType.Number, start_lineno, start_col)
if tok == None: return if tok == None: return
token_set_str(lx.pool, tok, lx.src, start, length) token_set_str(lx.pool, tok, lx.src, start, length)
tok.is_float = is_float tok.is_float = is_float
@@ -715,7 +715,7 @@ def _emit_number(lx: rawptr[Lexer], start: sizet,
# String Handling # String Handling
# ============================================================ # ============================================================
def _read_string(lx: rawptr[Lexer]): def _read_string(lx: Lexer*):
"""Read string literal. """Read string literal.
Supports prefixes: r, b, u, f, rb, br, rf, fr (case insensitive) Supports prefixes: r, b, u, f, rb, br, rf, fr (case insensitive)
Supports quotes: ', ", ''', Supports quotes: ', ", ''',
@@ -875,7 +875,7 @@ def _read_string(lx: rawptr[Lexer]):
lx.col += 1 lx.col += 1
# Create token # Create token
tok: rawptr[Token] = new_token(lx.pool, TokenType.String, start_lineno, start_col) tok: Token* = new_token(lx.pool, TokenType.String, start_lineno, start_col)
if tok == None: return if tok == None: return
content_len: sizet = content_end - content_buf_start content_len: sizet = content_end - content_buf_start
# esc_len: Actual bytes after escaping (used to check single character) # esc_len: Actual bytes after escaping (used to check single character)
@@ -968,16 +968,16 @@ def _read_string(lx: rawptr[Lexer]):
# Operator Matching # Operator Matching
# ============================================================ # ============================================================
def _read_operator(lx: rawptr[Lexer]): def _read_operator(lx: Lexer*):
"""Greedy match operator""" """Greedy match operator"""
start_lineno: int = lx.lineno start_lineno: int = lx.lineno
start_col: int = lx.col start_col: int = lx.col
remaining: sizet = lx.len - lx.pos remaining: sizet = lx.len - lx.pos
# Traverse operator table, find longest match # Traverse operator table, find longest match
best_entry: rawptr[OpEntry] = None best_entry: OpEntry* = None
best_len: int = 0 best_len: int = 0
cur: rawptr[OpEntry] = _op_head cur: OpEntry* = _op_head
while cur != None: while cur != None:
if cur.length <= int(remaining): if cur.length <= int(remaining):
# Compare cur.name with src[pos:pos+cur.length] # Compare cur.name with src[pos:pos+cur.length]
@@ -1006,7 +1006,7 @@ def _read_operator(lx: rawptr[Lexer]):
if lx.paren_depth > 0: if lx.paren_depth > 0:
lx.paren_depth -= 1 lx.paren_depth -= 1
tok: rawptr[Token] = _make_op_token(lx, best_entry.op_id, best_entry.length, tok: Token* = _make_op_token(lx, best_entry.op_id, best_entry.length,
start_lineno, start_col) start_lineno, start_col)
if tok == None: return if tok == None: return
token_set_str(lx.pool, tok, lx.src, lx.pos, sizet(best_len)) token_set_str(lx.pool, tok, lx.src, lx.pos, sizet(best_len))
@@ -1019,7 +1019,7 @@ def _read_operator(lx: rawptr[Lexer]):
# Main Lexical Analysis Entry Point # Main Lexical Analysis Entry Point
# ============================================================ # ============================================================
def tokenize(lx: rawptr[Lexer]) -> rawptr[Token]: def tokenize(lx: Lexer*) -> Token*:
"""Execute tokenization, return token list head""" """Execute tokenization, return token list head"""
if lx == None: return None if lx == None: return None
while lx.pos < lx.len: while lx.pos < lx.len:
@@ -1037,11 +1037,11 @@ def tokenize(lx: rawptr[Lexer]) -> rawptr[Token]:
if ch == '\n': if ch == '\n':
if lx.paren_depth > 0: if lx.paren_depth > 0:
# # In bi brackets, generates TokenType.Nl # # In bi brackets, generates TokenType.Nl
tok: rawptr[Token] = new_token(lx.pool, TokenType.Nl, lx.lineno, lx.col) tok: Token* = new_token(lx.pool, TokenType.Nl, lx.lineno, lx.col)
_emit(lx, tok) _emit(lx, tok)
else: else:
# Logical new line # Logical new line
tok: rawptr[Token] = new_token(lx.pool, TokenType.NewLine, lx.lineno, lx.col) tok: Token* = new_token(lx.pool, TokenType.NewLine, lx.lineno, lx.col)
_emit(lx, tok) _emit(lx, tok)
lx.at_line_start = 1 lx.at_line_start = 1
lx.pos += 1 lx.pos += 1
@@ -1116,17 +1116,17 @@ def tokenize(lx: rawptr[Lexer]) -> rawptr[Token]:
# End of file: generate TokenType.NewLine (if there's content) # End of file: generate TokenType.NewLine (if there's content)
if lx.tokens_tail != None: if lx.tokens_tail != None:
if lx.tokens_tail.type != TokenType.NewLine and lx.tokens_tail.type != TokenType.Nl: if lx.tokens_tail.type != TokenType.NewLine and lx.tokens_tail.type != TokenType.Nl:
tok: rawptr[Token] = new_token(lx.pool, TokenType.NewLine, lx.lineno, lx.col) tok: Token* = new_token(lx.pool, TokenType.NewLine, lx.lineno, lx.col)
_emit(lx, tok) _emit(lx, tok)
# Generate remaining remaining TokenType.Dedent # Generate remaining remaining TokenType.Dedent
while lx.indent_top > 0: while lx.indent_top > 0:
lx.indent_top -= 1 lx.indent_top -= 1
tok: rawptr[Token] = new_token(lx.pool, TokenType.Dedent, lx.lineno, 0) tok: Token* = new_token(lx.pool, TokenType.Dedent, lx.lineno, 0)
_emit(lx, tok) _emit(lx, tok)
# TokenType.EndMarker # TokenType.EndMarker
tok: rawptr[Token] = new_token(lx.pool, TokenType.EndMarker, lx.lineno, 0) tok: Token* = new_token(lx.pool, TokenType.EndMarker, lx.lineno, 0)
_emit(lx, tok) _emit(lx, tok)
return lx.tokens_head return lx.tokens_head
ast/match.vp
+61 -61
View File
@@ -14,17 +14,17 @@ from .base import (
# ============================================================ # ============================================================
class MatchCase(AST): class MatchCase(AST):
"""MatchCase(pattern: AST, guard: AST)""" """MatchCase(pattern: AST, guard: AST)"""
pattern: rawptr[AST] pattern: AST*
guard: rawptr[AST] guard: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
pattern: rawptr[AST], guard: rawptr[AST]): pattern: AST*, guard: AST*):
ptr: rawptr[MatchCase] = pool.alloc(MatchCase.__sizeof__()) ptr: MatchCase* = pool.alloc(MatchCase.__sizeof__())
if ptr: string.memset(ptr, 0, MatchCase.__sizeof__()) if ptr: string.memset(ptr, 0, MatchCase.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
pattern: rawptr[AST], guard: rawptr[AST]): pattern: AST*, guard: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.pattern = pattern self.pattern = pattern
self.guard = guard self.guard = guard
@@ -53,14 +53,14 @@ class MatchCase(AST):
# ============================================================ # ============================================================
class MatchValue(AST): class MatchValue(AST):
"""MatchValue(value: AST)""" """MatchValue(value: AST)"""
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, value: AST*):
ptr: rawptr[MatchValue] = pool.alloc(MatchValue.__sizeof__()) ptr: MatchValue* = pool.alloc(MatchValue.__sizeof__())
if ptr: string.memset(ptr, 0, MatchValue.__sizeof__()) if ptr: string.memset(ptr, 0, MatchValue.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
@@ -83,14 +83,14 @@ class MatchValue(AST):
# ============================================================ # ============================================================
class MatchSingleton(AST): class MatchSingleton(AST):
"""MatchSingleton(value: AST)""" """MatchSingleton(value: AST)"""
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, value: AST*):
ptr: rawptr[MatchSingleton] = pool.alloc(MatchSingleton.__sizeof__()) ptr: MatchSingleton* = pool.alloc(MatchSingleton.__sizeof__())
if ptr: string.memset(ptr, 0, MatchSingleton.__sizeof__()) if ptr: string.memset(ptr, 0, MatchSingleton.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
@@ -113,16 +113,16 @@ class MatchSingleton(AST):
# ============================================================ # ============================================================
class MatchSequence(AST): class MatchSequence(AST):
"""MatchSequence(patterns: list[rawptr[AST]])""" """MatchSequence(patterns: list[rawptr[AST]])"""
patterns: rawptr[list[rawptr[AST]]] patterns: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
patterns: rawptr[list[rawptr[AST]]]): patterns: list[AST*]*):
ptr: rawptr[MatchSequence] = pool.alloc(MatchSequence.__sizeof__()) ptr: MatchSequence* = pool.alloc(MatchSequence.__sizeof__())
if ptr: string.memset(ptr, 0, MatchSequence.__sizeof__()) if ptr: string.memset(ptr, 0, MatchSequence.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
patterns: rawptr[list[rawptr[AST]]]): patterns: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.patterns = patterns self.patterns = patterns
_set_parent_list(patterns, self) _set_parent_list(patterns, self)
@@ -145,21 +145,21 @@ class MatchSequence(AST):
# ============================================================ # ============================================================
class MatchMapping(AST): class MatchMapping(AST):
"""MatchMapping(keys: list[rawptr[AST]], patterns: list[rawptr[AST]], rest: str)""" """MatchMapping(keys: list[rawptr[AST]], patterns: list[rawptr[AST]], rest: str)"""
keys: rawptr[list[rawptr[AST]]] keys: list[AST*]*
patterns: rawptr[list[rawptr[AST]]] patterns: list[AST*]*
rest: str rest: str
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
keys: rawptr[list[rawptr[AST]]], keys: list[AST*]*,
patterns: rawptr[list[rawptr[AST]]], patterns: list[AST*]*,
rest: str): rest: str):
ptr: rawptr[MatchMapping] = pool.alloc(MatchMapping.__sizeof__()) ptr: MatchMapping* = pool.alloc(MatchMapping.__sizeof__())
if ptr: string.memset(ptr, 0, MatchMapping.__sizeof__()) if ptr: string.memset(ptr, 0, MatchMapping.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
keys: rawptr[list[rawptr[AST]]], keys: list[AST*]*,
patterns: rawptr[list[rawptr[AST]]], patterns: list[AST*]*,
rest: str): rest: str):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.keys = keys self.keys = keys
@@ -191,26 +191,26 @@ class MatchMapping(AST):
class MatchClass(AST): class MatchClass(AST):
"""MatchClass(cls: AST, patterns: list[rawptr[AST]], """MatchClass(cls: AST, patterns: list[rawptr[AST]],
kwd_attrs: list[rawptr[AST]], kwd_patterns: list[rawptr[AST]])""" kwd_attrs: list[AST*], kwd_patterns: list[AST*])"""
cls: rawptr[AST] cls: AST*
patterns: rawptr[list[rawptr[AST]]] patterns: list[AST*]*
kwd_attrs: rawptr[list[rawptr[AST]]] kwd_attrs: list[AST*]*
kwd_patterns: rawptr[list[rawptr[AST]]] kwd_patterns: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
cls: rawptr[AST], cls: AST*,
patterns: rawptr[list[rawptr[AST]]], patterns: list[AST*]*,
kwd_attrs: rawptr[list[rawptr[AST]]], kwd_attrs: list[AST*]*,
kwd_patterns: rawptr[list[rawptr[AST]]]): kwd_patterns: list[AST*]*):
ptr: rawptr[MatchClass] = pool.alloc(MatchClass.__sizeof__()) ptr: MatchClass* = pool.alloc(MatchClass.__sizeof__())
if ptr: string.memset(ptr, 0, MatchClass.__sizeof__()) if ptr: string.memset(ptr, 0, MatchClass.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
cls: rawptr[AST], cls: AST*,
patterns: rawptr[list[rawptr[AST]]], patterns: list[AST*]*,
kwd_attrs: rawptr[list[rawptr[AST]]], kwd_attrs: list[AST*]*,
kwd_patterns: rawptr[list[rawptr[AST]]]): kwd_patterns: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.cls = cls self.cls = cls
self.patterns = patterns self.patterns = patterns
@@ -247,12 +247,12 @@ class MatchStar(AST):
"""MatchStar(name: str)""" """MatchStar(name: str)"""
name: str name: str
def __new__(self, pool: rawptr[memhub.MemManager], name: str): def __new__(self, pool: memhub.MemManager*, name: str):
ptr: rawptr[MatchStar] = pool.alloc(MatchStar.__sizeof__()) ptr: MatchStar* = pool.alloc(MatchStar.__sizeof__())
if ptr: string.memset(ptr, 0, MatchStar.__sizeof__()) if ptr: string.memset(ptr, 0, MatchStar.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], name: str): def __init__(self, pool: memhub.MemManager*, name: str):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.name = _copy_str(pool, name) self.name = _copy_str(pool, name)
@@ -275,17 +275,17 @@ class MatchStar(AST):
class MatchAs(AST): class MatchAs(AST):
"""MatchAs(pattern: AST, name: str)""" """MatchAs(pattern: AST, name: str)"""
pattern: rawptr[AST] pattern: AST*
name: str name: str
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
pattern: rawptr[AST], name: str): pattern: AST*, name: str):
ptr: rawptr[MatchAs] = pool.alloc(MatchAs.__sizeof__()) ptr: MatchAs* = pool.alloc(MatchAs.__sizeof__())
if ptr: string.memset(ptr, 0, MatchAs.__sizeof__()) if ptr: string.memset(ptr, 0, MatchAs.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
pattern: rawptr[AST], name: str): pattern: AST*, name: str):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.pattern = pattern self.pattern = pattern
self.name = _copy_str(pool, name) self.name = _copy_str(pool, name)
@@ -311,16 +311,16 @@ class MatchAs(AST):
class MatchOr(AST): class MatchOr(AST):
"""MatchOr(patterns: list[rawptr[AST]])""" """MatchOr(patterns: list[rawptr[AST]])"""
patterns: rawptr[list[rawptr[AST]]] patterns: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
patterns: rawptr[list[rawptr[AST]]]): patterns: list[AST*]*):
ptr: rawptr[MatchOr] = pool.alloc(MatchOr.__sizeof__()) ptr: MatchOr* = pool.alloc(MatchOr.__sizeof__())
if ptr: string.memset(ptr, 0, MatchOr.__sizeof__()) if ptr: string.memset(ptr, 0, MatchOr.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
patterns: rawptr[list[rawptr[AST]]]): patterns: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.patterns = patterns self.patterns = patterns
_set_parent_list(patterns, self) _set_parent_list(patterns, self)
ast/parser.vp
+628 -628
View File
File diff suppressed because it is too large. Load diff
ast/stmts.vp
+200 -200
View File
@@ -16,12 +16,12 @@ from .base import (
virtual class Module(AST): virtual class Module(AST):
"""Module(children: list[rawptr[AST]])""" """Module(children: list[rawptr[AST]])"""
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
ptr: rawptr[Module] = pool.alloc(Module.__sizeof__()) ptr: Module* = pool.alloc(Module.__sizeof__())
if ptr: string.memset(ptr, 0, Module.__sizeof__()) if ptr: string.memset(ptr, 0, Module.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager]): def __init__(self, pool: memhub.MemManager*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
def kind(self) -> int: def kind(self) -> int:
@@ -43,17 +43,17 @@ virtual class Module(AST):
class Assign(Stmt): class Assign(Stmt):
"""Assign(targets: list[rawptr[AST]], value: AST)""" """Assign(targets: list[rawptr[AST]], value: AST)"""
targets: rawptr[list[rawptr[AST]]] targets: list[AST*]*
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
targets: rawptr[list[rawptr[AST]]], value: rawptr[AST]): targets: list[AST*]*, value: AST*):
ptr: rawptr[Assign] = pool.alloc(Assign.__sizeof__()) ptr: Assign* = pool.alloc(Assign.__sizeof__())
if ptr: string.memset(ptr, 0, Assign.__sizeof__()) if ptr: string.memset(ptr, 0, Assign.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
targets: rawptr[list[rawptr[AST]]], value: rawptr[AST]): targets: list[AST*]*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.targets = targets self.targets = targets
self.value = value self.value = value
@@ -83,19 +83,19 @@ class Assign(Stmt):
class If(Stmt): class If(Stmt):
"""If(test: AST, orelse: list[rawptr[AST]])""" """If(test: AST, orelse: list[rawptr[AST]])"""
test: rawptr[AST] test: AST*
orelse: rawptr[list[rawptr[AST]]] orelse: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
test: rawptr[AST], test: AST*,
orelse: rawptr[list[rawptr[AST]]]): orelse: list[AST*]*):
ptr: rawptr[If] = pool.alloc(If.__sizeof__()) ptr: If* = pool.alloc(If.__sizeof__())
if ptr: string.memset(ptr, 0, If.__sizeof__()) if ptr: string.memset(ptr, 0, If.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
test: rawptr[AST], test: AST*,
orelse: rawptr[list[rawptr[AST]]]): orelse: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.test = test self.test = test
self.orelse = orelse self.orelse = orelse
@@ -127,22 +127,22 @@ class If(Stmt):
class For(Stmt): class For(Stmt):
"""For(target: AST, iter: AST, orelse: list[rawptr[AST]], is_async: CInt)""" """For(target: AST, iter: AST, orelse: list[rawptr[AST]], is_async: CInt)"""
target: rawptr[AST] target: AST*
iter: rawptr[AST] iter: AST*
orelse: rawptr[list[rawptr[AST]]] orelse: list[AST*]*
flags: int flags: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
target: rawptr[AST], iter: rawptr[AST], target: AST*, iter: AST*,
orelse: rawptr[list[rawptr[AST]]], orelse: list[AST*]*,
is_async: int): is_async: int):
ptr: rawptr[For] = pool.alloc(For.__sizeof__()) ptr: For* = pool.alloc(For.__sizeof__())
if ptr: string.memset(ptr, 0, For.__sizeof__()) if ptr: string.memset(ptr, 0, For.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
target: rawptr[AST], iter: rawptr[AST], target: AST*, iter: AST*,
orelse: rawptr[list[rawptr[AST]]], orelse: list[AST*]*,
is_async: int): is_async: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.target = target self.target = target
@@ -183,19 +183,19 @@ class For(Stmt):
class While(Stmt): class While(Stmt):
"""While(test: AST, orelse: list[rawptr[AST]])""" """While(test: AST, orelse: list[rawptr[AST]])"""
test: rawptr[AST] test: AST*
orelse: rawptr[list[rawptr[AST]]] orelse: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
test: rawptr[AST], test: AST*,
orelse: rawptr[list[rawptr[AST]]]): orelse: list[AST*]*):
ptr: rawptr[While] = pool.alloc(While.__sizeof__()) ptr: While* = pool.alloc(While.__sizeof__())
if ptr: string.memset(ptr, 0, While.__sizeof__()) if ptr: string.memset(ptr, 0, While.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
test: rawptr[AST], test: AST*,
orelse: rawptr[list[rawptr[AST]]]): orelse: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.test = test self.test = test
self.orelse = orelse self.orelse = orelse
@@ -225,14 +225,14 @@ class While(Stmt):
class Return(Stmt): class Return(Stmt):
"""Return(value: AST | None)""" """Return(value: AST | None)"""
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, value: AST*):
ptr: rawptr[Return] = pool.alloc(Return.__sizeof__()) ptr: Return* = pool.alloc(Return.__sizeof__())
if ptr: string.memset(ptr, 0, Return.__sizeof__()) if ptr: string.memset(ptr, 0, Return.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
@@ -258,14 +258,14 @@ class Return(Stmt):
class Expr(Stmt): class Expr(Stmt):
"""Expr(value: AST)""" """Expr(value: AST)"""
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __new__(self, pool: memhub.MemManager*, value: AST*):
ptr: rawptr[Expr] = pool.alloc(Expr.__sizeof__()) ptr: Expr* = pool.alloc(Expr.__sizeof__())
if ptr: string.memset(ptr, 0, Expr.__sizeof__()) if ptr: string.memset(ptr, 0, Expr.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], value: rawptr[AST]): def __init__(self, pool: memhub.MemManager*, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.value = value self.value = value
@@ -291,31 +291,31 @@ class Expr(Stmt):
class FunctionDef(Stmt): class FunctionDef(Stmt):
"""FunctionDef(name: str, args: AST, """FunctionDef(name: str, args: AST,
decorator_list: list[rawptr[AST]], returns: AST, flags: CInt, decorator_list: list[AST*], returns: AST, flags: CInt,
type_params: rawptr[list[str]] = None) type_params: list[str]* = None)
type_params: generic function type-parameter name list (the [T] in PEP 695 def f[T](...)), type_params: generic function type-parameter name list (the [T] in PEP 695 def f[T](...)),
None means a non-generic function.""" None means a non-generic function."""
name: str name: str
args: rawptr[AST] args: AST*
decorator_list: rawptr[list[rawptr[AST]]] decorator_list: list[AST*]*
returns: rawptr[AST] returns: AST*
flags: int flags: int
type_params: rawptr[list[str]] type_params: list[str]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
name: str, args: rawptr[AST], name: str, args: AST*,
decorator_list: rawptr[list[rawptr[AST]]], decorator_list: list[AST*]*,
returns: rawptr[AST], is_async: int): returns: AST*, is_async: int):
ptr: rawptr[FunctionDef] = pool.alloc(FunctionDef.__sizeof__()) ptr: FunctionDef* = pool.alloc(FunctionDef.__sizeof__())
if ptr: string.memset(ptr, 0, FunctionDef.__sizeof__()) if ptr: string.memset(ptr, 0, FunctionDef.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
name: str, args: rawptr[AST], name: str, args: AST*,
decorator_list: rawptr[list[rawptr[AST]]], decorator_list: list[AST*]*,
returns: rawptr[AST], is_async: int, returns: AST*, is_async: int,
type_params: rawptr[list[str]] = None): type_params: list[str]* = None):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.name = _copy_str(pool, name) self.name = _copy_str(pool, name)
self.args = args self.args = args
@@ -361,16 +361,16 @@ class FunctionDef(Stmt):
class Expression(AST): class Expression(AST):
"""Expression(body: AST)""" """Expression(body: AST)"""
body: rawptr[AST] body: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
body: rawptr[AST]): body: AST*):
ptr: rawptr[Expression] = pool.alloc(Expression.__sizeof__()) ptr: Expression* = pool.alloc(Expression.__sizeof__())
if ptr: string.memset(ptr, 0, Expression.__sizeof__()) if ptr: string.memset(ptr, 0, Expression.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
body: rawptr[AST]): body: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.body = body self.body = body
@@ -396,16 +396,16 @@ class Expression(AST):
class Interactive(AST): class Interactive(AST):
"""Interactive(body: AST)""" """Interactive(body: AST)"""
body: rawptr[AST] body: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
body: rawptr[AST]): body: AST*):
ptr: rawptr[Interactive] = pool.alloc(Interactive.__sizeof__()) ptr: Interactive* = pool.alloc(Interactive.__sizeof__())
if ptr: string.memset(ptr, 0, Interactive.__sizeof__()) if ptr: string.memset(ptr, 0, Interactive.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
body: rawptr[AST]): body: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.body = body self.body = body
@@ -431,19 +431,19 @@ class Interactive(AST):
class FunctionType(AST): class FunctionType(AST):
"""FunctionType(argtypes: list[rawptr[AST]], returns: AST)""" """FunctionType(argtypes: list[rawptr[AST]], returns: AST)"""
argtypes: rawptr[list[rawptr[AST]]] argtypes: list[AST*]*
returns: rawptr[AST] returns: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
argtypes: rawptr[list[rawptr[AST]]], argtypes: list[AST*]*,
returns: rawptr[AST]): returns: AST*):
ptr: rawptr[FunctionType] = pool.alloc(FunctionType.__sizeof__()) ptr: FunctionType* = pool.alloc(FunctionType.__sizeof__())
if ptr: string.memset(ptr, 0, FunctionType.__sizeof__()) if ptr: string.memset(ptr, 0, FunctionType.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
argtypes: rawptr[list[rawptr[AST]]], argtypes: list[AST*]*,
returns: rawptr[AST]): returns: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.argtypes = argtypes self.argtypes = argtypes
self.returns = returns self.returns = returns
@@ -472,32 +472,32 @@ class FunctionType(AST):
class ClassDef(Stmt): class ClassDef(Stmt):
"""ClassDef(name: str, bases: list[rawptr[AST]], keywords: list[rawptr[AST]], """ClassDef(name: str, bases: list[rawptr[AST]], keywords: list[rawptr[AST]],
decorator_list: list[rawptr[AST]], type_params: rawptr[list[str]]) decorator_list: list[AST*], type_params: list[str]*)
type_params: generic type-parameter name list (the [T] in PEP 695 class list[T]:), type_params: generic type-parameter name list (the [T] in PEP 695 class list[T]:),
None means a non-generic class.""" None means a non-generic class."""
name: str name: str
bases: rawptr[list[rawptr[AST]]] bases: list[AST*]*
keywords: rawptr[list[rawptr[AST]]] keywords: list[AST*]*
decorator_list: rawptr[list[rawptr[AST]]] decorator_list: list[AST*]*
type_params: rawptr[list[str]] type_params: list[str]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
name: str, name: str,
bases: rawptr[list[rawptr[AST]]], bases: list[AST*]*,
keywords: rawptr[list[rawptr[AST]]], keywords: list[AST*]*,
decorator_list: rawptr[list[rawptr[AST]]], decorator_list: list[AST*]*,
type_params: rawptr[list[str]] = None): type_params: list[str]* = None):
ptr: rawptr[ClassDef] = pool.alloc(ClassDef.__sizeof__()) ptr: ClassDef* = pool.alloc(ClassDef.__sizeof__())
if ptr: string.memset(ptr, 0, ClassDef.__sizeof__()) if ptr: string.memset(ptr, 0, ClassDef.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
name: str, name: str,
bases: rawptr[list[rawptr[AST]]], bases: list[AST*]*,
keywords: rawptr[list[rawptr[AST]]], keywords: list[AST*]*,
decorator_list: rawptr[list[rawptr[AST]]], decorator_list: list[AST*]*,
type_params: rawptr[list[str]] = None): type_params: list[str]* = None):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.name = _copy_str(pool, name) self.name = _copy_str(pool, name)
self.bases = bases self.bases = bases
@@ -533,16 +533,16 @@ class ClassDef(Stmt):
class Delete(Stmt): class Delete(Stmt):
"""Delete(targets: list[rawptr[AST]])""" """Delete(targets: list[rawptr[AST]])"""
targets: rawptr[list[rawptr[AST]]] targets: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
targets: rawptr[list[rawptr[AST]]]): targets: list[AST*]*):
ptr: rawptr[Delete] = pool.alloc(Delete.__sizeof__()) ptr: Delete* = pool.alloc(Delete.__sizeof__())
if ptr: string.memset(ptr, 0, Delete.__sizeof__()) if ptr: string.memset(ptr, 0, Delete.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
targets: rawptr[list[rawptr[AST]]]): targets: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.targets = targets self.targets = targets
_set_parent_list(targets, self) _set_parent_list(targets, self)
@@ -566,18 +566,18 @@ class Delete(Stmt):
class AugAssign(Stmt): class AugAssign(Stmt):
"""AugAssign(target: AST, op: CInt, value: AST)""" """AugAssign(target: AST, op: CInt, value: AST)"""
target: rawptr[AST] target: AST*
op: int op: int
value: rawptr[AST] value: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
target: rawptr[AST], op: int, value: rawptr[AST]): target: AST*, op: int, value: AST*):
ptr: rawptr[AugAssign] = pool.alloc(AugAssign.__sizeof__()) ptr: AugAssign* = pool.alloc(AugAssign.__sizeof__())
if ptr: string.memset(ptr, 0, AugAssign.__sizeof__()) if ptr: string.memset(ptr, 0, AugAssign.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
target: rawptr[AST], op: int, value: rawptr[AST]): target: AST*, op: int, value: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.target = target self.target = target
self.op = op self.op = op
@@ -612,21 +612,21 @@ class AugAssign(Stmt):
class AnnAssign(Stmt): class AnnAssign(Stmt):
"""AnnAssign(target: AST, annotation: AST, value: AST, simple: CInt)""" """AnnAssign(target: AST, annotation: AST, value: AST, simple: CInt)"""
target: rawptr[AST] target: AST*
annotation: rawptr[AST] annotation: AST*
value: rawptr[AST] value: AST*
simple: int simple: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
target: rawptr[AST], annotation: rawptr[AST], target: AST*, annotation: AST*,
value: rawptr[AST], simple: int): value: AST*, simple: int):
ptr: rawptr[AnnAssign] = pool.alloc(AnnAssign.__sizeof__()) ptr: AnnAssign* = pool.alloc(AnnAssign.__sizeof__())
if ptr: string.memset(ptr, 0, AnnAssign.__sizeof__()) if ptr: string.memset(ptr, 0, AnnAssign.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
target: rawptr[AST], annotation: rawptr[AST], target: AST*, annotation: AST*,
value: rawptr[AST], simple: int): value: AST*, simple: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.target = target self.target = target
self.annotation = annotation self.annotation = annotation
@@ -667,18 +667,18 @@ class AnnAssign(Stmt):
class With(Stmt): class With(Stmt):
"""With(items: list[rawptr[AST]], is_async: CInt)""" """With(items: list[rawptr[AST]], is_async: CInt)"""
items: rawptr[list[rawptr[AST]]] items: list[AST*]*
flags: int flags: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
items: rawptr[list[rawptr[AST]]], items: list[AST*]*,
is_async: int): is_async: int):
ptr: rawptr[With] = pool.alloc(With.__sizeof__()) ptr: With* = pool.alloc(With.__sizeof__())
if ptr: string.memset(ptr, 0, With.__sizeof__()) if ptr: string.memset(ptr, 0, With.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
items: rawptr[list[rawptr[AST]]], items: list[AST*]*,
is_async: int): is_async: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.items = items self.items = items
@@ -709,17 +709,17 @@ class With(Stmt):
class Raise(Stmt): class Raise(Stmt):
"""Raise(exc: AST, cause: AST)""" """Raise(exc: AST, cause: AST)"""
exc: rawptr[AST] exc: AST*
cause: rawptr[AST] cause: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
exc: rawptr[AST], cause: rawptr[AST]): exc: AST*, cause: AST*):
ptr: rawptr[Raise] = pool.alloc(Raise.__sizeof__()) ptr: Raise* = pool.alloc(Raise.__sizeof__())
if ptr: string.memset(ptr, 0, Raise.__sizeof__()) if ptr: string.memset(ptr, 0, Raise.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
exc: rawptr[AST], cause: rawptr[AST]): exc: AST*, cause: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.exc = exc self.exc = exc
self.cause = cause self.cause = cause
@@ -751,23 +751,23 @@ class Raise(Stmt):
class Try(Stmt): class Try(Stmt):
"""Try(handlers: list[rawptr[AST]], """Try(handlers: list[rawptr[AST]],
orelse: list[rawptr[AST]], finalbody: list[rawptr[AST]])""" orelse: list[AST*], finalbody: list[AST*])"""
handlers: rawptr[list[rawptr[AST]]] handlers: list[AST*]*
orelse: rawptr[list[rawptr[AST]]] orelse: list[AST*]*
finalbody: rawptr[list[rawptr[AST]]] finalbody: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
handlers: rawptr[list[rawptr[AST]]], handlers: list[AST*]*,
orelse: rawptr[list[rawptr[AST]]], orelse: list[AST*]*,
finalbody: rawptr[list[rawptr[AST]]]): finalbody: list[AST*]*):
ptr: rawptr[Try] = pool.alloc(Try.__sizeof__()) ptr: Try* = pool.alloc(Try.__sizeof__())
if ptr: string.memset(ptr, 0, Try.__sizeof__()) if ptr: string.memset(ptr, 0, Try.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
handlers: rawptr[list[rawptr[AST]]], handlers: list[AST*]*,
orelse: rawptr[list[rawptr[AST]]], orelse: list[AST*]*,
finalbody: rawptr[list[rawptr[AST]]]): finalbody: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.handlers = handlers self.handlers = handlers
self.orelse = orelse self.orelse = orelse
@@ -801,17 +801,17 @@ class Try(Stmt):
class Assert(Stmt): class Assert(Stmt):
"""Assert(test: AST, msg: AST)""" """Assert(test: AST, msg: AST)"""
test: rawptr[AST] test: AST*
msg: rawptr[AST] msg: AST*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
test: rawptr[AST], msg: rawptr[AST]): test: AST*, msg: AST*):
ptr: rawptr[Assert] = pool.alloc(Assert.__sizeof__()) ptr: Assert* = pool.alloc(Assert.__sizeof__())
if ptr: string.memset(ptr, 0, Assert.__sizeof__()) if ptr: string.memset(ptr, 0, Assert.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
test: rawptr[AST], msg: rawptr[AST]): test: AST*, msg: AST*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.test = test self.test = test
self.msg = msg self.msg = msg
@@ -843,16 +843,16 @@ class Assert(Stmt):
class Global(Stmt): class Global(Stmt):
"""Global(names: list[rawptr[AST]])""" """Global(names: list[rawptr[AST]])"""
names: rawptr[list[rawptr[AST]]] names: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
names: rawptr[list[rawptr[AST]]]): names: list[AST*]*):
ptr: rawptr[Global] = pool.alloc(Global.__sizeof__()) ptr: Global* = pool.alloc(Global.__sizeof__())
if ptr: string.memset(ptr, 0, Global.__sizeof__()) if ptr: string.memset(ptr, 0, Global.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
names: rawptr[list[rawptr[AST]]]): names: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.names = names self.names = names
_set_parent_list(names, self) _set_parent_list(names, self)
@@ -876,16 +876,16 @@ class Global(Stmt):
class Nonlocal(Stmt): class Nonlocal(Stmt):
"""Nonlocal(names: list[rawptr[AST]])""" """Nonlocal(names: list[rawptr[AST]])"""
names: rawptr[list[rawptr[AST]]] names: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
names: rawptr[list[rawptr[AST]]]): names: list[AST*]*):
ptr: rawptr[Nonlocal] = pool.alloc(Nonlocal.__sizeof__()) ptr: Nonlocal* = pool.alloc(Nonlocal.__sizeof__())
if ptr: string.memset(ptr, 0, Nonlocal.__sizeof__()) if ptr: string.memset(ptr, 0, Nonlocal.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
names: rawptr[list[rawptr[AST]]]): names: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.names = names self.names = names
_set_parent_list(names, self) _set_parent_list(names, self)
@@ -910,12 +910,12 @@ class Nonlocal(Stmt):
class Pass(Stmt): class Pass(Stmt):
"""Pass()""" """Pass()"""
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
ptr: rawptr[Pass] = pool.alloc(Pass.__sizeof__()) ptr: Pass* = pool.alloc(Pass.__sizeof__())
if ptr: string.memset(ptr, 0, Pass.__sizeof__()) if ptr: string.memset(ptr, 0, Pass.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager]): def __init__(self, pool: memhub.MemManager*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
def kind(self) -> int: def kind(self) -> int:
@@ -936,12 +936,12 @@ class Pass(Stmt):
class Break(Stmt): class Break(Stmt):
"""Break()""" """Break()"""
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
ptr: rawptr[Break] = pool.alloc(Break.__sizeof__()) ptr: Break* = pool.alloc(Break.__sizeof__())
if ptr: string.memset(ptr, 0, Break.__sizeof__()) if ptr: string.memset(ptr, 0, Break.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager]): def __init__(self, pool: memhub.MemManager*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
def kind(self) -> int: def kind(self) -> int:
@@ -962,12 +962,12 @@ class Break(Stmt):
class Continue(Stmt): class Continue(Stmt):
"""Continue()""" """Continue()"""
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
ptr: rawptr[Continue] = pool.alloc(Continue.__sizeof__()) ptr: Continue* = pool.alloc(Continue.__sizeof__())
if ptr: string.memset(ptr, 0, Continue.__sizeof__()) if ptr: string.memset(ptr, 0, Continue.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager]): def __init__(self, pool: memhub.MemManager*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
def kind(self) -> int: def kind(self) -> int:
@@ -988,12 +988,12 @@ class Continue(Stmt):
class FallThrough(Stmt): class FallThrough(Stmt):
"""FallThrough() - a switch case body does not auto-break, so it falls through to the next case""" """FallThrough() - a switch case body does not auto-break, so it falls through to the next case"""
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
ptr: rawptr[FallThrough] = pool.alloc(FallThrough.__sizeof__()) ptr: FallThrough* = pool.alloc(FallThrough.__sizeof__())
if ptr: string.memset(ptr, 0, FallThrough.__sizeof__()) if ptr: string.memset(ptr, 0, FallThrough.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager]): def __init__(self, pool: memhub.MemManager*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
def kind(self) -> int: def kind(self) -> int:
@@ -1013,16 +1013,16 @@ class FallThrough(Stmt):
class Import(Stmt): class Import(Stmt):
"""Import(names: list[rawptr[AST]])""" """Import(names: list[rawptr[AST]])"""
names: rawptr[list[rawptr[AST]]] names: list[AST*]*
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
names: rawptr[list[rawptr[AST]]]): names: list[AST*]*):
ptr: rawptr[Import] = pool.alloc(Import.__sizeof__()) ptr: Import* = pool.alloc(Import.__sizeof__())
if ptr: string.memset(ptr, 0, Import.__sizeof__()) if ptr: string.memset(ptr, 0, Import.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
names: rawptr[list[rawptr[AST]]]): names: list[AST*]*):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.names = names self.names = names
_set_parent_list(names, self) _set_parent_list(names, self)
@@ -1047,20 +1047,20 @@ class Import(Stmt):
class ImportFrom(Stmt): class ImportFrom(Stmt):
"""ImportFrom(module: str, names: list[rawptr[AST]], level: CInt)""" """ImportFrom(module: str, names: list[rawptr[AST]], level: CInt)"""
module: str module: str
names: rawptr[list[rawptr[AST]]] names: list[AST*]*
level: int level: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
module: str, module: str,
names: rawptr[list[rawptr[AST]]], names: list[AST*]*,
level: int): level: int):
ptr: rawptr[ImportFrom] = pool.alloc(ImportFrom.__sizeof__()) ptr: ImportFrom* = pool.alloc(ImportFrom.__sizeof__())
if ptr: string.memset(ptr, 0, ImportFrom.__sizeof__()) if ptr: string.memset(ptr, 0, ImportFrom.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
module: str, module: str,
names: rawptr[list[rawptr[AST]]], names: list[AST*]*,
level: int): level: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.module = _copy_str(pool, module) self.module = _copy_str(pool, module)
@@ -1095,21 +1095,21 @@ class Match(Stmt):
is_switch=1: from `switch <expr>:` sugar (see _parse_switch), C semantics (no fall-through without 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). `fallthrough`). is_switch=0: real `match`, fallthrough is completely forbidden (fail-fast).
""" """
subject: rawptr[AST] subject: AST*
cases: rawptr[list[rawptr[AST]]] cases: list[AST*]*
is_switch: int is_switch: int
def __new__(self, pool: rawptr[memhub.MemManager], def __new__(self, pool: memhub.MemManager*,
subject: rawptr[AST], subject: AST*,
cases: rawptr[list[rawptr[AST]]], cases: list[AST*]*,
is_switch: int): is_switch: int):
ptr: rawptr[Match] = pool.alloc(Match.__sizeof__()) ptr: Match* = pool.alloc(Match.__sizeof__())
if ptr: string.memset(ptr, 0, Match.__sizeof__()) if ptr: string.memset(ptr, 0, Match.__sizeof__())
return ptr return ptr
def __init__(self, pool: rawptr[memhub.MemManager], def __init__(self, pool: memhub.MemManager*,
subject: rawptr[AST], subject: AST*,
cases: rawptr[list[rawptr[AST]]], cases: list[AST*]*,
is_switch: int): is_switch: int):
_init_ast(self, pool, 0, 0) _init_ast(self, pool, 0, 0)
self.subject = subject self.subject = subject
ast/tokens.vp
+26 -26
View File
@@ -200,11 +200,11 @@ class Token:
col_offset: int # Starting column offset col_offset: int # Starting column offset
end_lineno: int # Ending line number end_lineno: int # Ending line number
end_col_offset: int # Ending column offset end_col_offset: int # Ending column offset
next: rawptr[Token] # Next token in linked list next: Token* # Next token in linked list
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
"""Allocate zero‑initialized Token struct memory from mpool""" """Allocate zero‑initialized Token struct memory from mpool"""
ptr: rawptr[Token] = pool.alloc(Token.__sizeof__()) ptr: Token* = pool.alloc(Token.__sizeof__())
if ptr == None: if ptr == None:
_ast_pool_fatal("Token", sizet(Token.__sizeof__())) _ast_pool_fatal("Token", sizet(Token.__sizeof__()))
string.memset(ptr, 0, Token.__sizeof__()) string.memset(ptr, 0, Token.__sizeof__())
@@ -218,10 +218,10 @@ class Token:
class KwEntry: class KwEntry:
name: str name: str
kw_id: int kw_id: int
next: rawptr[KwEntry] next: KwEntry*
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
ptr: rawptr[KwEntry] = pool.alloc(KwEntry.__sizeof__()) ptr: KwEntry* = pool.alloc(KwEntry.__sizeof__())
if ptr == None: if ptr == None:
_ast_pool_fatal("KwEntry", sizet(KwEntry.__sizeof__())) _ast_pool_fatal("KwEntry", sizet(KwEntry.__sizeof__()))
string.memset(ptr, 0, KwEntry.__sizeof__()) string.memset(ptr, 0, KwEntry.__sizeof__())
@@ -229,8 +229,8 @@ class KwEntry:
# Global keyword linked list head (lazy initialization) # Global keyword linked list head (lazy initialization)
_kw_head: rawptr[KwEntry] = None _kw_head: KwEntry* = None
_kw_pool: rawptr[memhub.MemManager] = None _kw_pool: memhub.MemManager* = None
# Keyword hash index (open addressing, linear probing): slot u64, 0 = empty else KwEntry address; # Keyword hash index (open addressing, linear probing): slot u64, 0 = empty else KwEntry address;
# expected O(1) lookups, falling back to the list only when not built (alloc failure). Miss returns 0. # expected O(1) lookups, falling back to the list only when not built (alloc failure). Miss returns 0.
@@ -253,7 +253,7 @@ def _kw_hash_str(key: str) -> uint64:
return uint64(h) return uint64(h)
def _kw_index_put(entry: rawptr[KwEntry]): def _kw_index_put(entry: KwEntry*):
"""Write a keyword entry into the hash index (silently skipped if not built); a duplicate key keeps """Write a keyword entry into the hash index (silently skipped if not built); a duplicate key keeps
the first registrant, and collisions are separated by strcmp (hash alone could return a wrong kw_id).""" the first registrant, and collisions are separated by strcmp (hash alone could return a wrong kw_id)."""
if _kw_index == None: return if _kw_index == None: return
@@ -272,10 +272,10 @@ def _kw_index_put(entry: rawptr[KwEntry]):
idx = (idx + 1) & mask idx = (idx + 1) & mask
def _kw_intern(pool: rawptr[memhub.MemManager], name: str, kw_id: int): def _kw_intern(pool: memhub.MemManager*, name: str, kw_id: int):
"""Register keyword name in the linked list""" """Register keyword name in the linked list"""
global _kw_head global _kw_head
entry: rawptr[KwEntry] = KwEntry(pool) entry: KwEntry* = KwEntry(pool)
if entry == None: return if entry == None: return
slen: sizet = string.strlen(name) slen: sizet = string.strlen(name)
buf: str = pool.alloc(slen + 1) buf: str = pool.alloc(slen + 1)
@@ -313,7 +313,7 @@ def _kw_lookup(name: str) -> int:
return cur.kw_id return cur.kw_id
idx = (idx + 1) & mask idx = (idx + 1) & mask
return 0 return 0
cur2: rawptr[KwEntry] = _kw_head cur2: KwEntry* = _kw_head
while cur2 != None: while cur2 != None:
if string.strcmp(cur2.name, name) == 0: if string.strcmp(cur2.name, name) == 0:
return cur2.kw_id return cur2.kw_id
@@ -321,7 +321,7 @@ def _kw_lookup(name: str) -> int:
return 0 return 0
def _init_keywords(pool: rawptr[memhub.MemManager]): def _init_keywords(pool: memhub.MemManager*):
"""Initialize keyword linked list (only once)""" """Initialize keyword linked list (only once)"""
global _kw_head, _kw_pool, _kw_index global _kw_head, _kw_pool, _kw_index
if _kw_head != None: return if _kw_head != None: return
@@ -406,21 +406,21 @@ class OpEntry:
name: str # Operator text (e.g. "==", "+=") name: str # Operator text (e.g. "==", "+=")
op_id: int op_id: int
length: int length: int
next: rawptr[OpEntry] next: OpEntry*
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
ptr: rawptr[OpEntry] = pool.alloc(OpEntry.__sizeof__()) ptr: OpEntry* = pool.alloc(OpEntry.__sizeof__())
if ptr: string.memset(ptr, 0, OpEntry.__sizeof__()) if ptr: string.memset(ptr, 0, OpEntry.__sizeof__())
return ptr return ptr
_op_head: rawptr[OpEntry] = None _op_head: OpEntry* = None
def _op_intern(pool: rawptr[memhub.MemManager], name: str, op_id: int): def _op_intern(pool: memhub.MemManager*, name: str, op_id: int):
global _op_head global _op_head
slen: sizet = string.strlen(name) slen: sizet = string.strlen(name)
entry: rawptr[OpEntry] = OpEntry(pool) entry: OpEntry* = OpEntry(pool)
if entry == None: return if entry == None: return
buf: str = pool.alloc(slen + 1) buf: str = pool.alloc(slen + 1)
if buf == None: return if buf == None: return
@@ -432,7 +432,7 @@ def _op_intern(pool: rawptr[memhub.MemManager], name: str, op_id: int):
_op_head = entry _op_head = entry
def _init_operators(pool: rawptr[memhub.MemManager]): def _init_operators(pool: memhub.MemManager*):
"""Initialize the operator table (register in descending length order for easy greedy matching)""" """Initialize the operator table (register in descending length order for easy greedy matching)"""
global _op_head global _op_head
if _op_head != None: return if _op_head != None: return
@@ -488,7 +488,7 @@ def _init_operators(pool: rawptr[memhub.MemManager]):
_op_intern(pool, "~", TokOp.Tilde) _op_intern(pool, "~", TokOp.Tilde)
def _init_tables(pool: rawptr[memhub.MemManager]): def _init_tables(pool: memhub.MemManager*):
"""Initialize all lookup tables (idempotent)""" """Initialize all lookup tables (idempotent)"""
_init_keywords(pool) _init_keywords(pool)
_init_operators(pool) _init_operators(pool)
@@ -498,10 +498,10 @@ def _init_tables(pool: rawptr[memhub.MemManager]):
# Token creation helper functions # Token creation helper functions
# ============================================================ # ============================================================
def new_token(pool: rawptr[memhub.MemManager], ttype: int, lineno: int, def new_token(pool: memhub.MemManager*, ttype: int, lineno: int,
col_offset: int) -> rawptr[Token]: col_offset: int) -> Token*:
"""Create a new empty Token and fill in fields later""" """Create a new empty Token and fill in fields later"""
tok: rawptr[Token] = Token(pool) tok: Token* = Token(pool)
if tok == None: return None if tok == None: return None
tok.type = ttype tok.type = ttype
tok.lineno = lineno tok.lineno = lineno
@@ -511,7 +511,7 @@ def new_token(pool: rawptr[memhub.MemManager], ttype: int, lineno: int,
return tok return tok
def token_set_str(pool: rawptr[memhub.MemManager], tok: rawptr[Token], def token_set_str(pool: memhub.MemManager*, tok: Token*,
src: str, start: sizet, length: sizet): src: str, start: sizet, length: sizet):
"""Copy text from src[start:start + length] to token.str_val """Copy text from src[start:start + length] to token.str_val
@@ -527,7 +527,7 @@ def token_set_str(pool: rawptr[memhub.MemManager], tok: rawptr[Token],
tok.str_val = buf tok.str_val = buf
def token_set_str_literal(pool: rawptr[memhub.MemManager], tok: rawptr[Token], def token_set_str_literal(pool: memhub.MemManager*, tok: Token*,
text: str): text: str):
"""Copy a C string to token.str_val""" """Copy a C string to token.str_val"""
if tok == None or text == None: return if tok == None or text == None: return
hashlib/__md5.vp
+1 -1
View File
@@ -48,7 +48,7 @@ class md5:
def __init__(self): def __init__(self):
string.memset(self.buf, 0, MD5_BLOCK_LEN) string.memset(self.buf, 0, MD5_BLOCK_LEN)
# MD5 single-group compression transform # MD5 single-group compression transform
def transform(self, block: rawptr[uint8]): def transform(self, block: uint8*):
a: uint32 = self.state[0] a: uint32 = self.state[0]
b: uint32 = self.state[1] b: uint32 = self.state[1]
c: uint32 = self.state[2] c: uint32 = self.state[2]
hashlib/__sha1.vp
+2 -2
View File
@@ -27,9 +27,9 @@ class sha1:
def __init__(self): def __init__(self):
string.memset(self.buf, 0, SHA1_BLOCK_LEN) string.memset(self.buf, 0, SHA1_BLOCK_LEN)
# Single-group compression transform # Single-group compression transform
def transform(self, block: rawptr[uint8]): def transform(self, block: uint8*):
w: [80]uint32 w: [80]uint32
data: rawptr[uint8] = block data: uint8* = block
# First 16 words # First 16 words
for i in range(16): for i in range(16):
w[i] = (((uint32(data[i * 4 + 0])) << 24) | w[i] = (((uint32(data[i * 4 + 0])) << 24) |
hashlib/__sha256.vp
+1 -1
View File
@@ -42,7 +42,7 @@ class sha256:
string.memset(self, 0, sha256.__sizeof__()) string.memset(self, 0, sha256.__sizeof__())
# string.memset(self.buf, 0, SHA256_BLOCK_LEN) # string.memset(self.buf, 0, SHA256_BLOCK_LEN)
# SHA256 single-group compression transform # SHA256 single-group compression transform
def transform(self, block: rawptr[uint8]): def transform(self, block: uint8*):
w: [64]uint32 w: [64]uint32
for i in range(16): for i in range(16):
w[i] = ((uint32(block[i * 4 + 0]) << 24) | w[i] = ((uint32(block[i * 4 + 0]) << 24) |
json/__init__.vp
+10 -10
View File
@@ -31,7 +31,7 @@ class JsonValue:
child: 'JsonValue' | t.CPtr child: 'JsonValue' | t.CPtr
child_count: sizet child_count: sizet
def __new__(self, pool: rawptr[memhub.MemManager]): def __new__(self, pool: memhub.MemManager*):
"""Allocate and zero-initialize a JsonValue struct from mpool.""" """Allocate and zero-initialize a JsonValue struct from mpool."""
ptr: JsonValue* = pool.alloc(JsonValue.__sizeof__()) ptr: JsonValue* = pool.alloc(JsonValue.__sizeof__())
if ptr: if ptr:
@@ -148,34 +148,34 @@ class JsonValue:
# Constructors: create each kind of JsonValue (allocated from mpool) # Constructors: create each kind of JsonValue (allocated from mpool)
# ============================================================ # ============================================================
def null(pool: rawptr[memhub.MemManager]) -> JsonValue*: def null(pool: memhub.MemManager*) -> JsonValue*:
v: JsonValue* = JsonValue(pool) v: JsonValue* = JsonValue(pool)
if v == None: return None if v == None: return None
v.vtype = JSON_NULL v.vtype = JSON_NULL
return v return v
def bool_val(pool: rawptr[memhub.MemManager], val: bool) -> JsonValue*: def bool_val(pool: memhub.MemManager*, val: bool) -> JsonValue*:
v: JsonValue* = JsonValue(pool) v: JsonValue* = JsonValue(pool)
if v == None: return None if v == None: return None
v.vtype = JSON_BOOL v.vtype = JSON_BOOL
v.bool_val = 1 if val else 0 v.bool_val = 1 if val else 0
return v return v
def int_val(pool: rawptr[memhub.MemManager], val: int64) -> JsonValue*: def int_val(pool: memhub.MemManager*, val: int64) -> JsonValue*:
v: JsonValue* = JsonValue(pool) v: JsonValue* = JsonValue(pool)
if v == None: return None if v == None: return None
v.vtype = JSON_INT v.vtype = JSON_INT
v.int_val = val v.int_val = val
return v return v
def float_val(pool: rawptr[memhub.MemManager], val: double) -> JsonValue*: def float_val(pool: memhub.MemManager*, val: double) -> JsonValue*:
v: JsonValue* = JsonValue(pool) v: JsonValue* = JsonValue(pool)
if v == None: return None if v == None: return None
v.vtype = JSON_FLOAT v.vtype = JSON_FLOAT
v.float_val = val v.float_val = val
return v return v
def string_val(pool: rawptr[memhub.MemManager], val: str) -> JsonValue*: def string_val(pool: memhub.MemManager*, val: str) -> JsonValue*:
v: JsonValue* = JsonValue(pool) v: JsonValue* = JsonValue(pool)
if v == None: return None if v == None: return None
v.vtype = JSON_STRING v.vtype = JSON_STRING
@@ -187,26 +187,26 @@ def string_val(pool: rawptr[memhub.MemManager], val: str) -> JsonValue*:
v.str_val = buf v.str_val = buf
return v return v
def array(pool: rawptr[memhub.MemManager]) -> JsonValue*: def array(pool: memhub.MemManager*) -> JsonValue*:
v: JsonValue* = JsonValue(pool) v: JsonValue* = JsonValue(pool)
if v == None: return None if v == None: return None
v.vtype = JSON_ARRAY v.vtype = JSON_ARRAY
return v return v
def object(pool: rawptr[memhub.MemManager]) -> JsonValue*: def object(pool: memhub.MemManager*) -> JsonValue*:
v: JsonValue* = JsonValue(pool) v: JsonValue* = JsonValue(pool)
if v == None: return None if v == None: return None
v.vtype = JSON_OBJECT v.vtype = JSON_OBJECT
return v return v
# Append an element to an array # Append an element to an array
def array_append(pool: rawptr[memhub.MemManager], arr: JsonValue*, item: JsonValue*): def array_append(pool: memhub.MemManager*, arr: JsonValue*, item: JsonValue*):
if arr == None or item == None: return if arr == None or item == None: return
if arr.vtype != JSON_ARRAY: return if arr.vtype != JSON_ARRAY: return
arr._append_child(item) arr._append_child(item)
# Set a key/value pair on an object # Set a key/value pair on an object
def object_set(pool: rawptr[memhub.MemManager], obj: JsonValue*, key: str, val: JsonValue*): def object_set(pool: memhub.MemManager*, obj: JsonValue*, key: str, val: JsonValue*):
if obj == None or key == None or val == None: return if obj == None or key == None or val == None: return
if obj.vtype != JSON_OBJECT: return if obj.vtype != JSON_OBJECT: return
cur: JsonValue* = obj.child cur: JsonValue* = obj.child
json/__parser.vp
+17 -17
View File
@@ -13,25 +13,25 @@ class ParseState:
src: str src: str
pos: sizet = 0 pos: sizet = 0
len: sizet = 0 len: sizet = 0
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
def __init__(self, src: str, pool: rawptr[memhub.MemManager]): def __init__(self, src: str, pool: memhub.MemManager*):
self.src = src self.src = src
self.len = string.strlen(src) if src != None else 0 self.len = string.strlen(src) if src != None else 0
self.pool = pool self.pool = pool
def _peek(s: rawptr[ParseState]) -> char: def _peek(s: ParseState*) -> char:
if s.pos >= s.len: return '\0' if s.pos >= s.len: return '\0'
return s.src[s.pos] return s.src[s.pos]
def _advance(s: rawptr[ParseState]) -> char: def _advance(s: ParseState*) -> char:
if s.pos >= s.len: return '\0' if s.pos >= s.len: return '\0'
ch: char = s.src[s.pos] ch: char = s.src[s.pos]
s.pos += 1 s.pos += 1
return ch return ch
def _skip_whitespace(s: rawptr[ParseState]): def _skip_whitespace(s: ParseState*):
while s.pos < s.len: while s.pos < s.len:
ch: char = s.src[s.pos] ch: char = s.src[s.pos]
if ch == ' ' or ch == '\t' or ch == '\n' or ch == '\r': if ch == ' ' or ch == '\t' or ch == '\n' or ch == '\r':
@@ -39,7 +39,7 @@ def _skip_whitespace(s: rawptr[ParseState]):
else: else:
break break
def _expect(s: rawptr[ParseState], ch: char) -> bool: def _expect(s: ParseState*, ch: char) -> bool:
_skip_whitespace(s) _skip_whitespace(s)
if s.pos >= s.len: return False if s.pos >= s.len: return False
if s.src[s.pos] != ch: return False if s.src[s.pos] != ch: return False
@@ -47,7 +47,7 @@ def _expect(s: rawptr[ParseState], ch: char) -> bool:
return True return True
def _parse_string(s: rawptr[ParseState]) -> str: def _parse_string(s: ParseState*) -> str:
if _peek(s) != '"': return None if _peek(s) != '"': return None
_advance(s) _advance(s)
@@ -103,7 +103,7 @@ def _parse_string(s: rawptr[ParseState]) -> str:
return buf return buf
def _parse_number(s: rawptr[ParseState]) -> rawptr[JsonValue]: def _parse_number(s: ParseState*) -> JsonValue*:
_skip_whitespace(s) _skip_whitespace(s)
is_float: bool = False is_float: bool = False
start: sizet = s.pos start: sizet = s.pos
@@ -157,7 +157,7 @@ def _parse_number(s: rawptr[ParseState]) -> rawptr[JsonValue]:
return int_val(s.pool, ival) return int_val(s.pool, ival)
def _parse_value(s: rawptr[ParseState]) -> rawptr[JsonValue]: def _parse_value(s: ParseState*) -> JsonValue*:
_skip_whitespace(s) _skip_whitespace(s)
if s.pos >= s.len: if s.pos >= s.len:
return null(s.pool) return null(s.pool)
@@ -201,11 +201,11 @@ def _parse_value(s: rawptr[ParseState]) -> rawptr[JsonValue]:
return null(s.pool) return null(s.pool)
def _parse_array(s: rawptr[ParseState]) -> rawptr[JsonValue]: def _parse_array(s: ParseState*) -> JsonValue*:
if not _expect(s, '['): if not _expect(s, '['):
return null(s.pool) return null(s.pool)
arr: rawptr[JsonValue] = array(s.pool) arr: JsonValue* = array(s.pool)
# Pool exhausted => array() returns None; continuing to arr._append_child(...) would deref # Pool exhausted => array() returns None; continuing to arr._append_child(...) would deref
# a null pointer, so return None here (json.parse may return None; callers must check). # a null pointer, so return None here (json.parse may return None; callers must check).
if arr == None: if arr == None:
@@ -216,7 +216,7 @@ def _parse_array(s: rawptr[ParseState]) -> rawptr[JsonValue]:
_advance(s) _advance(s)
return arr return arr
item: rawptr[JsonValue] = _parse_value(s) item: JsonValue* = _parse_value(s)
# item == None iff allocation failed somewhere inside _parse_value (syntax errors yield # item == None iff allocation failed somewhere inside _parse_value (syntax errors yield
# a valid JSON_NULL node; only pool exhaustion yields None) => return None, append nothing. # a valid JSON_NULL node; only pool exhaustion yields None) => return None, append nothing.
if item == None: if item == None:
@@ -239,11 +239,11 @@ def _parse_array(s: rawptr[ParseState]) -> rawptr[JsonValue]:
return arr return arr
def _parse_object(s: rawptr[ParseState]) -> rawptr[JsonValue]: def _parse_object(s: ParseState*) -> JsonValue*:
if not _expect(s, '{'): if not _expect(s, '{'):
return null(s.pool) return null(s.pool)
obj: rawptr[JsonValue] = object(s.pool) obj: JsonValue* = object(s.pool)
# Same as _parse_array: obj is None on pool exhaustion; do not call _append_child on None. # Same as _parse_array: obj is None on pool exhaustion; do not call _append_child on None.
if obj == None: if obj == None:
return null(s.pool) return null(s.pool)
@@ -256,7 +256,7 @@ def _parse_object(s: rawptr[ParseState]) -> rawptr[JsonValue]:
_skip_whitespace(s) _skip_whitespace(s)
key: str = _parse_string(s) key: str = _parse_string(s)
_expect(s, ':') _expect(s, ':')
val: rawptr[JsonValue] = _parse_value(s) val: JsonValue* = _parse_value(s)
if key != None and val != None: if key != None and val != None:
klen: sizet = string.strlen(key) klen: sizet = string.strlen(key)
kbuf: str = s.pool.alloc(klen + 1) kbuf: str = s.pool.alloc(klen + 1)
@@ -288,9 +288,9 @@ def _parse_object(s: rawptr[ParseState]) -> rawptr[JsonValue]:
return obj return obj
def parse(pool: rawptr[memhub.MemManager], src: str) -> rawptr[JsonValue]: def parse(pool: memhub.MemManager*, src: str) -> JsonValue*:
"""Parse a JSON string, returning a JsonValue tree.""" """Parse a JSON string, returning a JsonValue tree."""
if src == None: if src == None:
return null(pool) return null(pool)
s: rawptr[ParseState] = ParseState(src, pool) s: ParseState* = ParseState(src, pool)
return _parse_value(s) return _parse_value(s)
json/__writer.vp
+5 -5
View File
@@ -71,8 +71,8 @@ def _write_string_escaped(buf: str, pos: sizet, cap: sizet, s: str) -> sizet:
return pos return pos
def _write_value(buf: str, pos: sizet, cap: sizet, val: rawptr[JsonValue], def _write_value(buf: str, pos: sizet, cap: sizet, val: JsonValue*,
pool: rawptr[memhub.MemManager]) -> sizet: pool: memhub.MemManager*) -> sizet:
if pos >= cap: if pos >= cap:
return pos # already overflowed: stop writing (recursion converges here) return pos # already overflowed: stop writing (recursion converges here)
if val == None: if val == None:
@@ -108,7 +108,7 @@ def _write_value(buf: str, pos: sizet, cap: sizet, val: rawptr[JsonValue],
pos = _write_str(buf, pos, cap, "[]") pos = _write_str(buf, pos, cap, "[]")
return pos return pos
pos = _write_char(buf, pos, cap, '[') pos = _write_char(buf, pos, cap, '[')
cur: rawptr[JsonValue] = val.child cur: JsonValue* = val.child
first: bool = True first: bool = True
while cur != None: while cur != None:
if pos >= cap: if pos >= cap:
@@ -125,7 +125,7 @@ def _write_value(buf: str, pos: sizet, cap: sizet, val: rawptr[JsonValue],
pos = _write_str(buf, pos, cap, "{}") pos = _write_str(buf, pos, cap, "{}")
return pos return pos
pos = _write_char(buf, pos, cap, '{') pos = _write_char(buf, pos, cap, '{')
cur2: rawptr[JsonValue] = val.child cur2: JsonValue* = val.child
first2: bool = True first2: bool = True
while cur2 != None: while cur2 != None:
if pos >= cap: if pos >= cap:
@@ -144,7 +144,7 @@ def _write_value(buf: str, pos: sizet, cap: sizet, val: rawptr[JsonValue],
# Serialize to a JSON string. cap = output buffer size (bytes, incl trailing NUL), default 4096. # Serialize to a JSON string. cap = output buffer size (bytes, incl trailing NUL), default 4096.
# Returns None when content does not fit (never writes past the buffer). # Returns None when content does not fit (never writes past the buffer).
def write(pool: rawptr[memhub.MemManager], val: rawptr[JsonValue], pretty: bool, def write(pool: memhub.MemManager*, val: JsonValue*, pretty: bool,
cap: sizet = 4096) -> str: cap: sizet = 4096) -> str:
"""Serialize a JsonValue into a JSON string.""" """Serialize a JsonValue into a JSON string."""
if cap < 2: if cap < 2:
memhub.vp
+1 -1
View File
@@ -453,7 +453,7 @@ def NewMemPool(base: rawptr, size: sizet) -> MemPool*:
# detection) and then calls the existing virtual alloc => no new virtual function, no vtable change, # detection) and then calls the existing virtual alloc => no new virtual function, no vtable change,
# no contract change; for a MemBuddy pool its alloc_tagged is also available (that one additionally # no contract change; for a MemBuddy pool its alloc_tagged is also available (that one additionally
# records a record-table tag for [FREEFRAME] reports). # records a record-table tag for [FREEFRAME] reports).
def MemAllocTagged(pool: rawptr[MemManager], size: sizet, tag: sizet) -> rawptr: def MemAllocTagged(pool: MemManager*, size: sizet, tag: sizet) -> rawptr:
if pool is None: if pool is None:
return None return None
prev: uint64 = _alloc_site_enter(uint64(tag)) prev: uint64 = _alloc_site_enter(uint64(tag))
mlirlite/__builder.vp
+270 -270
View File
File diff suppressed because it is too large. Load diff
mlirlite/__function.vp
+109 -109
View File
@@ -50,7 +50,7 @@ novirtual class Line(GSListNode[Line]):
# ============================================================ # ============================================================
novirtual class BasicBlock(GSListNode[BasicBlock]): novirtual class BasicBlock(GSListNode[BasicBlock]):
Name: str # block name (e.g. "entry"/"if.then") Name: str # block name (e.g. "entry"/"if.then")
Lines: rawptr[GSList[Line]] # instruction-line list container (Head/Tail/Count) Lines: GSList[Line]* # instruction-line list container (Head/Tail/Count)
IsTerminated: int # 1=terminator present (br/ret) IsTerminated: int # 1=terminator present (br/ret)
@@ -63,7 +63,7 @@ novirtual class BasicBlock(GSListNode[BasicBlock]):
# NOTE: must carry @t.NoVTable (same reason as Line). # NOTE: must carry @t.NoVTable (same reason as Line).
# ============================================================ # ============================================================
novirtual class Param(GSListNode[Param]): novirtual class Param(GSListNode[Param]):
Ty: rawptr[LLVMType] # parameter type Ty: LLVMType* # parameter type
Name: str # parameter name (e.g. "%0"/"%a") Name: str # parameter name (e.g. "%0"/"%a")
Attrs: str # parameter attribute text (None=none) Attrs: str # parameter attribute text (None=none)
@@ -80,9 +80,9 @@ novirtual class Param(GSListNode[Param]):
# ============================================================ # ============================================================
novirtual class Function(GSListNode[Function]): novirtual class Function(GSListNode[Function]):
Name: str # function name Name: str # function name
RetTy: rawptr[LLVMType] # return type RetTy: LLVMType* # return type
Params: rawptr[GSList[Param]] # parameter list container Params: GSList[Param]* # parameter list container
Blocks: rawptr[GSList[BasicBlock]] # basic-block list container Blocks: GSList[BasicBlock]* # basic-block list container
IsDeclared: int # 1=declaration only (declare), 0=definition (define) IsDeclared: int # 1=declaration only (declare), 0=definition (define)
IsVarArg: int # 1=variadic function (...) IsVarArg: int # 1=variadic function (...)
Attrs: str # function attribute text (None=none) Attrs: str # function attribute text (None=none)
@@ -98,9 +98,9 @@ novirtual class Function(GSListNode[Function]):
# Line hardcoded size: Next(8) + Buf(8) + Len(8) = 24 bytes # Line hardcoded size: Next(8) + Buf(8) + Len(8) = 24 bytes
define LINE_SIZE = 24 define LINE_SIZE = 24
def new_line(pool: memhub.MemBuddy*, text: str) -> rawptr[Line]: def new_line(pool: memhub.MemBuddy*, text: str) -> Line*:
"""Create an instruction line, copying text into a newly allocated buffer""" """Create an instruction line, copying text into a newly allocated buffer"""
ptr: rawptr[Line] = pool.alloc(LINE_SIZE) ptr: Line* = pool.alloc(LINE_SIZE)
if ptr is None: return None if ptr is None: return None
string.memset(ptr, 0, LINE_SIZE) string.memset(ptr, 0, LINE_SIZE)
if text is not None: if text is not None:
@@ -124,9 +124,9 @@ def _new_gslist(pool: memhub.MemBuddy*, list_size: sizet) -> t.CPtr:
# BasicBlock hardcoded size: Next(8) + Name(8) + Lines(8) + IsTerminated(4) = 32 bytes # BasicBlock hardcoded size: Next(8) + Name(8) + Lines(8) + IsTerminated(4) = 32 bytes
define BLOCK_SIZE = 32 define BLOCK_SIZE = 32
def new_basic_block(pool: memhub.MemBuddy*, name: str) -> rawptr[BasicBlock]: def new_basic_block(pool: memhub.MemBuddy*, name: str) -> BasicBlock*:
"""Create a basic block""" """Create a basic block"""
ptr: rawptr[BasicBlock] = pool.alloc(BLOCK_SIZE) ptr: BasicBlock* = pool.alloc(BLOCK_SIZE)
if ptr is None: return None if ptr is None: return None
string.memset(ptr, 0, BLOCK_SIZE) string.memset(ptr, 0, BLOCK_SIZE)
ptr.Name = name ptr.Name = name
@@ -138,10 +138,10 @@ def new_basic_block(pool: memhub.MemBuddy*, name: str) -> rawptr[BasicBlock]:
# Param hardcoded size: Next(8) + Ty(8) + Name(8) + Attrs(8) = 32 bytes # Param hardcoded size: Next(8) + Ty(8) + Name(8) + Attrs(8) = 32 bytes
define PARAM_SIZE = 32 define PARAM_SIZE = 32
def new_param(pool: memhub.MemBuddy*, ty: rawptr[LLVMType], def new_param(pool: memhub.MemBuddy*, ty: LLVMType*,
name: str) -> rawptr[Param]: name: str) -> Param*:
"""Create a function parameter""" """Create a function parameter"""
ptr: rawptr[Param] = pool.alloc(PARAM_SIZE) ptr: Param* = pool.alloc(PARAM_SIZE)
if ptr is None: return None if ptr is None: return None
string.memset(ptr, 0, PARAM_SIZE) string.memset(ptr, 0, PARAM_SIZE)
ptr.Ty = ty ptr.Ty = ty
@@ -154,9 +154,9 @@ def new_param(pool: memhub.MemBuddy*, ty: rawptr[LLVMType],
define FUNC_SIZE = 88 define FUNC_SIZE = 88
def new_function(pool: memhub.MemBuddy*, name: str, def new_function(pool: memhub.MemBuddy*, name: str,
ret_ty: rawptr[LLVMType]) -> rawptr[Function]: ret_ty: LLVMType*) -> Function*:
"""Create a function""" """Create a function"""
ptr: rawptr[Function] = pool.alloc(FUNC_SIZE) ptr: Function* = pool.alloc(FUNC_SIZE)
if ptr is None: return None if ptr is None: return None
string.memset(ptr, 0, FUNC_SIZE) string.memset(ptr, 0, FUNC_SIZE)
ptr.Name = name ptr.Name = name
@@ -179,25 +179,25 @@ def new_function(pool: memhub.MemBuddy*, name: str,
# ============================================================ # ============================================================
# List operations (delegating to GSList.append) # List operations (delegating to GSList.append)
# ============================================================ # ============================================================
def function_add_param(func: rawptr[Function], param: rawptr[Param]): def function_add_param(func: Function*, param: Param*):
"""Append a parameter to the function's parameter list""" """Append a parameter to the function's parameter list"""
if func is None or param is None: return if func is None or param is None: return
# NOTE: use a local variable + type parameter (see function_move_block_to_end): chaining # NOTE: use a local variable + type parameter (see function_move_block_to_end): chaining
# func.Params.append() mis-resolves to LinkedNode.append and corrupts memory 48 bytes before the container. # func.Params.append() mis-resolves to LinkedNode.append and corrupts memory 48 bytes before the container.
params: rawptr[GSList[Param]] = func.Params params: GSList[Param]* = func.Params
if params is None: return if params is None: return
params.append(param) params.append(param)
def function_add_block(func: rawptr[Function], block: rawptr[BasicBlock]): def function_add_block(func: Function*, block: BasicBlock*):
"""Append a basic block to the function's block list""" """Append a basic block to the function's block list"""
if func is None or block is None: return if func is None or block is None: return
blocks: rawptr[GSList[BasicBlock]] = func.Blocks blocks: GSList[BasicBlock]* = func.Blocks
if blocks is None: return if blocks is None: return
blocks.append(block) blocks.append(block)
def function_move_block_to_end(func: rawptr[Function], block: rawptr[BasicBlock]): def function_move_block_to_end(func: Function*, block: BasicBlock*):
"""Move block to the end of the function's block list (BB text order == control-flow order). """Move block to the end of the function's block list (BB text order == control-flow order).
Fixes non-monotonic SSA numbering (BBs are created in order but instructions are emitted in Fixes non-monotonic SSA numbering (BBs are created in order but instructions are emitted in
@@ -206,7 +206,7 @@ def function_move_block_to_end(func: rawptr[Function], block: rawptr[BasicBlock]
type and blocks.Head/Tail/Count field reads return garbage. type and blocks.Head/Tail/Count field reads return garbage.
""" """
if func is None or block is None: return if func is None or block is None: return
blocks: rawptr[GSList[BasicBlock]] = func.Blocks blocks: GSList[BasicBlock]* = func.Blocks
if blocks is None: return if blocks is None: return
# Already Tail; nothing to move # Already Tail; nothing to move
@@ -219,7 +219,7 @@ def function_move_block_to_end(func: rawptr[Function], block: rawptr[BasicBlock]
blocks.Head = block.Next blocks.Head = block.Next
else: else:
# Walk to find the predecessor # Walk to find the predecessor
prev: rawptr[BasicBlock] = blocks.Head prev: BasicBlock* = blocks.Head
while prev is not None and prev.Next is not block: while prev is not None and prev.Next is not block:
prev = prev.Next prev = prev.Next
if prev is None: if prev is None:
@@ -237,38 +237,38 @@ def function_move_block_to_end(func: rawptr[Function], block: rawptr[BasicBlock]
blocks.Tail = block blocks.Tail = block
def block_append_line(block: rawptr[BasicBlock], line: rawptr[Line]): def block_append_line(block: BasicBlock*, line: Line*):
"""Append an instruction line to the basic block""" """Append an instruction line to the basic block"""
if block is None or line is None: return if block is None or line is None: return
lines: rawptr[GSList[Line]] = block.Lines lines: GSList[Line]* = block.Lines
if lines is None: return if lines is None: return
lines.append(line) lines.append(line)
def block_set_terminated(block: rawptr[BasicBlock], val: int): def block_set_terminated(block: BasicBlock*, val: int):
"""Set the block terminator flag (cross-module call to avoid opaque chained field access)""" """Set the block terminator flag (cross-module call to avoid opaque chained field access)"""
if block is None: return if block is None: return
block.IsTerminated = val block.IsTerminated = val
def block_get_terminated(block: rawptr[BasicBlock]) -> int: def block_get_terminated(block: BasicBlock*) -> int:
"""Get the block terminator flag (cross-module call to avoid opaque chained field access)""" """Get the block terminator flag (cross-module call to avoid opaque chained field access)"""
if block is None: if block is None:
return 1 return 1
return block.IsTerminated return block.IsTerminated
def block_append_text(pool: memhub.MemBuddy*, block: rawptr[BasicBlock], def block_append_text(pool: memhub.MemBuddy*, block: BasicBlock*,
text: str): text: str):
"""Create an instruction line and append it to the basic block""" """Create an instruction line and append it to the basic block"""
if block is None or text is None: return if block is None or text is None: return
line: rawptr[Line] = new_line(pool, text) line: Line* = new_line(pool, text)
if line is not None: if line is not None:
block_append_line(block, line) block_append_line(block, line)
def block_insert_text_before_terminator(pool: memhub.MemBuddy*, def block_insert_text_before_terminator(pool: memhub.MemBuddy*,
block: rawptr[BasicBlock], block: BasicBlock*,
text: str): text: str):
"""Create an instruction line and insert it before the block terminator. """Create an instruction line and insert it before the block terminator.
@@ -277,14 +277,14 @@ def block_insert_text_before_terminator(pool: memhub.MemBuddy*,
""" """
if block is None or text is None: return if block is None or text is None: return
if block.Lines is None: return if block.Lines is None: return
line: rawptr[Line] = new_line(pool, text) line: Line* = new_line(pool, text)
if line is None: return if line is None: return
# Block not terminated: append directly # Block not terminated: append directly
if block.IsTerminated == 0: if block.IsTerminated == 0:
block_append_line(block, line) block_append_line(block, line)
return return
# Block terminated: insert before Tail (the terminator) # Block terminated: insert before Tail (the terminator)
lines: rawptr[GSList[Line]] = block.Lines lines: GSList[Line]* = block.Lines
if lines.Head is None: if lines.Head is None:
block_append_line(block, line) block_append_line(block, line)
return return
@@ -295,7 +295,7 @@ def block_insert_text_before_terminator(pool: memhub.MemBuddy*,
lines.Count += 1 lines.Count += 1
return return
# Find the predecessor of Tail # Find the predecessor of Tail
prev: rawptr[Line] = lines.Head prev: Line* = lines.Head
while prev is not None and prev.Next is not lines.Tail: while prev is not None and prev.Next is not lines.Tail:
prev = prev.Next prev = prev.Next
if prev is None: if prev is None:
@@ -311,7 +311,7 @@ def block_insert_text_before_terminator(pool: memhub.MemBuddy*,
# ============================================================ # ============================================================
# Attribute setters # Attribute setters
# ============================================================ # ============================================================
def function_set_attrs(func: rawptr[Function], attrs: str): def function_set_attrs(func: Function*, attrs: str):
"""Set function-level attribute text (e.g. "nounwind"/"noinline")""" """Set function-level attribute text (e.g. "nounwind"/"noinline")"""
if func is None: return if func is None: return
func.Attrs = attrs func.Attrs = attrs
@@ -319,7 +319,7 @@ def function_set_attrs(func: rawptr[Function], attrs: str):
_g_attr_group_counter: int = 0 _g_attr_group_counter: int = 0
def function_set_attr_group(func: rawptr[Function], group: str): def function_set_attr_group(func: Function*, group: str):
"""Set function string attribute group (e.g. '"section"=".text.startup"') and assign #N. """Set function string attribute group (e.g. '"section"=".text.startup"') and assign #N.
LLVM string attributes (with a value, e.g. section) cannot be inlined on the signature LLVM string attributes (with a value, e.g. section) cannot be inlined on the signature
@@ -333,13 +333,13 @@ def function_set_attr_group(func: rawptr[Function], group: str):
func.AttrGroupId = _g_attr_group_counter func.AttrGroupId = _g_attr_group_counter
def param_set_attrs(param: rawptr[Param], attrs: str): def param_set_attrs(param: Param*, attrs: str):
"""Set parameter attribute text (e.g. "noundef"/"nocapture"/"readonly")""" """Set parameter attribute text (e.g. "noundef"/"nocapture"/"readonly")"""
if param is None: return if param is None: return
param.Attrs = attrs param.Attrs = attrs
def function_set_dbg(func: rawptr[Function], ref: str): def function_set_dbg(func: Function*, ref: str):
"""Set the function-level debug ref (DISubprogram node ref, e.g. "!3"). """Set the function-level debug ref (DISubprogram node ref, e.g. "!3").
Kept as-is: MLIR printing ignores it (FunctionPrint emits no !dbg), so this only Kept as-is: MLIR printing ignores it (FunctionPrint emits no !dbg), so this only
@@ -451,26 +451,26 @@ def _is_digit_ch(ch: char) -> int:
def _map_get_i32(map_arr: str, idx: int) -> int: def _map_get_i32(map_arr: str, idx: int) -> int:
"""Read i32 array map_arr[idx] (explicit byte offset idx*4). """Read i32 array map_arr[idx] (explicit byte offset idx*4).
Casts the byte offset to i32* via (rawptr[int])(uint64), then dereferences with c.Deref. Casts the byte offset to i32* via (int*)(uint64), then dereferences with c.Deref.
TPC has fixed type-union casts (_HandleTypeUnionCastLlvm fallback), so this form works. TPC has fixed type-union casts (_HandleTypeUnionCastLlvm fallback), so this form works.
""" """
if map_arr is None: if map_arr is None:
return -1 return -1
byte_off: uint64 = uint64(map_arr) + idx * 4 byte_off: uint64 = uint64(map_arr) + idx * 4
elem_ptr: rawptr[int] = (rawptr[int])(byte_off) elem_ptr: int* = (int*)(byte_off)
return *elem_ptr return *elem_ptr
def _map_set_i32(map_arr: str, idx: int, val: int): def _map_set_i32(map_arr: str, idx: int, val: int):
"""Write map_arr[idx] = val (i32 array, explicit byte offset idx*4). """Write map_arr[idx] = val (i32 array, explicit byte offset idx*4).
Casts via (rawptr[int])(uint64) and assigns through c.DerefAs. Casts via (int*)(uint64) and assigns through c.DerefAs.
TPC has fixed type-union casts, so this form works. TPC has fixed type-union casts, so this form works.
""" """
if map_arr is None: if map_arr is None:
return return
byte_off: uint64 = uint64(map_arr) + idx * 4 byte_off: uint64 = uint64(map_arr) + idx * 4
elem_ptr: rawptr[int] = (rawptr[int])(byte_off) elem_ptr: int* = (int*)(byte_off)
c.DerefAs(elem_ptr, val) c.DerefAs(elem_ptr, val)
@@ -492,13 +492,13 @@ def _scan_max_ssa_in_text(text: str, cur_max: int) -> int:
return result return result
def _find_max_ssa_number(func: rawptr[Function]) -> int: def _find_max_ssa_number(func: Function*) -> int:
"""Walk all BB instruction lines for the largest %N; returns -1 if no numeric SSA names""" """Walk all BB instruction lines for the largest %N; returns -1 if no numeric SSA names"""
max_n: int = -1 max_n: int = -1
if func is None or func.Blocks is None: if func is None or func.Blocks is None:
return max_n return max_n
blocks: rawptr[GSList[BasicBlock]] = func.Blocks blocks: GSList[BasicBlock]* = func.Blocks
blk: rawptr[BasicBlock] = blocks.Head blk: BasicBlock* = blocks.Head
blk_steps: sizet = 0 blk_steps: sizet = 0
while blk is not None: while blk is not None:
blk_steps += 1 blk_steps += 1
@@ -506,8 +506,8 @@ def _find_max_ssa_number(func: rawptr[Function]) -> int:
stdio.printf("[IR-DUMP] 链表成环: func blocks（函数名=%s，ssa 扫描终止）\n", func.Name) stdio.printf("[IR-DUMP] 链表成环: func blocks（函数名=%s，ssa 扫描终止）\n", func.Name)
stdlib.exit(1) stdlib.exit(1)
if blk.Lines is not None: if blk.Lines is not None:
lines: rawptr[GSList[Line]] = blk.Lines lines: GSList[Line]* = blk.Lines
line: rawptr[Line] = lines.Head line: Line* = lines.Head
line_steps: sizet = 0 line_steps: sizet = 0
while line is not None: while line is not None:
line_steps += 1 line_steps += 1
@@ -605,7 +605,7 @@ def _replace_ssa_numbers(text: str,
return new_buf return new_buf
def RenumberSSA(func: rawptr[Function], pool: memhub.MemBuddy*): def RenumberSSA(func: Function*, pool: memhub.MemBuddy*):
"""Renumber all numeric SSA names in the function so text-output order is monotonic. """Renumber all numeric SSA names in the function so text-output order is monotonic.
Called before FunctionPrint serializes the body; only applies to define (IsDeclared==0) Called before FunctionPrint serializes the body; only applies to define (IsDeclared==0)
@@ -633,8 +633,8 @@ def RenumberSSA(func: rawptr[Function], pool: memhub.MemBuddy*):
# 3. Second pass: assign new numbers in text order # 3. Second pass: assign new numbers in text order
next_new: int = 0 next_new: int = 0
blocks: rawptr[GSList[BasicBlock]] = func.Blocks blocks: GSList[BasicBlock]* = func.Blocks
blk: rawptr[BasicBlock] = blocks.Head blk: BasicBlock* = blocks.Head
blk_steps: sizet = 0 blk_steps: sizet = 0
while blk is not None: while blk is not None:
blk_steps += 1 blk_steps += 1
@@ -642,8 +642,8 @@ def RenumberSSA(func: rawptr[Function], pool: memhub.MemBuddy*):
stdio.printf("[IR-DUMP] 链表成环: func blocks（函数名=%s，ssa 重编号终止）\n", func.Name) stdio.printf("[IR-DUMP] 链表成环: func blocks（函数名=%s，ssa 重编号终止）\n", func.Name)
stdlib.exit(1) stdlib.exit(1)
if blk.Lines is not None: if blk.Lines is not None:
lines: rawptr[GSList[Line]] = blk.Lines lines: GSList[Line]* = blk.Lines
line: rawptr[Line] = lines.Head line: Line* = lines.Head
line_steps: sizet = 0 line_steps: sizet = 0
while line is not None: while line is not None:
line_steps += 1 line_steps += 1
@@ -677,8 +677,8 @@ def RenumberSSA(func: rawptr[Function], pool: memhub.MemBuddy*):
stdio.printf("[IR-DUMP] 链表成环: func blocks（函数名=%s，ssa 替换终止）\n", func.Name) stdio.printf("[IR-DUMP] 链表成环: func blocks（函数名=%s，ssa 替换终止）\n", func.Name)
stdlib.exit(1) stdlib.exit(1)
if blk.Lines is not None: if blk.Lines is not None:
lines: rawptr[GSList[Line]] = blk.Lines lines: GSList[Line]* = blk.Lines
line: rawptr[Line] = lines.Head line: Line* = lines.Head
line_steps = 0 line_steps = 0
while line is not None: while line is not None:
line_steps += 1 line_steps += 1
@@ -846,24 +846,24 @@ def _peep_is_alloc_of(eb: str, a_name: str, nl: sizet) -> int:
return 0 return 0
def _peephole_opt(func: rawptr[Function], pool: memhub.MemBuddy*): def _peephole_opt(func: Function*, pool: memhub.MemBuddy*):
"""Text-layer local peephole: T1 ret zeroinitializer; T2 entry-slot store->load forwarding""" """Text-layer local peephole: T1 ret zeroinitializer; T2 entry-slot store->load forwarding"""
if func is None or func.Blocks is None or pool is None: if func is None or func.Blocks is None or pool is None:
return return
# NOTE: TPC silently drops assignments for a two-level "var = ptr.field.member" auto-deref # NOTE: TPC silently drops assignments for a two-level "var = ptr.field.member" auto-deref
# chain (the IR reads an uninitialized stack var -> random stack errors). Split into one level: # chain (the IR reads an uninitialized stack var -> random stack errors). Split into one level:
# fetch the field into a local rawptr, then null-check before .Head (same pattern as FunctionPrint). # fetch the field into a local rawptr, then null-check before .Head (same pattern as FunctionPrint).
func_blocks: rawptr[GSList[BasicBlock]] = func.Blocks func_blocks: GSList[BasicBlock]* = func.Blocks
blk: rawptr[BasicBlock] = None blk: BasicBlock* = None
if func_blocks is not None: if func_blocks is not None:
blk = func_blocks.Head blk = func_blocks.Head
# ---------- T1: ret <ty> zeroinitializer ---------- # ---------- T1: ret <ty> zeroinitializer ----------
blk_t1 = blk blk_t1 = blk
while blk_t1 is not None: while blk_t1 is not None:
line1: rawptr[Line] = None line1: Line* = None
if blk_t1.Lines is not None: if blk_t1.Lines is not None:
t1_lines: rawptr[GSList[Line]] = blk_t1.Lines t1_lines: GSList[Line]* = blk_t1.Lines
line1 = t1_lines.Head line1 = t1_lines.Head
while line1 is not None: while line1 is not None:
if line1.Buf is not None: if line1.Buf is not None:
@@ -893,13 +893,13 @@ def _peephole_opt(func: rawptr[Function], pool: memhub.MemBuddy*):
blk_t1 = blk_t1.Next blk_t1 = blk_t1.Next
# ---------- T2: entry alloca slot forwarding ---------- # ---------- T2: entry alloca slot forwarding ----------
entry_blk: rawptr[BasicBlock] = blk entry_blk: BasicBlock* = blk
if entry_blk is None: if entry_blk is None:
return return
entry_lines: rawptr[GSList[Line]] = entry_blk.Lines entry_lines: GSList[Line]* = entry_blk.Lines
if entry_lines is None: if entry_lines is None:
return return
e_line: rawptr[Line] = entry_lines.Head e_line: Line* = entry_lines.Head
while e_line is not None: while e_line is not None:
eb: str = e_line.Buf eb: str = e_line.Buf
if eb is not None: if eb is not None:
@@ -920,9 +920,9 @@ def _peephole_opt(func: rawptr[Function], pool: memhub.MemBuddy*):
# First pass: count this alloca's store/load/other refs and line order # First pass: count this alloca's store/load/other refs and line order
blk_s = blk blk_s = blk
while blk_s is not None: while blk_s is not None:
l_s: rawptr[Line] = None l_s: Line* = None
if blk_s.Lines is not None: if blk_s.Lines is not None:
scan_lines: rawptr[GSList[Line]] = blk_s.Lines scan_lines: GSList[Line]* = blk_s.Lines
l_s = scan_lines.Head l_s = scan_lines.Head
while l_s is not None: while l_s is not None:
sb: str = l_s.Buf sb: str = l_s.Buf
@@ -1008,9 +1008,9 @@ def _peephole_opt(func: rawptr[Function], pool: memhub.MemBuddy*):
ltok_len: sizet = string.strlen(ltok) ltok_len: sizet = string.strlen(ltok)
blk_r = blk blk_r = blk
while blk_r is not None: while blk_r is not None:
lr: rawptr[Line] = None lr: Line* = None
if blk_r.Lines is not None: if blk_r.Lines is not None:
repl_lines: rawptr[GSList[Line]] = blk_r.Lines repl_lines: GSList[Line]* = blk_r.Lines
lr = repl_lines.Head lr = repl_lines.Head
while lr is not None: while lr is not None:
if lr.Buf is not None: if lr.Buf is not None:
@@ -1023,9 +1023,9 @@ def _peephole_opt(func: rawptr[Function], pool: memhub.MemBuddy*):
# Delete: alloca def / the single store / all load lines # Delete: alloca def / the single store / all load lines
blk_d = blk blk_d = blk
while blk_d is not None: while blk_d is not None:
ld: rawptr[Line] = None ld: Line* = None
if blk_d.Lines is not None: if blk_d.Lines is not None:
kill_lines: rawptr[GSList[Line]] = blk_d.Lines kill_lines: GSList[Line]* = blk_d.Lines
ld = kill_lines.Head ld = kill_lines.Head
while ld is not None: while ld is not None:
db: str = ld.Buf db: str = ld.Buf
@@ -1048,7 +1048,7 @@ def _peephole_opt(func: rawptr[Function], pool: memhub.MemBuddy*):
_peep_noop_bitcast(func, pool) _peep_noop_bitcast(func, pool)
def _peep_noop_bitcast(func: rawptr[Function], pool: memhub.MemBuddy*): def _peep_noop_bitcast(func: Function*, pool: memhub.MemBuddy*):
"""T3: remove no-op bitcast (bitcast <T> %x to <T>, same type on both sides). """T3: remove no-op bitcast (bitcast <T> %x to <T>, same type on both sides).
The emitter (virtual calls / union width casts) produces same-type identity bitcasts The emitter (virtual calls / union width casts) produces same-type identity bitcasts
@@ -1062,13 +1062,13 @@ def _peep_noop_bitcast(func: rawptr[Function], pool: memhub.MemBuddy*):
# resuming from the next line; stop at the first non-matching bitcast. Equivalent deletion # resuming from the next line; stop at the first non-matching bitcast. Equivalent deletion
# result to the old rescan-from-block-head approach (replacement only touches operand tokens), # result to the old rescan-from-block-head approach (replacement only touches operand tokens),
# but removes the O(K*C) quadratic rescan. # but removes the O(K*C) quadratic rescan.
blk: rawptr[BasicBlock] = func.Blocks.Head blk: BasicBlock* = func.Blocks.Head
while blk is not None: while blk is not None:
ln: rawptr[Line] = None ln: Line* = None
if blk.Lines is not None: if blk.Lines is not None:
ln = blk.Lines.Head ln = blk.Lines.Head
while ln is not None: while ln is not None:
nxt: rawptr[Line] = ln.Next nxt: Line* = ln.Next
if ln.Buf is not None: if ln.Buf is not None:
eqpos: str = string.strstr(ln.Buf, " = bitcast ") eqpos: str = string.strstr(ln.Buf, " = bitcast ")
if eqpos is not None: if eqpos is not None:
@@ -1105,10 +1105,10 @@ def _peep_noop_bitcast(func: rawptr[Function], pool: memhub.MemBuddy*):
# nm_buf/src_buf are constant across the scan; strlen computed once (not per line) # nm_buf/src_buf are constant across the scan; strlen computed once (not per line)
nm_buf_len: sizet = string.strlen(nm_buf) nm_buf_len: sizet = string.strlen(nm_buf)
src_buf_len: sizet = string.strlen(src_buf) src_buf_len: sizet = string.strlen(src_buf)
blk_r: rawptr[BasicBlock] = func.Blocks.Head blk_r: BasicBlock* = func.Blocks.Head
while blk_r is not None: while blk_r is not None:
if blk_r.Lines is not None: if blk_r.Lines is not None:
ln2: rawptr[Line] = blk_r.Lines.Head ln2: Line* = blk_r.Lines.Head
while ln2 is not None: while ln2 is not None:
if ln2.Buf is not None: if ln2.Buf is not None:
rb: str = _peep_replace_token(pool, ln2.Buf, nm_buf, src_buf, rb: str = _peep_replace_token(pool, ln2.Buf, nm_buf, src_buf,
@@ -1147,8 +1147,8 @@ define MLIR_ALIAS_CAP = 512
# Render pass: 1=scan(register) 2=emit(write text) # Render pass: 1=scan(register) 2=emit(write text)
_MLIR_Pass: int = 0 _MLIR_Pass: int = 0
_MLIR_Pool: memhub.MemBuddy* = None _MLIR_Pool: memhub.MemBuddy* = None
_MLIR_Func: rawptr[Function] = None _MLIR_Func: Function* = None
_MLIR_SrcBlk: rawptr[BasicBlock] = None _MLIR_SrcBlk: BasicBlock* = None
# Constant table: (MLIR type text, constant text) -> materialized SSA name # Constant table: (MLIR type text, constant text) -> materialized SSA name
_MLIR_ConstTy: t.CPtr = None _MLIR_ConstTy: t.CPtr = None
@@ -1609,12 +1609,12 @@ def _MlirBlkRef(t: str) -> str:
return t return t
def _MlirFindBlock(func: rawptr[Function], name: str) -> rawptr[BasicBlock]: def _MlirFindBlock(func: Function*, name: str) -> BasicBlock*:
"""Find a basic block by name (without %) within the function""" """Find a basic block by name (without %) within the function"""
if func is None or func.Blocks is None or name is None: if func is None or func.Blocks is None or name is None:
return None return None
blocks: rawptr[GSList[BasicBlock]] = func.Blocks blocks: GSList[BasicBlock]* = func.Blocks
blk: rawptr[BasicBlock] = blocks.Head blk: BasicBlock* = blocks.Head
steps: int = 0 steps: int = 0
while blk is not None: while blk is not None:
steps += 1 steps += 1
@@ -1719,7 +1719,7 @@ def _MlirPhiParam(text: str) -> int:
return 1 return 1
def _MlirPhiFindIncoming(text: str, src: rawptr[BasicBlock]) -> int: def _MlirPhiFindIncoming(text: str, src: BasicBlock*) -> int:
"""Find the phi incoming edge matching the source block; on success writes _SC_B1(value)/_SC_B2(type) and returns 1""" """Find the phi incoming edge matching the source block; on success writes _SC_B1(value)/_SC_B2(type) and returns 1"""
p: str = _mlir_ws(text) p: str = _mlir_ws(text)
tb: str = _SC_Buf tb: str = _SC_Buf
@@ -1772,12 +1772,12 @@ def _MlirPhiFindIncoming(text: str, src: rawptr[BasicBlock]) -> int:
# ============================================================ # ============================================================
# Block parameters / block arguments # Block parameters / block arguments
# ============================================================ # ============================================================
def _MlirBlockHasPhi(blk: rawptr[BasicBlock]) -> int: def _MlirBlockHasPhi(blk: BasicBlock*) -> int:
"""Whether the block head has a phi (i.e. the block carries block params)""" """Whether the block head has a phi (i.e. the block carries block params)"""
if blk is None or blk.Lines is None: if blk is None or blk.Lines is None:
return 0 return 0
lines: rawptr[GSList[Line]] = blk.Lines lines: GSList[Line]* = blk.Lines
ln: rawptr[Line] = lines.Head ln: Line* = lines.Head
while ln is not None: while ln is not None:
if ln.Buf is not None: if ln.Buf is not None:
if _MlirIsPhiLine(ln.Buf) != 0: if _MlirIsPhiLine(ln.Buf) != 0:
@@ -1788,7 +1788,7 @@ def _MlirBlockHasPhi(blk: rawptr[BasicBlock]) -> int:
def _MlirBlockOperands(out: str, outsz: sizet, def _MlirBlockOperands(out: str, outsz: sizet,
target: rawptr[BasicBlock], src: rawptr[BasicBlock]): target: BasicBlock*, src: BasicBlock*):
"""Emit target's block arguments when branching to it: (%v : ty, ...). """Emit target's block arguments when branching to it: (%v : ty, ...).
Incoming edges are matched to phis by source block; no match -> loud error (never silently drop args). Incoming edges are matched to phis by source block; no match -> loud error (never silently drop args).
@@ -1799,8 +1799,8 @@ def _MlirBlockOperands(out: str, outsz: sizet,
return return
tmp: str = _SC_Tmp tmp: str = _SC_Tmp
tmp[0] = '\0' tmp[0] = '\0'
lines: rawptr[GSList[Line]] = target.Lines lines: GSList[Line]* = target.Lines
ln: rawptr[Line] = lines.Head ln: Line* = lines.Head
cnt: int = 0 cnt: int = 0
while ln is not None: while ln is not None:
if ln.Buf is None: if ln.Buf is None:
@@ -1827,7 +1827,7 @@ def _MlirBlockOperands(out: str, outsz: sizet,
_append_cstr(out, outsz, ")") _append_cstr(out, outsz, ")")
def _MlirEmitBlockHeader(out: str, outsz: sizet, blk: rawptr[BasicBlock]): def _MlirEmitBlockHeader(out: str, outsz: sizet, blk: BasicBlock*):
"""Emit a non-entry block header: ^name(%p: ty, ...):""" """Emit a non-entry block header: ^name(%p: ty, ...):"""
_append_cstr(out, outsz, "^") _append_cstr(out, outsz, "^")
if blk.Name is not None: if blk.Name is not None:
@@ -1835,8 +1835,8 @@ def _MlirEmitBlockHeader(out: str, outsz: sizet, blk: rawptr[BasicBlock]):
if _MlirBlockHasPhi(blk) != 0: if _MlirBlockHasPhi(blk) != 0:
tmp: str = _SC_Tmp tmp: str = _SC_Tmp
tmp[0] = '\0' tmp[0] = '\0'
lines: rawptr[GSList[Line]] = blk.Lines lines: GSList[Line]* = blk.Lines
ln: rawptr[Line] = lines.Head ln: Line* = lines.Head
cnt: int = 0 cnt: int = 0
while ln is not None: while ln is not None:
if ln.Buf is None: if ln.Buf is None:
@@ -1863,12 +1863,12 @@ def _MlirEmitBlockHeader(out: str, outsz: sizet, blk: rawptr[BasicBlock]):
_append_cstr(out, outsz, ":\n") _append_cstr(out, outsz, ":\n")
def _MlirEmitBlockLines(out: str, outsz: sizet, blk: rawptr[BasicBlock]): def _MlirEmitBlockLines(out: str, outsz: sizet, blk: BasicBlock*):
"""Emit in-block instructions (skip leading phis, which became block params)""" """Emit in-block instructions (skip leading phis, which became block params)"""
if blk is None or blk.Lines is None: if blk is None or blk.Lines is None:
return return
lines: rawptr[GSList[Line]] = blk.Lines lines: GSList[Line]* = blk.Lines
ln: rawptr[Line] = lines.Head ln: Line* = lines.Head
skipping: int = 1 skipping: int = 1
steps: int = 0 steps: int = 0
while ln is not None: while ln is not None:
@@ -1884,7 +1884,7 @@ def _MlirEmitBlockLines(out: str, outsz: sizet, blk: rawptr[BasicBlock]):
ln = ln.Next ln = ln.Next
def _MlirCheckEntryNoPhi(blk: rawptr[BasicBlock]): def _MlirCheckEntryNoPhi(blk: BasicBlock*):
"""entry block must not have phis (no predecessor, cannot become block params)""" """entry block must not have phis (no predecessor, cannot become block params)"""
if _MlirBlockHasPhi(blk) != 0: if _MlirBlockHasPhi(blk) != 0:
MlirFail("MLIR 渲染: entry 块不允许 phi（MLIR entry 块不接受块参数）") MlirFail("MLIR 渲染: entry 块不允许 phi（MLIR entry 块不接受块参数）")
@@ -3136,7 +3136,7 @@ def _MlirRenderLine(text: str, out: str, outsz: sizet):
# Function signature and body # Function signature and body
# ============================================================ # ============================================================
def _MlirFuncSig(buf: str, size: sizet, def _MlirFuncSig(buf: str, size: sizet,
func: rawptr[Function], pool: memhub.MemBuddy*): func: Function*, pool: memhub.MemBuddy*):
"""llvm.func @name(%a: i32, %b: i32) -> i32 (void return omits -> ty)""" """llvm.func @name(%a: i32, %b: i32) -> i32 (void return omits -> ty)"""
_append_cstr(buf, size, "llvm.func @") _append_cstr(buf, size, "llvm.func @")
if func.Name is not None: if func.Name is not None:
@@ -3147,8 +3147,8 @@ def _MlirFuncSig(buf: str, size: sizet,
else: else:
_append_cstr(buf, size, func.Name) _append_cstr(buf, size, func.Name)
_append_cstr(buf, size, "(") _append_cstr(buf, size, "(")
params: rawptr[GSList[Param]] = func.Params params: GSList[Param]* = func.Params
cur: rawptr[Param] = None cur: Param* = None
if params is not None: if params is not None:
cur = params.Head cur = params.Head
first: int = 1 first: int = 1
@@ -3194,7 +3194,7 @@ def _MlirFuncSig(buf: str, size: sizet,
def FunctionPrint(buf: str, size: sizet, def FunctionPrint(buf: str, size: sizet,
func: rawptr[Function], pool: memhub.MemBuddy*): func: Function*, pool: memhub.MemBuddy*):
"""Serialize function func as MLIR (llvm dialect) text APPENDED to buf. """Serialize function func as MLIR (llvm dialect) text APPENDED to buf.
NOTE: like the llvmlite version, this appends (so the module printer can concatenate NOTE: like the llvmlite version, this appends (so the module printer can concatenate
@@ -3235,7 +3235,7 @@ def FunctionPrint(buf: str, size: sizet,
_MlirOutTruncFail() _MlirOutTruncFail()
return return
blocks: rawptr[GSList[BasicBlock]] = func.Blocks blocks: GSList[BasicBlock]* = func.Blocks
if blocks is None: if blocks is None:
_MlirFuncSig(buf, size, func, pool) _MlirFuncSig(buf, size, func, pool)
_append_cstr(buf, size, "\n") _append_cstr(buf, size, "\n")
@@ -3244,7 +3244,7 @@ def FunctionPrint(buf: str, size: sizet,
# ---- pass1: scan (register constants/aliases + shape checks) ---- # ---- pass1: scan (register constants/aliases + shape checks) ----
_MLIR_Pass = 1 _MLIR_Pass = 1
blk: rawptr[BasicBlock] = blocks.Head blk: BasicBlock* = blocks.Head
blk_steps: int = 0 blk_steps: int = 0
while blk is not None: while blk is not None:
blk_steps += 1 blk_steps += 1
@@ -3252,8 +3252,8 @@ def FunctionPrint(buf: str, size: sizet,
MlirFail("MLIR 渲染: 函数块链疑似成环") MlirFail("MLIR 渲染: 函数块链疑似成环")
_MLIR_SrcBlk = blk _MLIR_SrcBlk = blk
if blk.Lines is not None: if blk.Lines is not None:
lines: rawptr[GSList[Line]] = blk.Lines lines: GSList[Line]* = blk.Lines
ln: rawptr[Line] = lines.Head ln: Line* = lines.Head
ln_steps: int = 0 ln_steps: int = 0
while ln is not None: while ln is not None:
ln_steps += 1 ln_steps += 1
@@ -3570,14 +3570,14 @@ def DebugTakeText() -> str:
# These accessors run inside this module where the full type definitions exist, so they can access # These accessors run inside this module where the full type definitions exist, so they can access
# all fields correctly; other modules get field values via function calls, bypassing the stub limits. # all fields correctly; other modules get field values via function calls, bypassing the stub limits.
# ============================================================ # ============================================================
def function_get_name(func: rawptr[Function]) -> str: def function_get_name(func: Function*) -> str:
"""Get the function name""" """Get the function name"""
if func is None: if func is None:
return None return None
return func.Name return func.Name
def function_get_name_len(func: rawptr[Function]) -> sizet: def function_get_name_len(func: Function*) -> sizet:
"""Get the function name length (computed once at creation, always == strlen(Name)). """Get the function name length (computed once at creation, always == strlen(Name)).
Mirrors function_get_name's cross-module stub-bypass pattern: the user module only has a stub Mirrors function_get_name's cross-module stub-bypass pattern: the user module only has a stub
@@ -3590,59 +3590,59 @@ def function_get_name_len(func: rawptr[Function]) -> sizet:
return func.NameLen return func.NameLen
def function_get_ret_ty(func: rawptr[Function]) -> rawptr[LLVMType]: def function_get_ret_ty(func: Function*) -> LLVMType*:
"""Get the function return type""" """Get the function return type"""
if func is None: if func is None:
return None return None
return func.RetTy return func.RetTy
def function_get_params(func: rawptr[Function]) -> rawptr[GSList[Param]]: def function_get_params(func: Function*) -> GSList[Param]*:
"""Get the function parameter list container""" """Get the function parameter list container"""
if func is None: if func is None:
return None return None
return func.Params return func.Params
def function_get_param_head(func: rawptr[Function]) -> rawptr[Param]: def function_get_param_head(func: Function*) -> Param*:
"""Get the function parameter list head (one step, avoiding GSList.Head access by callers)""" """Get the function parameter list head (one step, avoiding GSList.Head access by callers)"""
if func is None: if func is None:
return None return None
params: rawptr[GSList[Param]] = func.Params params: GSList[Param]* = func.Params
if params is None: if params is None:
return None return None
return params.Head return params.Head
def function_get_next(func: rawptr[Function]) -> rawptr[Function]: def function_get_next(func: Function*) -> Function*:
"""Get the next function in the list""" """Get the next function in the list"""
if func is None: if func is None:
return None return None
return func.Next return func.Next
def function_is_declared(func: rawptr[Function]) -> int: def function_is_declared(func: Function*) -> int:
"""Get whether the function is a declaration (1=declare, 0=define)""" """Get whether the function is a declaration (1=declare, 0=define)"""
if func is None: if func is None:
return 0 return 0
return func.IsDeclared return func.IsDeclared
def param_get_name(param: rawptr[Param]) -> str: def param_get_name(param: Param*) -> str:
"""Get the parameter name""" """Get the parameter name"""
if param is None: if param is None:
return None return None
return param.Name return param.Name
def param_get_ty(param: rawptr[Param]) -> rawptr[LLVMType]: def param_get_ty(param: Param*) -> LLVMType*:
"""Get the parameter type""" """Get the parameter type"""
if param is None: if param is None:
return None return None
return param.Ty return param.Ty
def param_get_next(param: rawptr[Param]) -> rawptr[Param]: def param_get_next(param: Param*) -> Param*:
"""Get the next parameter in the list""" """Get the next parameter in the list"""
if param is None: if param is None:
return None return None
mlirlite/__init__.vp
+63 -63
View File
@@ -110,8 +110,8 @@ def _str_dup(pool: memhub.MemBuddy*, src: str) -> str:
# ============================================================ # ============================================================
# Convenience factory: create a named basic block # Convenience factory: create a named basic block
# ============================================================ # ============================================================
def create_block(pool: memhub.MemBuddy*, func: rawptr[Function], def create_block(pool: memhub.MemBuddy*, func: Function*,
name: str) -> rawptr[BasicBlock]: name: str) -> BasicBlock*:
"""Create a basic block and add it to the function.""" """Create a basic block and add it to the function."""
# Block-name/param conflict guard: block label "entry:" is value %entry, so a param %entry # Block-name/param conflict guard: block label "entry:" is value %entry, so a param %entry
# collides; on collision append .1/.2/... (strip a leading % from Param.Name before comparing). # collides; on collision append .1/.2/... (strip a leading % from Param.Name before comparing).
@@ -125,7 +125,7 @@ def create_block(pool: memhub.MemBuddy*, func: rawptr[Function],
cb_collide: int = 1 cb_collide: int = 1
while cb_collide != 0: while cb_collide != 0:
cb_collide = 0 cb_collide = 0
cb_p: rawptr[Param] = function_get_param_head(func) cb_p: Param* = function_get_param_head(func)
while cb_p is not None: while cb_p is not None:
cb_pnm: str = param_get_name(cb_p) cb_pnm: str = param_get_name(cb_p)
if cb_pnm is not None: if cb_pnm is not None:
@@ -141,7 +141,7 @@ def create_block(pool: memhub.MemBuddy*, func: rawptr[Function],
use_name = cb_buf use_name = cb_buf
cb_k += 1 cb_k += 1
name_dup: str = _str_dup(pool, use_name) name_dup: str = _str_dup(pool, use_name)
blk: rawptr[BasicBlock] = new_basic_block(pool, name_dup) blk: BasicBlock* = new_basic_block(pool, name_dup)
if blk is not None: if blk is not None:
function_add_block(func, blk) function_add_block(func, blk)
return blk return blk
@@ -151,12 +151,12 @@ def create_block(pool: memhub.MemBuddy*, func: rawptr[Function],
# Convenience factory: create an integer constant value # Convenience factory: create an integer constant value
# ============================================================ # ============================================================
def const_int(pool: memhub.MemBuddy*, bits: int, def const_int(pool: memhub.MemBuddy*, bits: int,
val: int64) -> rawptr[Value]: val: int64) -> Value*:
"""Create an integer constant value (auto-creates type + name text). """Create an integer constant value (auto-creates type + name text).
bits: bit width (1/8/16/32/64); val: integer value. bits: bit width (1/8/16/32/64); val: integer value.
""" """
# create type # create type
ty: rawptr[LLVMType] = pool.alloc(LLVMType.__sizeof__()) ty: LLVMType* = pool.alloc(LLVMType.__sizeof__())
if ty is None: return None if ty is None: return None
string.memset(ty, 0, LLVMType.__sizeof__()) string.memset(ty, 0, LLVMType.__sizeof__())
c.DerefAs(ty, LLVMType.Int(bits)) c.DerefAs(ty, LLVMType.Int(bits))
@@ -174,12 +174,12 @@ def const_int(pool: memhub.MemBuddy*, bits: int,
return ConstInt(pool, ty, val, name) return ConstInt(pool, ty, val, name)
def const_int32(pool: memhub.MemBuddy*, val: int64) -> rawptr[Value]: def const_int32(pool: memhub.MemBuddy*, val: int64) -> Value*:
"""Convenience: create an i32 integer constant.""" """Convenience: create an i32 integer constant."""
return const_int(pool, 32, val) return const_int(pool, 32, val)
def const_int64(pool: memhub.MemBuddy*, val: int64) -> rawptr[Value]: def const_int64(pool: memhub.MemBuddy*, val: int64) -> Value*:
"""Convenience: create an i64 integer constant.""" """Convenience: create an i64 integer constant."""
return const_int(pool, 64, val) return const_int(pool, 64, val)
@@ -187,21 +187,21 @@ def const_int64(pool: memhub.MemBuddy*, val: int64) -> rawptr[Value]:
# ============================================================ # ============================================================
# Convenience factory: create a function and add it to the module # Convenience factory: create a function and add it to the module
# ============================================================ # ============================================================
def create_function(pool: memhub.MemBuddy*, mod: rawptr[LLVMModule], def create_function(pool: memhub.MemBuddy*, mod: LLVMModule*,
name: str, ret_ty: rawptr[LLVMType]) -> rawptr[Function]: name: str, ret_ty: LLVMType*) -> Function*:
"""Create a function and add it to the module.""" """Create a function and add it to the module."""
name_dup: str = _str_dup(pool, name) name_dup: str = _str_dup(pool, name)
func: rawptr[Function] = new_function(pool, name_dup, ret_ty) func: Function* = new_function(pool, name_dup, ret_ty)
if func is not None: if func is not None:
module_add_function(mod, func) module_add_function(mod, func)
return func return func
def add_param(pool: memhub.MemBuddy*, func: rawptr[Function], def add_param(pool: memhub.MemBuddy*, func: Function*,
ty: rawptr[LLVMType], name: str) -> rawptr[Param]: ty: LLVMType*, name: str) -> Param*:
"""Create a parameter and add it to the function.""" """Create a parameter and add it to the function."""
name_dup: str = _str_dup(pool, name) name_dup: str = _str_dup(pool, name)
param: rawptr[Param] = new_param(pool, ty, name_dup) param: Param* = new_param(pool, ty, name_dup)
if param is not None: if param is not None:
function_add_param(func, param) function_add_param(func, param)
return param return param
@@ -210,13 +210,13 @@ def add_param(pool: memhub.MemBuddy*, func: rawptr[Function],
# ============================================================ # ============================================================
# Convenience factory: create a function declaration (declare) # Convenience factory: create a function declaration (declare)
# ============================================================ # ============================================================
def create_declare(pool: memhub.MemBuddy*, mod: rawptr[LLVMModule], def create_declare(pool: memhub.MemBuddy*, mod: LLVMModule*,
name: str, ret_ty: rawptr[LLVMType]) -> rawptr[Function]: name: str, ret_ty: LLVMType*) -> Function*:
"""Create a function declaration (declare, no body) and add it to the module. """Create a function declaration (declare, no body) and add it to the module.
Unlike create_function, it emits only: declare <ret_ty> @<name>(<params>) Unlike create_function, it emits only: declare <ret_ty> @<name>(<params>)
""" """
name_dup: str = _str_dup(pool, name) name_dup: str = _str_dup(pool, name)
func: rawptr[Function] = new_function(pool, name_dup, ret_ty) func: Function* = new_function(pool, name_dup, ret_ty)
if func is not None: if func is not None:
func.IsDeclared = 1 func.IsDeclared = 1
module_add_function(mod, func) module_add_function(mod, func)
@@ -229,8 +229,8 @@ def create_declare(pool: memhub.MemBuddy*, mod: rawptr[LLVMModule],
# The initializer is stored in gv.Initializer as llvmlite-shaped LLVM syntax text (c"contents\00"); # The initializer is stored in gv.Initializer as llvmlite-shaped LLVM syntax text (c"contents\00");
# the MLIR render stage (__module.vp/_MlirGlobalInit) converts it to the attribute form "contents". # the MLIR render stage (__module.vp/_MlirGlobalInit) converts it to the attribute form "contents".
# ============================================================ # ============================================================
def create_global_string(pool: memhub.MemBuddy*, mod: rawptr[LLVMModule], def create_global_string(pool: memhub.MemBuddy*, mod: LLVMModule*,
name: str, text: str) -> rawptr[GlobalVariable]: name: str, text: str) -> GlobalVariable*:
"""Create a string-constant global variable and add it to the module. """Create a string-constant global variable and add it to the module.
name: global name (e.g. ".str"); text: C string without trailing NUL (added automatically). name: global name (e.g. ".str"); text: C string without trailing NUL (added automatically).
Returns: GlobalVariable pointer of type [len+1 x i8]. Returns: GlobalVariable pointer of type [len+1 x i8].
@@ -240,20 +240,20 @@ def create_global_string(pool: memhub.MemBuddy*, mod: rawptr[LLVMModule],
count: int = slen + 1 # includes the trailing NUL count: int = slen + 1 # includes the trailing NUL
# create i8 type # create i8 type
i8_ty: rawptr[LLVMType] = pool.alloc(LLVMType.__sizeof__()) i8_ty: LLVMType* = pool.alloc(LLVMType.__sizeof__())
if i8_ty is None: return None if i8_ty is None: return None
string.memset(i8_ty, 0, LLVMType.__sizeof__()) string.memset(i8_ty, 0, LLVMType.__sizeof__())
c.DerefAs(i8_ty, LLVMType.Int(8)) c.DerefAs(i8_ty, LLVMType.Int(8))
# create [count x i8] array type # create [count x i8] array type
arr_ty: rawptr[LLVMType] = pool.alloc(LLVMType.__sizeof__()) arr_ty: LLVMType* = pool.alloc(LLVMType.__sizeof__())
if arr_ty is None: return None if arr_ty is None: return None
string.memset(arr_ty, 0, LLVMType.__sizeof__()) string.memset(arr_ty, 0, LLVMType.__sizeof__())
c.DerefAs(arr_ty, LLVMType.Array(i8_ty, count)) c.DerefAs(arr_ty, LLVMType.Array(i8_ty, count))
# create global variable # create global variable
name_dup: str = _str_dup(pool, name) name_dup: str = _str_dup(pool, name)
gv: rawptr[GlobalVariable] = new_global_variable(pool, name_dup, arr_ty) gv: GlobalVariable* = new_global_variable(pool, name_dup, arr_ty)
if gv is None: return None if gv is None: return None
# set attributes: private + unnamed_addr + constant # set attributes: private + unnamed_addr + constant
@@ -310,19 +310,19 @@ def create_global_string(pool: memhub.MemBuddy*, mod: rawptr[LLVMModule],
# ============================================================ # ============================================================
# Convenience factory: create an integer global with an initializer # Convenience factory: create an integer global with an initializer
# ============================================================ # ============================================================
def create_global_int(pool: memhub.MemBuddy*, mod: rawptr[LLVMModule], def create_global_int(pool: memhub.MemBuddy*, mod: LLVMModule*,
name: str, bits: int, val: int64) -> rawptr[GlobalVariable]: name: str, bits: int, val: int64) -> GlobalVariable*:
"""Create an integer global variable and add it to the module. """Create an integer global variable and add it to the module.
MLIR output: llvm.mlir.global @<name>(<val> : i<bits>) : i<bits> MLIR output: llvm.mlir.global @<name>(<val> : i<bits>) : i<bits>
""" """
# create integer type # create integer type
ty: rawptr[LLVMType] = pool.alloc(LLVMType.__sizeof__()) ty: LLVMType* = pool.alloc(LLVMType.__sizeof__())
if ty is None: return None if ty is None: return None
string.memset(ty, 0, LLVMType.__sizeof__()) string.memset(ty, 0, LLVMType.__sizeof__())
c.DerefAs(ty, LLVMType.Int(bits)) c.DerefAs(ty, LLVMType.Int(bits))
name_dup: str = _str_dup(pool, name) name_dup: str = _str_dup(pool, name)
gv: rawptr[GlobalVariable] = new_global_variable(pool, name_dup, ty) gv: GlobalVariable* = new_global_variable(pool, name_dup, ty)
if gv is None: return None if gv is None: return None
# build initializer text "42" (the type is printed separately by the global render stage) # build initializer text "42" (the type is printed separately by the global render stage)
@@ -353,109 +353,109 @@ class LLVMModuleCore:
self.Pool = pool self.Pool = pool
# ---- module operations ---- # ---- module operations ----
def NewModule(self, name: str) -> rawptr[LLVMModule]: def NewModule(self, name: str) -> LLVMModule*:
return new_module(self.Pool, name) return new_module(self.Pool, name)
def CreateFunction(self, mod: rawptr[LLVMModule], name: str, def CreateFunction(self, mod: LLVMModule*, name: str,
ret_ty: rawptr[LLVMType]) -> rawptr[Function]: ret_ty: LLVMType*) -> Function*:
return create_function(self.Pool, mod, name, ret_ty) return create_function(self.Pool, mod, name, ret_ty)
def CreateDeclare(self, mod: rawptr[LLVMModule], name: str, def CreateDeclare(self, mod: LLVMModule*, name: str,
ret_ty: rawptr[LLVMType]) -> rawptr[Function]: ret_ty: LLVMType*) -> Function*:
"""Create a function declaration (declare, no body).""" """Create a function declaration (declare, no body)."""
return create_declare(self.Pool, mod, name, ret_ty) return create_declare(self.Pool, mod, name, ret_ty)
def AddParam(self, func: rawptr[Function], ty: rawptr[LLVMType], def AddParam(self, func: Function*, ty: LLVMType*,
name: str) -> rawptr[Param]: name: str) -> Param*:
return add_param(self.Pool, func, ty, name) return add_param(self.Pool, func, ty, name)
def FunctionSetAttrs(self, func: rawptr[Function], attrs: str): def FunctionSetAttrs(self, func: Function*, attrs: str):
"""Set the function-level attribute text.""" """Set the function-level attribute text."""
function_set_attrs(func, attrs) function_set_attrs(func, attrs)
def ParamSetAttrs(self, param: rawptr[Param], attrs: str): def ParamSetAttrs(self, param: Param*, attrs: str):
"""Set the parameter attribute text.""" """Set the parameter attribute text."""
param_set_attrs(param, attrs) param_set_attrs(param, attrs)
def CreateBlock(self, func: rawptr[Function], def CreateBlock(self, func: Function*,
name: str) -> rawptr[BasicBlock]: name: str) -> BasicBlock*:
return create_block(self.Pool, func, name) return create_block(self.Pool, func, name)
def NewBuilder(self, func: rawptr[Function]) -> rawptr[IRBuilder]: def NewBuilder(self, func: Function*) -> IRBuilder*:
return new_builder(self.Pool, func) return new_builder(self.Pool, func)
# ---- globals ---- # ---- globals ----
def NewGlobal(self, mod: rawptr[LLVMModule], name: str, def NewGlobal(self, mod: LLVMModule*, name: str,
ty: rawptr[LLVMType]) -> rawptr[GlobalVariable]: ty: LLVMType*) -> GlobalVariable*:
"""Create a global variable and add it to the module.""" """Create a global variable and add it to the module."""
name_dup: str = _str_dup(self.Pool, name) name_dup: str = _str_dup(self.Pool, name)
gv: rawptr[GlobalVariable] = new_global_variable(self.Pool, name_dup, ty) gv: GlobalVariable* = new_global_variable(self.Pool, name_dup, ty)
if gv is not None: if gv is not None:
module_add_global(mod, gv) module_add_global(mod, gv)
return gv return gv
def CreateGlobalString(self, mod: rawptr[LLVMModule], name: str, def CreateGlobalString(self, mod: LLVMModule*, name: str,
text: str) -> rawptr[GlobalVariable]: text: str) -> GlobalVariable*:
"""Create a string-constant global variable.""" """Create a string-constant global variable."""
return create_global_string(self.Pool, mod, name, text) return create_global_string(self.Pool, mod, name, text)
def CreateGlobalInt(self, mod: rawptr[LLVMModule], name: str, def CreateGlobalInt(self, mod: LLVMModule*, name: str,
bits: int, val: int64) -> rawptr[GlobalVariable]: bits: int, val: int64) -> GlobalVariable*:
"""Create an integer global with an initializer.""" """Create an integer global with an initializer."""
return create_global_int(self.Pool, mod, name, bits, val) return create_global_int(self.Pool, mod, name, bits, val)
def GlobalSetConstant(self, gv: rawptr[GlobalVariable], is_const: int): def GlobalSetConstant(self, gv: GlobalVariable*, is_const: int):
global_set_constant(gv, is_const) global_set_constant(gv, is_const)
def GlobalSetLinkage(self, gv: rawptr[GlobalVariable], linkage: str): def GlobalSetLinkage(self, gv: GlobalVariable*, linkage: str):
global_set_linkage(gv, linkage) global_set_linkage(gv, linkage)
def GlobalSetUnnamedAddr(self, gv: rawptr[GlobalVariable], level: int): def GlobalSetUnnamedAddr(self, gv: GlobalVariable*, level: int):
global_set_unnamed_addr(gv, level) global_set_unnamed_addr(gv, level)
def GlobalSetSection(self, gv: rawptr[GlobalVariable], section: str): def GlobalSetSection(self, gv: GlobalVariable*, section: str):
global_set_section(gv, section) global_set_section(gv, section)
# ---- value creation ---- # ---- value creation ----
def ConstInt(self, bits: int, val: int64) -> rawptr[Value]: def ConstInt(self, bits: int, val: int64) -> Value*:
return const_int(self.Pool, bits, val) return const_int(self.Pool, bits, val)
def ConstInt32(self, val: int64) -> rawptr[Value]: def ConstInt32(self, val: int64) -> Value*:
return const_int32(self.Pool, val) return const_int32(self.Pool, val)
def ConstInt64(self, val: int64) -> rawptr[Value]: def ConstInt64(self, val: int64) -> Value*:
return const_int64(self.Pool, val) return const_int64(self.Pool, val)
def ConstFloat(self, ty: rawptr[LLVMType], val: double) -> rawptr[Value]: def ConstFloat(self, ty: LLVMType*, val: double) -> Value*:
return ConstFloat(self.Pool, ty, val) return ConstFloat(self.Pool, ty, val)
def SSAValue(self, ty: rawptr[LLVMType], name: str) -> rawptr[Value]: def SSAValue(self, ty: LLVMType*, name: str) -> Value*:
return SSAValue(self.Pool, ty, name) return SSAValue(self.Pool, ty, name)
def ConstNull(self, ty: rawptr[LLVMType], name: str) -> rawptr[Value]: def ConstNull(self, ty: LLVMType*, name: str) -> Value*:
return ConstNull(self.Pool, ty, name) return ConstNull(self.Pool, ty, name)
# ---- printing ---- # ---- printing ----
def PrintValue(self, buf: str, size: sizet, val: rawptr[Value]): def PrintValue(self, buf: str, size: sizet, val: Value*):
ValuePrint(buf, size, val, self.Pool) ValuePrint(buf, size, val, self.Pool)
def PrintFunction(self, buf: str, size: sizet, func: rawptr[Function]): def PrintFunction(self, buf: str, size: sizet, func: Function*):
FunctionPrint(buf, size, func, self.Pool) FunctionPrint(buf, size, func, self.Pool)
def PrintModule(self, buf: str, size: sizet, mod: rawptr[LLVMModule]): def PrintModule(self, buf: str, size: sizet, mod: LLVMModule*):
LLVMModulePrint(buf, size, mod, self.Pool, OUTPUT_FULL) LLVMModulePrint(buf, size, mod, self.Pool, OUTPUT_FULL)
# ---- SSA verification ---- # ---- SSA verification ----
def NewVerifyResult(self, buf_size: sizet) -> rawptr[VerifyResult]: def NewVerifyResult(self, buf_size: sizet) -> VerifyResult*:
"""Create a verify-result object (buf_size = error message buffer size).""" """Create a verify-result object (buf_size = error message buffer size)."""
return _new_verify_result(self.Pool, buf_size) return _new_verify_result(self.Pool, buf_size)
def VerifyFunction(self, func: rawptr[Function], def VerifyFunction(self, func: Function*,
result: rawptr[VerifyResult]) -> int: result: VerifyResult*) -> int:
"""Verify SSA correctness of one function; returns error count (0 = pass).""" """Verify SSA correctness of one function; returns error count (0 = pass)."""
return verify_function(self.Pool, func, result) return verify_function(self.Pool, func, result)
def VerifyModule(self, mod: rawptr[LLVMModule], def VerifyModule(self, mod: LLVMModule*,
result: rawptr[VerifyResult]) -> int: result: VerifyResult*) -> int:
"""Verify SSA correctness of all functions in the module; returns error count (0 = pass).""" """Verify SSA correctness of all functions in the module; returns error count (0 = pass)."""
return verify_module(self.Pool, mod, result) return verify_module(self.Pool, mod, result)
mlirlite/__module.vp
+69 -69
View File
@@ -23,7 +23,7 @@ from .__function import (
# and linkage; strong-typed Next via GSListNode[GlobalVariable]. # and linkage; strong-typed Next via GSListNode[GlobalVariable].
novirtual class GlobalVariable(GSListNode[GlobalVariable]): novirtual class GlobalVariable(GSListNode[GlobalVariable]):
Name: str # Global name (e.g. ".str" / "my_global") Name: str # Global name (e.g. ".str" / "my_global")
Ty: rawptr[LLVMType] # Variable type Ty: LLVMType* # Variable type
Initializer: rawptr # Initializer Value* (None = no initializer) Initializer: rawptr # Initializer Value* (None = no initializer)
IsConstant: int # 1=constant, 0=variable IsConstant: int # 1=constant, 0=variable
Linkage: str # Linkage ("private"/"internal"/"external"/...) Linkage: str # Linkage ("private"/"internal"/"external"/...)
@@ -36,7 +36,7 @@ novirtual class GlobalVariable(GSListNode[GlobalVariable]):
# strong-typed Next via GSListNode[NamedTypeNode]. # strong-typed Next via GSListNode[NamedTypeNode].
@t.NoVTable @t.NoVTable
class NamedTypeNode(GSListNode[NamedTypeNode]): class NamedTypeNode(GSListNode[NamedTypeNode]):
Ty: rawptr[LLVMType] # Named-struct type pointer Ty: LLVMType* # Named-struct type pointer
IsPacked: int # 1 = packed struct (MLIR !llvm.struct<"name", packed (…)>; no field padding) IsPacked: int # 1 = packed struct (MLIR !llvm.struct<"name", packed (…)>; no field padding)
@@ -61,22 +61,22 @@ class DINamedMeta(GSListNode[DINamedMeta]):
@t.NoVTable @t.NoVTable
class LLVMModule: class LLVMModule:
Name: str # Module name Name: str # Module name
FuncHead: rawptr[Function] # Function list head FuncHead: Function* # Function list head
FuncTail: rawptr[Function] # Function list tail FuncTail: Function* # Function list tail
FuncCount: sizet # Function count FuncCount: sizet # Function count
GlobalHead: rawptr[GlobalVariable] # Global list head GlobalHead: GlobalVariable* # Global list head
GlobalTail: rawptr[GlobalVariable] # Global list tail GlobalTail: GlobalVariable* # Global list tail
GlobalCount: sizet # Global count GlobalCount: sizet # Global count
TargetTriple: str # Target triple (e.g. "x86_64-pc-linux-gnu") TargetTriple: str # Target triple (e.g. "x86_64-pc-linux-gnu")
DataLayout: str # Data layout (e.g. "e-m:e-p270:32:32-...") DataLayout: str # Data layout (e.g. "e-m:e-p270:32:32-...")
NamedTypeHead: rawptr[NamedTypeNode] # Named-struct type list head NamedTypeHead: NamedTypeNode* # Named-struct type list head
NamedTypeTail: rawptr[NamedTypeNode] # Named-struct type list tail NamedTypeTail: NamedTypeNode* # Named-struct type list tail
NamedTypeCount: sizet # Named-struct type count NamedTypeCount: sizet # Named-struct type count
DIMetaHead: rawptr[DINode] # DI metadata node list head (kept in sync; not printed by MLIR) DIMetaHead: DINode* # DI metadata node list head (kept in sync; not printed by MLIR)
DIMetaTail: rawptr[DINode] # DI metadata node list tail DIMetaTail: DINode* # DI metadata node list tail
DIMetaCount: sizet # DI node count (= next !N id) DIMetaCount: sizet # DI node count (= next !N id)
DINamedHead: rawptr[DINamedMeta] # named metadata list head DINamedHead: DINamedMeta* # named metadata list head
DINamedTail: rawptr[DINamedMeta] # named metadata list tail DINamedTail: DINamedMeta* # named metadata list tail
DINamedCount: sizet # named metadata count DINamedCount: sizet # named metadata count
# Total: 18 fields * 8 = 144 bytes (no vtable; same layout as includes/llvmlite) # Total: 18 fields * 8 = 144 bytes (no vtable; same layout as includes/llvmlite)
@@ -84,7 +84,7 @@ class LLVMModule:
# kept as one-line delegates). # kept as one-line delegates).
# ---- List operations ---- # ---- List operations ----
def add_function(self, func: rawptr[Function]): def add_function(self, func: Function*):
"""Append a function to the module's function list (O(1)).""" """Append a function to the module's function list (O(1))."""
if self is None or func is None: return if self is None or func is None: return
func.Next = None func.Next = None
@@ -95,7 +95,7 @@ class LLVMModule:
self.FuncTail = func self.FuncTail = func
self.FuncCount += 1 self.FuncCount += 1
def add_global(self, gv: rawptr[GlobalVariable]): def add_global(self, gv: GlobalVariable*):
"""Append a global to the module's global list (O(1)).""" """Append a global to the module's global list (O(1))."""
if self is None or gv is None: return if self is None or gv is None: return
gv.Next = None gv.Next = None
@@ -127,7 +127,7 @@ class LLVMModule:
""" """
if self is None or pool is None or text is None: if self is None or pool is None or text is None:
return -1 return -1
node: rawptr[DINode] = pool.alloc(DI_NODE_SIZE) node: DINode* = pool.alloc(DI_NODE_SIZE)
if node is None: if node is None:
return -1 return -1
string.memset(node, 0, DI_NODE_SIZE) string.memset(node, 0, DI_NODE_SIZE)
@@ -155,7 +155,7 @@ class LLVMModule:
""" """
if self is None or pool is None or name is None: if self is None or pool is None or name is None:
return return
cur: rawptr[DINamedMeta] = self.DINamedHead cur: DINamedMeta* = self.DINamedHead
cur_steps: sizet = 0 cur_steps: sizet = 0
while cur is not None: while cur is not None:
cur_steps += 1 cur_steps += 1
@@ -178,7 +178,7 @@ class LLVMModule:
cur.Refs = merged cur.Refs = merged
return return
cur = cur.Next cur = cur.Next
entry: rawptr[DINamedMeta] = pool.alloc(DI_NAMED_SIZE) entry: DINamedMeta* = pool.alloc(DI_NAMED_SIZE)
if entry is None: if entry is None:
return return
string.memset(entry, 0, DI_NAMED_SIZE) string.memset(entry, 0, DI_NAMED_SIZE)
@@ -201,7 +201,7 @@ class LLVMModule:
self.DINamedCount += 1 self.DINamedCount += 1
# ---- Named-struct type management ---- # ---- Named-struct type management ----
def add_named_type(self, pool: memhub.MemBuddy*, ty: rawptr[LLVMType]): def add_named_type(self, pool: memhub.MemBuddy*, ty: LLVMType*):
"""Register a named struct type in the module (MLIR keeps the model only, no output). """Register a named struct type in the module (MLIR keeps the model only, no output).
Non-named structs (None Name or non-Struct) are ignored. Dedup by Name; a full definition Non-named structs (None Name or non-Struct) are ignored. Dedup by Name; a full definition
@@ -215,7 +215,7 @@ class LLVMModule:
if name is None: if name is None:
return return
# Dedup check (a full definition may replace an opaque declaration) # Dedup check (a full definition may replace an opaque declaration)
cur: rawptr[NamedTypeNode] = self.NamedTypeHead cur: NamedTypeNode* = self.NamedTypeHead
cnt_dedup: int = 0 cnt_dedup: int = 0
while cur is not None: while cur is not None:
# Step guard: a cyclic NamedTypeHead list (corruption/insert bug) would hang the # Step guard: a cyclic NamedTypeHead list (corruption/insert bug) would hang the
@@ -241,7 +241,7 @@ class LLVMModule:
return return
cur = cur.Next cur = cur.Next
# Create a new node # Create a new node
node: rawptr[NamedTypeNode] = pool.alloc(NAMED_TYPE_NODE_SIZE) node: NamedTypeNode* = pool.alloc(NAMED_TYPE_NODE_SIZE)
if node is None: if node is None:
return return
string.memset(node, 0, NAMED_TYPE_NODE_SIZE) string.memset(node, 0, NAMED_TYPE_NODE_SIZE)
@@ -268,7 +268,7 @@ class LLVMModule:
"""Return 1 if the module already defines a struct with this name, else 0.""" """Return 1 if the module already defines a struct with this name, else 0."""
if self is None or name is None: if self is None or name is None:
return 0 return 0
cur: rawptr[NamedTypeNode] = self.NamedTypeHead cur: NamedTypeNode* = self.NamedTypeHead
cnt_tdm: int = 0 cnt_tdm: int = 0
while cur is not None: while cur is not None:
# Step guard: as above, prevent infinite traversal of a cyclic NamedTypeHead # Step guard: as above, prevent infinite traversal of a cyclic NamedTypeHead
@@ -287,7 +287,7 @@ class LLVMModule:
return 0 return 0
def ensure_opaque_for_type(self, pool: memhub.MemBuddy*, def ensure_opaque_for_type(self, pool: memhub.MemBuddy*,
ty: rawptr[LLVMType]): ty: LLVMType*):
"""Add opaque declarations for cross-module struct references in a type. """Add opaque declarations for cross-module struct references in a type.
When the type references Ptr(Struct(name)) with a '.' in name (SHA1-qualified) and the When the type references Ptr(Struct(name)) with a '.' in name (SHA1-qualified) and the
@@ -343,7 +343,7 @@ class LLVMModule:
# Globals (MLIR has no standalone type-definition line: named structs are inlined at the # Globals (MLIR has no standalone type-definition line: named structs are inlined at the
# use site, so NamedTypeHead definitions are not emitted here, only registered for lookup). # use site, so NamedTypeHead definitions are not emitted here, only registered for lookup).
gv: rawptr[GlobalVariable] = self.GlobalHead gv: GlobalVariable* = self.GlobalHead
gv_steps: sizet = 0 gv_steps: sizet = 0
while gv is not None: while gv is not None:
gv_steps += 1 gv_steps += 1
@@ -365,7 +365,7 @@ class LLVMModule:
gv = gv.Next gv = gv.Next
# Walk functions (filter declare/define by mode) # Walk functions (filter declare/define by mode)
func: rawptr[Function] = self.FuncHead func: Function* = self.FuncHead
func_steps: sizet = 0 func_steps: sizet = 0
while func is not None: while func is not None:
func_steps += 1 func_steps += 1
@@ -397,7 +397,7 @@ class LLVMModule:
# Name-only type text (%"sha1.Cls") must expand to the inline named body, so this publishes a # Name-only type text (%"sha1.Cls") must expand to the inline named body, so this publishes a
# name → full-definition lookup (opaque entries too, so they report "still opaque", not # name → full-definition lookup (opaque entries too, so they report "still opaque", not
# "unregistered") plus each node's packed flag (NamedTypeNode.IsPacked) for the render side. # "unregistered") plus each node's packed flag (NamedTypeNode.IsPacked) for the render side.
def _MlirPublishNamedTypes(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*): def _MlirPublishNamedTypes(mod: LLVMModule*, pool: memhub.MemBuddy*):
"""Rebuild the named-struct registry from NamedTypeHead (print-time lookup, incl. packed). """Rebuild the named-struct registry from NamedTypeHead (print-time lookup, incl. packed).
Count the real list length first (not trusting NamedTypeCount), then allocate exactly that Count the real list length first (not trusting NamedTypeCount), then allocate exactly that
@@ -407,7 +407,7 @@ def _MlirPublishNamedTypes(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*):
if mod is None or pool is None: if mod is None or pool is None:
return return
cnt: sizet = 0 cnt: sizet = 0
nt: rawptr[NamedTypeNode] = mod.NamedTypeHead nt: NamedTypeNode* = mod.NamedTypeHead
nt_steps: sizet = 0 nt_steps: sizet = 0
while nt is not None: while nt is not None:
nt_steps += 1 nt_steps += 1
@@ -434,11 +434,11 @@ def _MlirPublishNamedTypes(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*):
# Factory functions # Factory functions
def new_module(pool: memhub.MemBuddy*, name: str) -> rawptr[LLVMModule]: def new_module(pool: memhub.MemBuddy*, name: str) -> LLVMModule*:
"""Create a module.""" """Create a module."""
# Hardcoded 144 bytes: 18 fields * 8 bytes (no vtable, @t.NoVTable), incl. the DI fields # Hardcoded 144 bytes: 18 fields * 8 bytes (no vtable, @t.NoVTable), incl. the DI fields
# (DIMetaHead/Tail/Count, DINamedHead/Tail/Count), same layout as llvmlite. # (DIMetaHead/Tail/Count, DINamedHead/Tail/Count), same layout as llvmlite.
ptr: rawptr[LLVMModule] = pool.alloc(144) ptr: LLVMModule* = pool.alloc(144)
if ptr is None: return None if ptr is None: return None
string.memset(ptr, 0, 144) string.memset(ptr, 0, 144)
ptr.Name = name ptr.Name = name
@@ -475,9 +475,9 @@ define DI_NODE_SIZE = 16
define DI_NAMED_SIZE = 24 define DI_NAMED_SIZE = 24
def new_global_variable(pool: memhub.MemBuddy*, def new_global_variable(pool: memhub.MemBuddy*,
name: str, ty: rawptr[LLVMType]) -> rawptr[GlobalVariable]: name: str, ty: LLVMType*) -> GlobalVariable*:
"""Create a global variable.""" """Create a global variable."""
ptr: rawptr[GlobalVariable] = pool.alloc(GV_SIZE) ptr: GlobalVariable* = pool.alloc(GV_SIZE)
if ptr is None: return None if ptr is None: return None
string.memset(ptr, 0, GV_SIZE) string.memset(ptr, 0, GV_SIZE)
ptr.Name = name ptr.Name = name
@@ -492,37 +492,37 @@ def new_global_variable(pool: memhub.MemBuddy*,
# List operations (embedded Head/Tail/Count, O(1) append) # List operations (embedded Head/Tail/Count, O(1) append)
def module_add_function(mod: rawptr[LLVMModule], func: rawptr[Function]): def module_add_function(mod: LLVMModule*, func: Function*):
mod.add_function(func) mod.add_function(func)
def module_get_func_head(mod: rawptr[LLVMModule]) -> rawptr[Function]: def module_get_func_head(mod: LLVMModule*) -> Function*:
"""Return the module's function list head (cross-module accessor bypassing the stub-field trap).""" """Return the module's function list head (cross-module accessor bypassing the stub-field trap)."""
if mod is None: if mod is None:
return None return None
return mod.FuncHead return mod.FuncHead
def module_add_global(mod: rawptr[LLVMModule], gv: rawptr[GlobalVariable]): def module_add_global(mod: LLVMModule*, gv: GlobalVariable*):
mod.add_global(gv) mod.add_global(gv)
def module_set_target(mod: rawptr[LLVMModule], triple: str): def module_set_target(mod: LLVMModule*, triple: str):
mod.set_target(triple) mod.set_target(triple)
def module_set_datalayout(mod: rawptr[LLVMModule], layout: str): def module_set_datalayout(mod: LLVMModule*, layout: str):
mod.set_datalayout(layout) mod.set_datalayout(layout)
# DI debug metadata (kept in sync; ignored at MLIR print time, model only) # DI debug metadata (kept in sync; ignored at MLIR print time, model only)
def module_add_di_node(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*, def module_add_di_node(mod: LLVMModule*, pool: memhub.MemBuddy*,
text: str) -> int: text: str) -> int:
"""Append a DI metadata node; return its !N id (-1 on failure).""" """Append a DI metadata node; return its !N id (-1 on failure)."""
return mod.add_di_node(pool, text) return mod.add_di_node(pool, text)
def module_add_named_metadata(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*, def module_add_named_metadata(mod: LLVMModule*, pool: memhub.MemBuddy*,
name: str, refs: str): name: str, refs: str):
"""Register named metadata "!<name> = !{ <refs> }".""" """Register named metadata "!<name> = !{ <refs> }"."""
mod.add_named_metadata(pool, name, refs) mod.add_named_metadata(pool, name, refs)
@@ -535,7 +535,7 @@ def module_add_named_metadata(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*,
# name only), created by Struct(pool, None, -1, name). Must be distinguished from an empty struct # name only), created by Struct(pool, None, -1, name). Must be distinguished from an empty struct
# (fcount==0, fields==None), which is a valid full definition ({} type, allocatable). # (fcount==0, fields==None), which is a valid full definition ({} type, allocatable).
# Returns: 1 = opaque / 0 = not. # Returns: 1 = opaque / 0 = not.
def _is_opaque_struct(ty: rawptr[LLVMType]) -> int: def _is_opaque_struct(ty: LLVMType*) -> int:
"""Return 1 if the type is an opaque struct, else 0. """Return 1 if the type is an opaque struct, else 0.
opaque is a cross-module forward declaration (name only) created by opaque is a cross-module forward declaration (name only) created by
@@ -555,13 +555,13 @@ def _is_opaque_struct(ty: rawptr[LLVMType]) -> int:
return 0 return 0
def module_add_named_type(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*, def module_add_named_type(mod: LLVMModule*, pool: memhub.MemBuddy*,
ty: rawptr[LLVMType]): ty: LLVMType*):
mod.add_named_type(pool, ty) mod.add_named_type(pool, ty)
def module_set_named_type_packed(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*, def module_set_named_type_packed(mod: LLVMModule*, pool: memhub.MemBuddy*,
ty: rawptr[LLVMType], is_packed: int): ty: LLVMType*, is_packed: int):
"""Set a named struct's packed flag by name (MLIR emits !llvm.struct<"name", packed (…)>). """Set a named struct's packed flag by name (MLIR emits !llvm.struct<"name", packed (…)>).
Called after parsing @c.Attribute(t.attr.packed) so llc computes field offsets/GEP with the Called after parsing @c.Attribute(t.attr.packed) so llc computes field offsets/GEP with the
@@ -575,7 +575,7 @@ def module_set_named_type_packed(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*
name: str = get_struct_name(ty) name: str = get_struct_name(ty)
if name is None: if name is None:
return return
cur: rawptr[NamedTypeNode] = mod.NamedTypeHead cur: NamedTypeNode* = mod.NamedTypeHead
cnt_p: int = 0 cnt_p: int = 0
while cur is not None: while cur is not None:
cnt_p += 1 cnt_p += 1
@@ -592,13 +592,13 @@ def module_set_named_type_packed(mod: rawptr[LLVMModule], pool: memhub.MemBuddy*
# module_ensure_opaque_for_type - add opaque declarations for cross-module struct references. # module_ensure_opaque_for_type - add opaque declarations for cross-module struct references.
# Recursively scans the LLVMType tree; for a Ptr(Struct(name)) whose '.'-containing (SHA1-qualified) # Recursively scans the LLVMType tree; for a Ptr(Struct(name)) whose '.'-containing (SHA1-qualified)
# name is undefined in the module, adds an opaque declaration, fixing llc "use of undefined type". # name is undefined in the module, adds an opaque declaration, fixing llc "use of undefined type".
def _is_type_defined_in_module(mod: rawptr[LLVMModule], name: str) -> int: def _is_type_defined_in_module(mod: LLVMModule*, name: str) -> int:
return mod._is_type_defined_in_module(name) return mod._is_type_defined_in_module(name)
def _scan_type_for_cross_module_refs(pool: memhub.MemBuddy*, def _scan_type_for_cross_module_refs(pool: memhub.MemBuddy*,
mod: rawptr[LLVMModule], mod: LLVMModule*,
ty: rawptr[LLVMType], ty: LLVMType*,
depth: int = 0): depth: int = 0):
"""Recursively scan the type tree and add opaque declarations for cross-module struct refs.""" """Recursively scan the type tree and add opaque declarations for cross-module struct refs."""
if ty is None or mod is None or pool is None: if ty is None or mod is None or pool is None:
@@ -620,13 +620,13 @@ def _scan_type_for_cross_module_refs(pool: memhub.MemBuddy*,
# Create an opaque type and add it to the module; fcount=-1 marks # Create an opaque type and add it to the module; fcount=-1 marks
# opaque (vs. empty {} struct, whose fcount==0 is a valid # opaque (vs. empty {} struct, whose fcount==0 is a valid
# full definition and can be alloc'd). # full definition and can be alloc'd).
opaque_ty: rawptr[LLVMType] = Struct(pool, None, -1, sname) opaque_ty: LLVMType* = Struct(pool, None, -1, sname)
if opaque_ty is not None: if opaque_ty is not None:
module_add_named_type(mod, pool, opaque_ty) module_add_named_type(mod, pool, opaque_ty)
# Recurse into struct fields for cross-module refs # Recurse into struct fields for cross-module refs
# (e.g. HashTable in TypeRegistry{HashTable*, MemManager*}). # (e.g. HashTable in TypeRegistry{HashTable*, MemManager*}).
if sfields is not None: if sfields is not None:
fld: rawptr[ParamNode] = sfields fld: ParamNode* = sfields
fld_steps: sizet = 0 fld_steps: sizet = 0
while fld is not None: while fld is not None:
fld_steps += 1 fld_steps += 1
@@ -642,7 +642,7 @@ def _scan_type_for_cross_module_refs(pool: memhub.MemBuddy*,
case LLVMType.Struct(sfields2, sfcount2, sname2): case LLVMType.Struct(sfields2, sfcount2, sname2):
# Top-level struct (non-pointer): recurse into fields # Top-level struct (non-pointer): recurse into fields
if sfields2 is not None: if sfields2 is not None:
fld2: rawptr[ParamNode] = sfields2 fld2: ParamNode* = sfields2
fld2_steps: sizet = 0 fld2_steps: sizet = 0
while fld2 is not None: while fld2 is not None:
fld2_steps += 1 fld2_steps += 1
@@ -660,32 +660,32 @@ def _scan_type_for_cross_module_refs(pool: memhub.MemBuddy*,
pass pass
def module_ensure_opaque_for_type(mod: rawptr[LLVMModule], def module_ensure_opaque_for_type(mod: LLVMModule*,
pool: memhub.MemBuddy*, pool: memhub.MemBuddy*,
ty: rawptr[LLVMType]): ty: LLVMType*):
mod.ensure_opaque_for_type(pool, ty) mod.ensure_opaque_for_type(pool, ty)
# Global variable attribute setters # Global variable attribute setters
def global_set_constant(gv: rawptr[GlobalVariable], is_const: int): def global_set_constant(gv: GlobalVariable*, is_const: int):
"""Set whether the global is a constant.""" """Set whether the global is a constant."""
if gv is None: return if gv is None: return
gv.IsConstant = is_const gv.IsConstant = is_const
def global_set_linkage(gv: rawptr[GlobalVariable], linkage: str): def global_set_linkage(gv: GlobalVariable*, linkage: str):
"""Set the linkage (private/internal/external/...).""" """Set the linkage (private/internal/external/...)."""
if gv is None: return if gv is None: return
gv.Linkage = linkage gv.Linkage = linkage
def global_set_unnamed_addr(gv: rawptr[GlobalVariable], level: int): def global_set_unnamed_addr(gv: GlobalVariable*, level: int):
"""Set the unnamed_addr attribute (0=none, 1=unnamed_addr, 2=local_unnamed_addr).""" """Set the unnamed_addr attribute (0=none, 1=unnamed_addr, 2=local_unnamed_addr)."""
if gv is None: return if gv is None: return
gv.UnnamedAddr = level gv.UnnamedAddr = level
def global_set_section(gv: rawptr[GlobalVariable], section: str): def global_set_section(gv: GlobalVariable*, section: str):
"""Set the section name.""" """Set the section name."""
if gv is None: return if gv is None: return
gv.Section = section gv.Section = section
@@ -704,7 +704,7 @@ _MlirModOutTrunc: int = 0
# LLVMModulePrint: serialize the module to .ll text; mode: OUTPUT_FULL / OUTPUT_STUB / OUTPUT_TEXT. # LLVMModulePrint: serialize the module to .ll text; mode: OUTPUT_FULL / OUTPUT_STUB / OUTPUT_TEXT.
def LLVMModulePrint(buf: str, size: sizet, def LLVMModulePrint(buf: str, size: sizet,
mod: rawptr[LLVMModule], pool: memhub.MemBuddy*, mod: LLVMModule*, pool: memhub.MemBuddy*,
mode: int): mode: int):
global _MlirModOutTrunc global _MlirModOutTrunc
_MlirModOutTrunc = 0 _MlirModOutTrunc = 0
@@ -720,7 +720,7 @@ def LLVMModulePrint(buf: str, size: sizet,
# zeroinitializer, struct/vtable, symbol-referencing aggregates, pointer initializers → empty value # zeroinitializer, struct/vtable, symbol-referencing aggregates, pointer initializers → empty value
# parens + initializer region). Any form neither path covers fails loud via MlirFail. # parens + initializer region). Any form neither path covers fails loud via MlirFail.
def _MlirGlobalLine(buf: str, size: sizet, def _MlirGlobalLine(buf: str, size: sizet,
pool: memhub.MemBuddy*, gv: rawptr[GlobalVariable], pool: memhub.MemBuddy*, gv: GlobalVariable*,
stub: int): stub: int):
"""Render one llvm.mlir.global (stub=1 emits the external declaration form).""" """Render one llvm.mlir.global (stub=1 emits the external declaration form)."""
if gv is None: if gv is None:
@@ -803,7 +803,7 @@ def _MlirGlobalLine(buf: str, size: sizet,
def _MlirGlobalInit(buf: str, size: sizet, def _MlirGlobalInit(buf: str, size: sizet,
pool: memhub.MemBuddy*, gv: rawptr[GlobalVariable]): pool: memhub.MemBuddy*, gv: GlobalVariable*):
"""Render a global initializer (MLIR attribute text).""" """Render a global initializer (MLIR attribute text)."""
x: str = gv.Initializer x: str = gv.Initializer
if x is None: if x is None:
@@ -1057,7 +1057,7 @@ def _MlirGvArrayNeedsRegion(x: str) -> int:
def _MlirGlobalInitRegion(buf: str, size: sizet, def _MlirGlobalInitRegion(buf: str, size: sizet,
pool: memhub.MemBuddy*, gv: rawptr[GlobalVariable]): pool: memhub.MemBuddy*, gv: GlobalVariable*):
"""Render the initializer region body (lines indented 2 spaces, without the outer braces). """Render the initializer region body (lines indented 2 spaces, without the outer braces).
Each line ends with '\\n'; the caller appends '}' and the module layer re-indents by 2. Each line ends with '\\n'; the caller appends '}' and the module layer re-indents by 2.
@@ -1116,7 +1116,7 @@ def _MlirGlobalInitRegion(buf: str, size: sizet,
_append_cstr(buf, size, "\n") _append_cstr(buf, size, "\n")
def _MlirGvWalk(p: str, ty: rawptr[LLVMType], path: str, depth: int) -> str: def _MlirGvWalk(p: str, ty: LLVMType*, path: str, depth: int) -> str:
"""Walk one node of the initializer-tree × type-tree in parallel; returns the new cursor. """Walk one node of the initializer-tree × type-tree in parallel; returns the new cursor.
The result SSA name goes to _MlirGvLast (leaf = materialized name; aggregate = last The result SSA name goes to _MlirGvLast (leaf = materialized name; aggregate = last
@@ -1230,15 +1230,15 @@ def _MlirGvPathChild(path: str, idx: int, depth: int) -> str:
return nb return nb
def _MlirGvWalkStruct(p: str, ty: rawptr[LLVMType], path: str, depth: int) -> str: def _MlirGvWalkStruct(p: str, ty: LLVMType*, path: str, depth: int) -> str:
"""Struct initializer { elem, elem, … }: field types come from the type tree's Struct field chain.""" """Struct initializer { elem, elem, … }: field types come from the type tree's Struct field chain."""
fields: rawptr[ParamNode] = None fields: ParamNode* = None
match ty: match ty:
case LLVMType.Struct(sf, sfc, sn): case LLVMType.Struct(sf, sfc, sn):
fields = sf fields = sf
case _: case _:
MlirFail("MLIR 渲染: 初值为结构体，但全局类型不是结构体") MlirFail("MLIR 渲染: 初值为结构体，但全局类型不是结构体")
cur: rawptr[ParamNode] = fields cur: ParamNode* = fields
p = p + 1 p = p + 1
idx: int = 0 idx: int = 0
done: int = 0 done: int = 0
@@ -1256,7 +1256,7 @@ def _MlirGvWalkStruct(p: str, ty: rawptr[LLVMType], path: str, depth: int) -> st
elif p[0] == ',': elif p[0] == ',':
p = p + 1 p = p + 1
else: else:
fty: rawptr[LLVMType] = None fty: LLVMType* = None
if cur is not None: if cur is not None:
fty = paramnode_get_ty(cur) fty = paramnode_get_ty(cur)
p = _MlirGvWalk(p, fty, _MlirGvPathChild(path, idx, depth), depth + 1) p = _MlirGvWalk(p, fty, _MlirGvPathChild(path, idx, depth), depth + 1)
@@ -1268,9 +1268,9 @@ def _MlirGvWalkStruct(p: str, ty: rawptr[LLVMType], path: str, depth: int) -> st
return p return p
def _MlirGvWalkArray(p: str, ty: rawptr[LLVMType], path: str, depth: int) -> str: def _MlirGvWalkArray(p: str, ty: LLVMType*, path: str, depth: int) -> str:
"""Array initializer [ elem, elem, … ]: element type comes from the type tree's Array element type.""" """Array initializer [ elem, elem, … ]: element type comes from the type tree's Array element type."""
elem_ty: rawptr[LLVMType] = None elem_ty: LLVMType* = None
match ty: match ty:
case LLVMType.Array(ae, ac): case LLVMType.Array(ae, ac):
elem_ty = ae elem_ty = ae
@@ -1326,7 +1326,7 @@ def _MlirGvIsBareValue(p: str) -> int:
return 0 return 0
def _MlirGvWalkLeaf(p: str, ty: rawptr[LLVMType], path: str, depth: int) -> str: def _MlirGvWalkLeaf(p: str, ty: LLVMType*, path: str, depth: int) -> str:
"""Leaf element `<LLVM type> <value>`: the value parses to a symbol ref / null / scalar literal. """Leaf element `<LLVM type> <value>`: the value parses to a symbol ref / null / scalar literal.
The element MLIR type comes from the type tree (ty), not the text's type token. A top-level The element MLIR type comes from the type tree (ty), not the text's type token. A top-level
@@ -1465,7 +1465,7 @@ def _MlirGvEmitAddressOf(name: str):
string.strcpy(_MlirGvLast, ln) string.strcpy(_MlirGvLast, ln)
def _MlirGvEmitZero(ty: rawptr[LLVMType]): def _MlirGvEmitZero(ty: LLVMType*):
"""Emit a leaf op: %vN = llvm.mlir.zero : <element MLIR type>.""" """Emit a leaf op: %vN = llvm.mlir.zero : <element MLIR type>."""
mt: str = _MlirGvTyBuf mt: str = _MlirGvTyBuf
mt[0] = '\0' mt[0] = '\0'
@@ -1479,7 +1479,7 @@ def _MlirGvEmitZero(ty: rawptr[LLVMType]):
string.strcpy(_MlirGvLast, ln) string.strcpy(_MlirGvLast, ln)
def _MlirGvEmitConst(val: str, ty: rawptr[LLVMType]): def _MlirGvEmitConst(val: str, ty: LLVMType*):
"""Emit a leaf op: %vN = llvm.mlir.constant(<lit> : <element MLIR type>) : <same type>.""" """Emit a leaf op: %vN = llvm.mlir.constant(<lit> : <element MLIR type>) : <same type>."""
mt: str = _MlirGvTyBuf mt: str = _MlirGvTyBuf
mt[0] = '\0' mt[0] = '\0'
mlirlite/__types.vp
+95 -95
View File
@@ -24,23 +24,23 @@ class LLVMType(t.REnum):
# Pointer type: pointee* # Pointer type: pointee*
class Ptr: class Ptr:
Pointee: rawptr[LLVMType] Pointee: LLVMType*
# Function type: ret (params) # Function type: ret (params)
class Func: class Func:
Ret: rawptr[LLVMType] Ret: LLVMType*
Params: rawptr[ParamNode] Params: ParamNode*
PCount: int PCount: int
# Array type: [N x elem_ty] # Array type: [N x elem_ty]
class Array: class Array:
ElemTy: rawptr[LLVMType] ElemTy: LLVMType*
Count: int Count: int
# Struct type {ty1, ty2, ...} or %"name" = type {...}; Fields reuse the ParamNode list # Struct type {ty1, ty2, ...} or %"name" = type {...}; Fields reuse the ParamNode list
# (ParamNode.Ty is the field type); a non-None Name makes it named (%"name" output). # (ParamNode.Ty is the field type); a non-None Name makes it named (%"name" output).
class Struct: class Struct:
Fields: rawptr[ParamNode] Fields: ParamNode*
FCount: int FCount: int
Name: str Name: str
@@ -73,52 +73,52 @@ def _TypeSizeGuard() -> sizet:
return sz return sz
def _new_type(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def _new_type(pool: memhub.MemBuddy*) -> LLVMType*:
"""Allocate a zero-initialized LLVMType from the pool.""" """Allocate a zero-initialized LLVMType from the pool."""
sz_nt: sizet = _TypeSizeGuard() sz_nt: sizet = _TypeSizeGuard()
ptr: rawptr[LLVMType] = pool.alloc(sz_nt) ptr: LLVMType* = pool.alloc(sz_nt)
if ptr: if ptr:
string.memset(ptr, 0, sz_nt) string.memset(ptr, 0, sz_nt)
return ptr return ptr
# Type factory functions # Type factory functions
def Int1(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Int1(pool: memhub.MemBuddy*) -> LLVMType*:
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Int(1)) c.DerefAs(ptr, LLVMType.Int(1))
return ptr return ptr
def Int8(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Int8(pool: memhub.MemBuddy*) -> LLVMType*:
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Int(8)) c.DerefAs(ptr, LLVMType.Int(8))
return ptr return ptr
def Int16(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Int16(pool: memhub.MemBuddy*) -> LLVMType*:
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Int(16)) c.DerefAs(ptr, LLVMType.Int(16))
return ptr return ptr
def Int32(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Int32(pool: memhub.MemBuddy*) -> LLVMType*:
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Int(32)) c.DerefAs(ptr, LLVMType.Int(32))
return ptr return ptr
def Int64(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Int64(pool: memhub.MemBuddy*) -> LLVMType*:
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Int(64)) c.DerefAs(ptr, LLVMType.Int(64))
return ptr return ptr
def Ptr(pool: memhub.MemBuddy*, pointee: rawptr[LLVMType]) -> rawptr[LLVMType]: def Ptr(pool: memhub.MemBuddy*, pointee: LLVMType*) -> LLVMType*:
"""Create pointer type Ptr(pointee). """Create pointer type Ptr(pointee).
LLVM IR forbids void* pointers ("pointers to void are invalid"): None or LLVM IR forbids void* pointers ("pointers to void are invalid"): None or
@@ -126,7 +126,7 @@ def Ptr(pool: memhub.MemBuddy*, pointee: rawptr[LLVMType]) -> rawptr[LLVMType]:
all other types build Ptr(pointee) normally. all other types build Ptr(pointee) normally.
""" """
# Pre-check: reject Void / None pointee (void* is illegal). # Pre-check: reject Void / None pointee (void* is illegal).
safe_pointee: rawptr[LLVMType] = pointee safe_pointee: LLVMType* = pointee
if safe_pointee is None: if safe_pointee is None:
safe_pointee = Int8(pool) safe_pointee = Int8(pool)
else: else:
@@ -135,84 +135,84 @@ def Ptr(pool: memhub.MemBuddy*, pointee: rawptr[LLVMType]) -> rawptr[LLVMType]:
safe_pointee = Int8(pool) safe_pointee = Int8(pool)
case _: case _:
pass pass
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Ptr(safe_pointee)) c.DerefAs(ptr, LLVMType.Ptr(safe_pointee))
return ptr return ptr
def Func(pool: memhub.MemBuddy*, ret: rawptr[LLVMType], def Func(pool: memhub.MemBuddy*, ret: LLVMType*,
params: rawptr[ParamNode], count: int) -> rawptr[LLVMType]: params: ParamNode*, count: int) -> LLVMType*:
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Func(ret, params, count)) c.DerefAs(ptr, LLVMType.Func(ret, params, count))
return ptr return ptr
def Void(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Void(pool: memhub.MemBuddy*) -> LLVMType*:
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Void()) c.DerefAs(ptr, LLVMType.Void())
return ptr return ptr
def Array(pool: memhub.MemBuddy*, elem_ty: rawptr[LLVMType], def Array(pool: memhub.MemBuddy*, elem_ty: LLVMType*,
count: int) -> rawptr[LLVMType]: count: int) -> LLVMType*:
"""Create array type [count x elem_ty].""" """Create array type [count x elem_ty]."""
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Array(elem_ty, count)) c.DerefAs(ptr, LLVMType.Array(elem_ty, count))
return ptr return ptr
def Struct(pool: memhub.MemBuddy*, fields: rawptr[ParamNode], def Struct(pool: memhub.MemBuddy*, fields: ParamNode*,
fcount: int, name: str) -> rawptr[LLVMType]: fcount: int, name: str) -> LLVMType*:
"""Create struct type {ty1, ty2, ...}. """Create struct type {ty1, ty2, ...}.
fields is the ParamNode list head and fcount the field count; a non-None name fields is the ParamNode list head and fcount the field count; a non-None name
(e.g. "sha1.ClassName") yields a named struct printed as %"name", else anonymous. (e.g. "sha1.ClassName") yields a named struct printed as %"name", else anonymous.
""" """
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Struct(fields, fcount, name)) c.DerefAs(ptr, LLVMType.Struct(fields, fcount, name))
return ptr return ptr
def Half(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Half(pool: memhub.MemBuddy*) -> LLVMType*:
"""Create half-precision float type half (16-bit).""" """Create half-precision float type half (16-bit)."""
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Float(16)) c.DerefAs(ptr, LLVMType.Float(16))
return ptr return ptr
def Float(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Float(pool: memhub.MemBuddy*) -> LLVMType*:
"""Create single-precision float type float (32-bit).""" """Create single-precision float type float (32-bit)."""
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Float(32)) c.DerefAs(ptr, LLVMType.Float(32))
return ptr return ptr
def Double(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Double(pool: memhub.MemBuddy*) -> LLVMType*:
"""Create double-precision float type double (64-bit).""" """Create double-precision float type double (64-bit)."""
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Float(64)) c.DerefAs(ptr, LLVMType.Float(64))
return ptr return ptr
def FP128(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def FP128(pool: memhub.MemBuddy*) -> LLVMType*:
"""Create quad-precision float type fp128 (128-bit).""" """Create quad-precision float type fp128 (128-bit)."""
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Float(128)) c.DerefAs(ptr, LLVMType.Float(128))
return ptr return ptr
def Label(pool: memhub.MemBuddy*) -> rawptr[LLVMType]: def Label(pool: memhub.MemBuddy*) -> LLVMType*:
"""Create label type label.""" """Create label type label."""
ptr: rawptr[LLVMType] = _new_type(pool) ptr: LLVMType* = _new_type(pool)
if ptr is None: return None if ptr is None: return None
c.DerefAs(ptr, LLVMType.Label()) c.DerefAs(ptr, LLVMType.Label())
return ptr return ptr
@@ -222,9 +222,9 @@ def Label(pool: memhub.MemBuddy*) -> rawptr[LLVMType]:
# ParamNode hardcoded size: Next(8) + Ty(8) = 16 bytes # ParamNode hardcoded size: Next(8) + Ty(8) = 16 bytes
define PNODE_SIZE = 16 define PNODE_SIZE = 16
def new_param_node(pool: memhub.MemBuddy*, ty: rawptr[LLVMType]) -> rawptr[ParamNode]: def new_param_node(pool: memhub.MemBuddy*, ty: LLVMType*) -> ParamNode*:
"""Create a parameter node with Ty set to the given type pointer.""" """Create a parameter node with Ty set to the given type pointer."""
ptr: rawptr[ParamNode] = pool.alloc(PNODE_SIZE) ptr: ParamNode* = pool.alloc(PNODE_SIZE)
if ptr is None: return None if ptr is None: return None
string.memset(ptr, 0, PNODE_SIZE) string.memset(ptr, 0, PNODE_SIZE)
ptr.Ty = ty ptr.Ty = ty
@@ -232,8 +232,8 @@ def new_param_node(pool: memhub.MemBuddy*, ty: rawptr[LLVMType]) -> rawptr[Param
return ptr return ptr
def param_list_append(head: rawptr[ParamNode], tail: rawptr[ParamNode], def param_list_append(head: ParamNode*, tail: ParamNode*,
node: rawptr[ParamNode]) -> rawptr[ParamNode]: node: ParamNode*) -> ParamNode*:
"""Append node to the parameter list tail, returning head and updated tail.""" """Append node to the parameter list tail, returning head and updated tail."""
if node is None: return head if node is None: return head
node.Next = None node.Next = None
@@ -246,28 +246,28 @@ def param_list_append(head: rawptr[ParamNode], tail: rawptr[ParamNode],
# ParamNode field accessors (bypass the stub-type limitation): cross-module consumers # ParamNode field accessors (bypass the stub-type limitation): cross-module consumers
# only have the stub type, so field access is skipped; these run where the type is full. # only have the stub type, so field access is skipped; these run where the type is full.
def paramnode_get_ty(node: rawptr[ParamNode]) -> rawptr[LLVMType]: def paramnode_get_ty(node: ParamNode*) -> LLVMType*:
"""Return the parameter node's type.""" """Return the parameter node's type."""
if node is None: if node is None:
return None return None
return (rawptr[LLVMType])(node.Ty) return (LLVMType*)(node.Ty)
def paramnode_get_next(node: rawptr[ParamNode]) -> rawptr[ParamNode]: def paramnode_get_next(node: ParamNode*) -> ParamNode*:
"""Return the next parameter node in the list.""" """Return the next parameter node in the list."""
if node is None: if node is None:
return None return None
return node.Next return node.Next
def paramnode_set_ty(node: rawptr[ParamNode], ty: rawptr[LLVMType]): def paramnode_set_ty(node: ParamNode*, ty: LLVMType*):
"""Set the parameter node's type.""" """Set the parameter node's type."""
if node is None: if node is None:
return return
node.Ty = ty node.Ty = ty
def paramnode_set_next(node: rawptr[ParamNode], nxt: rawptr[ParamNode]): def paramnode_set_next(node: ParamNode*, nxt: ParamNode*):
"""Set the next parameter node in the list.""" """Set the next parameter node in the list."""
if node is None: if node is None:
return return
@@ -284,64 +284,64 @@ class LLVMTypeCore:
def __init__(self, pool: memhub.MemBuddy*): def __init__(self, pool: memhub.MemBuddy*):
self.Pool = pool self.Pool = pool
def Int1(self) -> rawptr[LLVMType]: def Int1(self) -> LLVMType*:
return Int1(self.Pool) return Int1(self.Pool)
def Int8(self) -> rawptr[LLVMType]: def Int8(self) -> LLVMType*:
return Int8(self.Pool) return Int8(self.Pool)
def Int16(self) -> rawptr[LLVMType]: def Int16(self) -> LLVMType*:
return Int16(self.Pool) return Int16(self.Pool)
def Int32(self) -> rawptr[LLVMType]: def Int32(self) -> LLVMType*:
return Int32(self.Pool) return Int32(self.Pool)
def Int64(self) -> rawptr[LLVMType]: def Int64(self) -> LLVMType*:
return Int64(self.Pool) return Int64(self.Pool)
def Ptr(self, pointee: rawptr[LLVMType]) -> rawptr[LLVMType]: def Ptr(self, pointee: LLVMType*) -> LLVMType*:
return Ptr(self.Pool, pointee) return Ptr(self.Pool, pointee)
def Func(self, ret: rawptr[LLVMType], params: rawptr[ParamNode], def Func(self, ret: LLVMType*, params: ParamNode*,
count: int) -> rawptr[LLVMType]: count: int) -> LLVMType*:
return Func(self.Pool, ret, params, count) return Func(self.Pool, ret, params, count)
def Array(self, elem_ty: rawptr[LLVMType], count: int) -> rawptr[LLVMType]: def Array(self, elem_ty: LLVMType*, count: int) -> LLVMType*:
return Array(self.Pool, elem_ty, count) return Array(self.Pool, elem_ty, count)
def Struct(self, fields: rawptr[ParamNode], fcount: int, def Struct(self, fields: ParamNode*, fcount: int,
name: str = None) -> rawptr[LLVMType]: name: str = None) -> LLVMType*:
return Struct(self.Pool, fields, fcount, name) return Struct(self.Pool, fields, fcount, name)
def Void(self) -> rawptr[LLVMType]: def Void(self) -> LLVMType*:
return Void(self.Pool) return Void(self.Pool)
def Half(self) -> rawptr[LLVMType]: def Half(self) -> LLVMType*:
return Half(self.Pool) return Half(self.Pool)
def Float(self) -> rawptr[LLVMType]: def Float(self) -> LLVMType*:
return Float(self.Pool) return Float(self.Pool)
def Double(self) -> rawptr[LLVMType]: def Double(self) -> LLVMType*:
return Double(self.Pool) return Double(self.Pool)
def FP128(self) -> rawptr[LLVMType]: def FP128(self) -> LLVMType*:
return FP128(self.Pool) return FP128(self.Pool)
def Label(self) -> rawptr[LLVMType]: def Label(self) -> LLVMType*:
return Label(self.Pool) return Label(self.Pool)
def NewParamNode(self, ty: rawptr[LLVMType]) -> rawptr[ParamNode]: def NewParamNode(self, ty: LLVMType*) -> ParamNode*:
return new_param_node(self.Pool, ty) return new_param_node(self.Pool, ty)
# ---- List helpers ---- # ---- List helpers ----
def ParamListAppend(self, head: rawptr[ParamNode], tail: rawptr[ParamNode], def ParamListAppend(self, head: ParamNode*, tail: ParamNode*,
node: rawptr[ParamNode]) -> rawptr[ParamNode]: node: ParamNode*) -> ParamNode*:
"""Append node to the parameter/field list, returning the new tail.""" """Append node to the parameter/field list, returning the new tail."""
return param_list_append(head, tail, node) return param_list_append(head, tail, node)
# ---- Printing ---- # ---- Printing ----
def PrintType(self, buf: str, size: sizet, ty: rawptr[LLVMType]): def PrintType(self, buf: str, size: sizet, ty: LLVMType*):
TypePrint(buf, size, ty, self.Pool) TypePrint(buf, size, ty, self.Pool)
@@ -418,7 +418,7 @@ def MlirNamedTypesClear():
_MlirNamedCap = 0 _MlirNamedCap = 0
def MlirNamedTypeRegister(ty: rawptr[LLVMType], is_packed: int): def MlirNamedTypeRegister(ty: LLVMType*, is_packed: int):
"""Register a named struct type and its packed flag (same name: full def replaces opaque). """Register a named struct type and its packed flag (same name: full def replaces opaque).
Dedup matches module_add_named_type; non-named structs are ignored; overflow stops Dedup matches module_add_named_type; non-named structs are ignored; overflow stops
@@ -434,7 +434,7 @@ def MlirNamedTypeRegister(ty: rawptr[LLVMType], is_packed: int):
fcount: int = get_struct_fcount(ty) fcount: int = get_struct_fcount(ty)
for i in range(_MlirNamedCount): for i in range(_MlirNamedCount):
slot: sizet* = _MlirNamedSlot(i) slot: sizet* = _MlirNamedSlot(i)
ex: rawptr[LLVMType] = (rawptr[LLVMType])(slot[0]) ex: LLVMType* = (LLVMType*)(slot[0])
ex_name: str = get_struct_name(ex) ex_name: str = get_struct_name(ex)
if ex_name is not None and string.strcmp(ex_name, name) == 0: if ex_name is not None and string.strcmp(ex_name, name) == 0:
if fcount < 0 and get_struct_fcount(ex) >= 0: if fcount < 0 and get_struct_fcount(ex) >= 0:
@@ -456,7 +456,7 @@ def _MlirNamedFindSlot(name: str) -> int:
return -1 return -1
for i in range(_MlirNamedCount): for i in range(_MlirNamedCount):
slot: sizet* = _MlirNamedSlot(i) slot: sizet* = _MlirNamedSlot(i)
ty: rawptr[LLVMType] = (rawptr[LLVMType])(slot[0]) ty: LLVMType* = (LLVMType*)(slot[0])
nm: str = get_struct_name(ty) nm: str = get_struct_name(ty)
if nm is not None and string.strcmp(nm, name) == 0: if nm is not None and string.strcmp(nm, name) == 0:
return i return i
@@ -517,7 +517,7 @@ def _MlirNamedCheckName(pool: memhub.MemBuddy*, name: str):
def _MlirNamedStructAppend(dst: str, dstsz: sizet, name: str, def _MlirNamedStructAppend(dst: str, dstsz: sizet, name: str,
fields: rawptr[ParamNode], fcount: int, packed: int, fields: ParamNode*, fcount: int, packed: int,
pool: memhub.MemBuddy*, depth: int): pool: memhub.MemBuddy*, depth: int):
"""Append MLIR named-struct type text to dst. """Append MLIR named-struct type text to dst.
@@ -542,7 +542,7 @@ def _MlirNamedStructAppend(dst: str, dstsz: sizet, name: str,
if packed != 0: if packed != 0:
_strappend(dst, dstsz, "packed ") _strappend(dst, dstsz, "packed ")
_strappend(dst, dstsz, "(") _strappend(dst, dstsz, "(")
cur: rawptr[ParamNode] = fields cur: ParamNode* = fields
first: int = 1 first: int = 1
fidx: int = 0 fidx: int = 0
tmp: str = pool.alloc(4096) tmp: str = pool.alloc(4096)
@@ -578,7 +578,7 @@ def _MlirNamedBodyFromTable(dst: str, dstsz: sizet, name: str,
if si < 0: if si < 0:
return 0 return 0
slot: sizet* = _MlirNamedSlot(si) slot: sizet* = _MlirNamedSlot(si)
sty: rawptr[LLVMType] = (rawptr[LLVMType])(slot[0]) sty: LLVMType* = (LLVMType*)(slot[0])
spk: int = int(slot[1]) spk: int = int(slot[1])
match sty: match sty:
case LLVMType.Struct(sf, sc, _): case LLVMType.Struct(sf, sc, _):
@@ -593,7 +593,7 @@ def _MlirNamedBodyFromTable(dst: str, dstsz: sizet, name: str,
# Func→!llvm.func<ret (p0, p1)>, Void→none (omitted at return position); Label/Metadata fail loud. # Func→!llvm.func<ret (p0, p1)>, Void→none (omitted at return position); Label/Metadata fail loud.
# Embedded types already arrive as MLIR text; pool allocates temp buffers for subtypes. # Embedded types already arrive as MLIR text; pool allocates temp buffers for subtypes.
def TypePrint(buf: str, size: sizet, def TypePrint(buf: str, size: sizet,
ty: rawptr[LLVMType], pool: memhub.MemBuddy*): ty: LLVMType*, pool: memhub.MemBuddy*):
"""Serialize type ty as MLIR type text into buf (capacity size). """Serialize type ty as MLIR type text into buf (capacity size).
pool allocates temp buffers for subtypes; overflow (text exceeds size) fails loud, since pool allocates temp buffers for subtypes; overflow (text exceeds size) fails loud, since
@@ -919,7 +919,7 @@ def _MlirNamedStructText(dst: str, dstsz: sizet, p: str, lt: sizet,
"MLIR 渲染: 命名结构体类型文本未在模块中登记完整定义（MLIR 不允许无体前向声明，须以 !llvm.struct<\"name\", (…)> 内联形态使用）", "MLIR 渲染: 命名结构体类型文本未在模块中登记完整定义（MLIR 不允许无体前向声明，须以 !llvm.struct<\"name\", (…)> 内联形态使用）",
nm) nm)
slot: sizet* = _MlirNamedSlot(si) slot: sizet* = _MlirNamedSlot(si)
ty: rawptr[LLVMType] = (rawptr[LLVMType])(slot[0]) ty: LLVMType* = (LLVMType*)(slot[0])
packed: int = int(slot[1]) packed: int = int(slot[1])
match ty: match ty:
case LLVMType.Struct(fields, fcount, _): case LLVMType.Struct(fields, fcount, _):
@@ -1008,7 +1008,7 @@ def _MlirFuncText(dst: str, dstsz: sizet, p: str, lt: sizet, fp: sizet,
define TYPEPRINT_MAX_DEPTH = 100 define TYPEPRINT_MAX_DEPTH = 100
def _MlirTypePrintDepth(buf: str, size: sizet, def _MlirTypePrintDepth(buf: str, size: sizet,
ty: rawptr[LLVMType], pool: memhub.MemBuddy*, ty: LLVMType*, pool: memhub.MemBuddy*,
depth: int): depth: int):
"""Internal MLIR type printer with a recursion depth cap (overwrite-writes buf).""" """Internal MLIR type printer with a recursion depth cap (overwrite-writes buf)."""
if ty is None or buf is None or size == 0: if ty is None or buf is None or size == 0:
@@ -1070,7 +1070,7 @@ def _MlirTypePrintDepth(buf: str, size: sizet,
_MlirTypePrintDepth(rfb, 4096, ret, pool, depth + 1) _MlirTypePrintDepth(rfb, 4096, ret, pool, depth + 1)
_strappend(buf, size, rfb) _strappend(buf, size, rfb)
_strappend(buf, size, " (") _strappend(buf, size, " (")
cur2: rawptr[ParamNode] = params cur2: ParamNode* = params
first2: int = 1 first2: int = 1
_pc2: int = 0 _pc2: int = 0
tmp3: str = pool.alloc(4096) tmp3: str = pool.alloc(4096)
@@ -1100,12 +1100,12 @@ def _MlirTypePrintDepth(buf: str, size: sizet,
def _MlirStructFields(buf: str, size: sizet, def _MlirStructFields(buf: str, size: sizet,
fields: rawptr[ParamNode], pool: memhub.MemBuddy*, fields: ParamNode*, pool: memhub.MemBuddy*,
depth: int): depth: int):
"""Render !llvm.struct<(f0, f1, …)> (overwrite-writes buf).""" """Render !llvm.struct<(f0, f1, …)> (overwrite-writes buf)."""
buf[0] = '\0' buf[0] = '\0'
_strappend(buf, size, "!llvm.struct<(") _strappend(buf, size, "!llvm.struct<(")
cur: rawptr[ParamNode] = fields cur: ParamNode* = fields
first: int = 1 first: int = 1
fidx: int = 0 fidx: int = 0
tmp: str = pool.alloc(4096) tmp: str = pool.alloc(4096)
@@ -1154,7 +1154,7 @@ def _strappend(dst: str, dst_size: sizet, src: str):
# MLIR has no standalone type definition; struct types are inlined at the use site, so this # MLIR has no standalone type definition; struct types are inlined at the use site, so this
# writes an empty string. The same-name/same-signature API is kept to match llvmlite. # writes an empty string. The same-name/same-signature API is kept to match llvmlite.
def PrintStructDefinition(buf: str, size: sizet, def PrintStructDefinition(buf: str, size: sizet,
ty: rawptr[LLVMType], pool: memhub.MemBuddy*, ty: LLVMType*, pool: memhub.MemBuddy*,
packed: int = 0): packed: int = 0):
"""No type definition line on the MLIR side: write an empty string (API kept in sync).""" """No type definition line on the MLIR side: write an empty string (API kept in sync)."""
if buf is None or size == 0: if buf is None or size == 0:
@@ -1164,7 +1164,7 @@ def PrintStructDefinition(buf: str, size: sizet,
# get_struct_name - returns the named struct's Name (e.g. "sha1.ClassName"), or None for a # get_struct_name - returns the named struct's Name (e.g. "sha1.ClassName"), or None for a
# non-Struct / anonymous Struct; used by module_add_named_type to detect named structs and dedup. # non-Struct / anonymous Struct; used by module_add_named_type to detect named structs and dedup.
def get_struct_name(ty: rawptr[LLVMType]) -> str: def get_struct_name(ty: LLVMType*) -> str:
"""Return the named struct's name, or None if not a named struct.""" """Return the named struct's name, or None if not a named struct."""
if ty is None: if ty is None:
return None return None
@@ -1175,7 +1175,7 @@ def get_struct_name(ty: rawptr[LLVMType]) -> str:
return None return None
def get_struct_fields(ty: rawptr[LLVMType]) -> rawptr[ParamNode]: def get_struct_fields(ty: LLVMType*) -> ParamNode*:
"""Return the struct's field list (used to rebuild Struct types across modules).""" """Return the struct's field list (used to rebuild Struct types across modules)."""
if ty is None: if ty is None:
return None return None
@@ -1186,7 +1186,7 @@ def get_struct_fields(ty: rawptr[LLVMType]) -> rawptr[ParamNode]:
return None return None
def get_struct_fcount(ty: rawptr[LLVMType]) -> int: def get_struct_fcount(ty: LLVMType*) -> int:
"""Return the struct's field count (used to rebuild Struct types across modules).""" """Return the struct's field count (used to rebuild Struct types across modules)."""
if ty is None: if ty is None:
return 0 return 0
@@ -1204,13 +1204,13 @@ def get_struct_fcount(ty: rawptr[LLVMType]) -> int:
define DEEPCOPY_MAX_DEPTH = 64 define DEEPCOPY_MAX_DEPTH = 64
def DeepCopyType(pool: memhub.MemBuddy*, def DeepCopyType(pool: memhub.MemBuddy*,
ty: rawptr[LLVMType]) -> rawptr[LLVMType]: ty: LLVMType*) -> LLVMType*:
"""Deep-copy LLVMType to the permanent pool (depth-limited against self-recursion); None on failure.""" """Deep-copy LLVMType to the permanent pool (depth-limited against self-recursion); None on failure."""
return _DeepCopyDepth(pool, ty, 0) return _DeepCopyDepth(pool, ty, 0)
def _DeepCopyDepth(pool: memhub.MemBuddy*, def _DeepCopyDepth(pool: memhub.MemBuddy*,
ty: rawptr[LLVMType], depth: int) -> rawptr[LLVMType]: ty: LLVMType*, depth: int) -> LLVMType*:
"""Deep-copy implementation with a depth cap. """Deep-copy implementation with a depth cap.
The passed pool decides the lifetime: the main pool gives a transient copy (reclaimed by The passed pool decides the lifetime: the main pool gives a transient copy (reclaimed by
@@ -1219,7 +1219,7 @@ def _DeepCopyDepth(pool: memhub.MemBuddy*,
if ty is None: if ty is None:
return None return None
sz_dc: sizet = _TypeSizeGuard() sz_dc: sizet = _TypeSizeGuard()
new_ty: rawptr[LLVMType] = (rawptr[LLVMType])(pool.alloc(sz_dc)) new_ty: LLVMType* = (LLVMType*)(pool.alloc(sz_dc))
if new_ty is None: if new_ty is None:
return None return None
string.memset(new_ty, 0, sz_dc) string.memset(new_ty, 0, sz_dc)
@@ -1271,19 +1271,19 @@ def _DeepCopyDepth(pool: memhub.MemBuddy*,
def _DeepCopyParamChain(pool: memhub.MemBuddy*, def _DeepCopyParamChain(pool: memhub.MemBuddy*,
head: rawptr[ParamNode], depth: int) -> rawptr[ParamNode]: head: ParamNode*, depth: int) -> ParamNode*:
"""Deep-copy the ParamNode chain to the permanent pool.""" """Deep-copy the ParamNode chain to the permanent pool."""
if head is None: if head is None:
return None return None
first: rawptr[ParamNode] = None first: ParamNode* = None
prev: rawptr[ParamNode] = None prev: ParamNode* = None
cur: rawptr[ParamNode] = head cur: ParamNode* = head
guard: int = 0 guard: int = 0
while cur is not None: while cur is not None:
guard += 1 guard += 1
if guard > 512: if guard > 512:
break break
node: rawptr[ParamNode] = (rawptr[ParamNode])(pool.alloc(PNODE_SIZE)) node: ParamNode* = (ParamNode*)(pool.alloc(PNODE_SIZE))
if node is None: if node is None:
break break
string.memset(node, 0, PNODE_SIZE) string.memset(node, 0, PNODE_SIZE)
mlirlite/__values.vp
+27 -27
View File
@@ -19,7 +19,7 @@ from .__types import LLVMType, TypePrint
# ============================================================ # ============================================================
@t.NoVTable @t.NoVTable
class Value(GSListNode[Value]): class Value(GSListNode[Value]):
Ty: rawptr[LLVMType] # value type Ty: LLVMType* # value type
Name: str # SSA name ("%0"/"%result") or constant text ("42"/"1.5e+00") Name: str # SSA name ("%0"/"%result") or constant text ("42"/"1.5e+00")
IsConst: int # 1 = constant literal, 0 = SSA temporary IsConst: int # 1 = constant literal, 0 = SSA temporary
IntVal: int64 # integer constant value (used when IsConst=1) IntVal: int64 # integer constant value (used when IsConst=1)
@@ -32,20 +32,20 @@ class Value(GSListNode[Value]):
# Value hardcoded size: Next(8) + Ty(8) + Name(8) + IsConst(4) + IntVal(8) + FloatVal(8) = 48 bytes # Value hardcoded size: Next(8) + Ty(8) + Name(8) + IsConst(4) + IntVal(8) + FloatVal(8) = 48 bytes
define VALUE_SIZE = 48 define VALUE_SIZE = 48
def new_value(pool: memhub.MemBuddy*) -> rawptr[Value]: def new_value(pool: memhub.MemBuddy*) -> Value*:
"""Allocate a zero-initialized Value from mpool.""" """Allocate a zero-initialized Value from mpool."""
ptr: rawptr[Value] = pool.alloc(VALUE_SIZE) ptr: Value* = pool.alloc(VALUE_SIZE)
if ptr: if ptr:
string.memset(ptr, 0, VALUE_SIZE) string.memset(ptr, 0, VALUE_SIZE)
return ptr return ptr
def ConstInt(pool: memhub.MemBuddy*, ty: rawptr[LLVMType], def ConstInt(pool: memhub.MemBuddy*, ty: LLVMType*,
val: int64, name: str) -> rawptr[Value]: val: int64, name: str) -> Value*:
"""Create an integer constant value. """Create an integer constant value.
ty: integer type (Int1/Int8/Int32/Int64); val: integer value; name: caller-provided constant text (e.g. "42"). ty: integer type (Int1/Int8/Int32/Int64); val: integer value; name: caller-provided constant text (e.g. "42").
""" """
v: rawptr[Value] = new_value(pool) v: Value* = new_value(pool)
if v is None: return None if v is None: return None
v.Ty = ty v.Ty = ty
v.Name = name v.Name = name
@@ -54,10 +54,10 @@ def ConstInt(pool: memhub.MemBuddy*, ty: rawptr[LLVMType],
return v return v
def ConstNull(pool: memhub.MemBuddy*, ty: rawptr[LLVMType], def ConstNull(pool: memhub.MemBuddy*, ty: LLVMType*,
name: str) -> rawptr[Value]: name: str) -> Value*:
"""Create a null pointer constant.""" """Create a null pointer constant."""
v: rawptr[Value] = new_value(pool) v: Value* = new_value(pool)
if v is None: return None if v is None: return None
v.Ty = ty v.Ty = ty
v.Name = name v.Name = name
@@ -66,9 +66,9 @@ def ConstNull(pool: memhub.MemBuddy*, ty: rawptr[LLVMType],
return v return v
def ConstZero(pool: memhub.MemBuddy*, ty: rawptr[LLVMType]) -> rawptr[Value]: def ConstZero(pool: memhub.MemBuddy*, ty: LLVMType*) -> Value*:
"""Create a zeroinitializer constant (zero-initialized aggregate: struct/array).""" """Create a zeroinitializer constant (zero-initialized aggregate: struct/array)."""
v: rawptr[Value] = new_value(pool) v: Value* = new_value(pool)
if v is None: return None if v is None: return None
v.Ty = ty v.Ty = ty
v.Name = "zeroinitializer" v.Name = "zeroinitializer"
@@ -77,14 +77,14 @@ def ConstZero(pool: memhub.MemBuddy*, ty: rawptr[LLVMType]) -> rawptr[Value]:
return v return v
def ConstFloat(pool: memhub.MemBuddy*, ty: rawptr[LLVMType], def ConstFloat(pool: memhub.MemBuddy*, ty: LLVMType*,
val: double) -> rawptr[Value]: val: double) -> Value*:
"""Create a float constant value. """Create a float constant value.
ty: float type; val: float value. Name is the raw bit pattern (f16 0x%04x, f32 0x%08x, ty: float type; val: float value. Name is the raw bit pattern (f16 0x%04x, f32 0x%08x,
f64 0x%016llx, f128 0x%032x hi+lo) so MLIR FloatAttr is lossless; use CRT stdio.snprintf (%g in viperlib is buggy). f64 0x%016llx, f128 0x%032x hi+lo) so MLIR FloatAttr is lossless; use CRT stdio.snprintf (%g in viperlib is buggy).
""" """
v: rawptr[Value] = new_value(pool) v: Value* = new_value(pool)
if v is None: return None if v is None: return None
v.Ty = ty v.Ty = ty
v.IsConst = 1 v.IsConst = 1
@@ -113,11 +113,11 @@ def ConstFloat(pool: memhub.MemBuddy*, ty: rawptr[LLVMType],
# quad: double -> fp128 is lossless (fpext); little-endian low 64 first, print big-endian # quad: double -> fp128 is lossless (fpext); little-endian low 64 first, print big-endian
# (hi first). c.Load width follows the source pointee, so cast the source to u64* to avoid overflow. # (hi first). c.Load width follows the source pointee, so cast the source to u64* to avoid overflow.
q128: t.CFloat128T = t.CFloat128T(val) q128: t.CFloat128T = t.CFloat128T(val)
q8: rawptr[uint8] = (rawptr[uint8])(&q128) q8: uint8* = (uint8*)(&q128)
q_lo: uint64 = 0 q_lo: uint64 = 0
q_hi: uint64 = 0 q_hi: uint64 = 0
*&q_lo = *(rawptr[uint64])(q8) *&q_lo = *(uint64*)(q8)
*&q_hi = *(rawptr[uint64])(q8 + 8) *&q_hi = *(uint64*)(q8 + 8)
stdio.snprintf(name_buf, 64, "0x%016llx%016llx", q_hi, q_lo) stdio.snprintf(name_buf, 64, "0x%016llx%016llx", q_hi, q_lo)
else: else:
fv_bits: uint64 = 0 fv_bits: uint64 = 0
@@ -127,12 +127,12 @@ def ConstFloat(pool: memhub.MemBuddy*, ty: rawptr[LLVMType],
return v return v
def SSAValue(pool: memhub.MemBuddy*, ty: rawptr[LLVMType], def SSAValue(pool: memhub.MemBuddy*, ty: LLVMType*,
name: str) -> rawptr[Value]: name: str) -> Value*:
"""Create an SSA temporary value. """Create an SSA temporary value.
ty: value type; name: caller-provided SSA name (e.g. "%0"/"%result"). ty: value type; name: caller-provided SSA name (e.g. "%0"/"%result").
""" """
v: rawptr[Value] = new_value(pool) v: Value* = new_value(pool)
if v is None: return None if v is None: return None
v.Ty = ty v.Ty = ty
v.Name = name v.Name = name
@@ -149,7 +149,7 @@ def SSAValue(pool: memhub.MemBuddy*, ty: rawptr[LLVMType],
# must first be materialized as llvm.mlir.constant/zero/addressof ops). # must first be materialized as llvm.mlir.constant/zero/addressof ops).
# ============================================================ # ============================================================
def ValuePrint(buf: str, size: sizet, def ValuePrint(buf: str, size: sizet,
val: rawptr[Value], pool: memhub.MemBuddy*): val: Value*, pool: memhub.MemBuddy*):
"""Serialize val into buf as MLIR text; pool is used to allocate scratch buffers for """Serialize val into buf as MLIR text; pool is used to allocate scratch buffers for
recursive complex types (Array/Struct/Func). recursive complex types (Array/Struct/Func).
""" """
@@ -177,42 +177,42 @@ def ValuePrint(buf: str, size: sizet,
# Cross-module callers only see a stub Value (missing/wrong fields), so TransPyC silently skips # Cross-module callers only see a stub Value (missing/wrong fields), so TransPyC silently skips
# field access; these accessors run inside this module with the full type definition. # field access; these accessors run inside this module with the full type definition.
# ============================================================ # ============================================================
def value_get_ty(val: rawptr[Value]) -> rawptr[LLVMType]: def value_get_ty(val: Value*) -> LLVMType*:
"""Get the value's type.""" """Get the value's type."""
if val is None: if val is None:
return None return None
return val.Ty return val.Ty
def value_get_next(val: rawptr[Value]) -> rawptr[Value]: def value_get_next(val: Value*) -> Value*:
"""Get the next value in the list.""" """Get the next value in the list."""
if val is None: if val is None:
return None return None
return val.Next return val.Next
def value_set_ty(val: rawptr[Value], ty: rawptr[LLVMType]): def value_set_ty(val: Value*, ty: LLVMType*):
"""Set the value's type.""" """Set the value's type."""
if val is None: if val is None:
return return
val.Ty = ty val.Ty = ty
def value_set_next(val: rawptr[Value], nxt: rawptr[Value]): def value_set_next(val: Value*, nxt: Value*):
"""Set the next value in the list.""" """Set the next value in the list."""
if val is None: if val is None:
return return
val.Next = nxt val.Next = nxt
def value_set_name(val: rawptr[Value], name: str): def value_set_name(val: Value*, name: str):
"""Set the value's name.""" """Set the value's name."""
if val is None: if val is None:
return return
val.Name = name val.Name = name
def value_set_isconst(val: rawptr[Value], is_const: int): def value_set_isconst(val: Value*, is_const: int):
"""Set whether the value is a constant.""" """Set whether the value is a constant."""
if val is None: if val is None:
return return
mlirlite/__verify.vp
+27 -27
View File
@@ -55,9 +55,9 @@ class VerifyResult:
# Helper functions # Helper functions
# ============================================================ # ============================================================
def _new_verify_result(pool: memhub.MemBuddy*, def _new_verify_result(pool: memhub.MemBuddy*,
buf_size: sizet) -> rawptr[VerifyResult]: buf_size: sizet) -> VerifyResult*:
"""Create a VerifyResult object""" """Create a VerifyResult object"""
ptr: rawptr[VerifyResult] = pool.alloc(VerifyResult.__sizeof__()) ptr: VerifyResult* = pool.alloc(VerifyResult.__sizeof__())
if ptr is None: return None if ptr is None: return None
string.memset(ptr, 0, VerifyResult.__sizeof__()) string.memset(ptr, 0, VerifyResult.__sizeof__())
ptr.ErrorCount = 0 ptr.ErrorCount = 0
@@ -71,7 +71,7 @@ def _new_verify_result(pool: memhub.MemBuddy*,
return ptr return ptr
def _report_error(result: rawptr[VerifyResult], code: int, msg: str): def _report_error(result: VerifyResult*, code: int, msg: str):
"""Record one error""" """Record one error"""
if result is None: return if result is None: return
result.ErrorCount += 1 result.ErrorCount += 1
@@ -125,9 +125,9 @@ def _append_cstr(dst: str, dst_size: sizet, src: str):
# ============================================================ # ============================================================
# SSA name-table operations # SSA name-table operations
# ============================================================ # ============================================================
def _new_name_table(pool: memhub.MemBuddy*) -> rawptr[GSList[NameEntry]]: def _new_name_table(pool: memhub.MemBuddy*) -> GSList[NameEntry]*:
"""Create an empty name table""" """Create an empty name table"""
gsl: rawptr[GSList[NameEntry]] = pool.alloc(24) # GSList: Head+Tail+Count gsl: GSList[NameEntry]* = pool.alloc(24) # GSList: Head+Tail+Count
if gsl is None: return None if gsl is None: return None
string.memset(gsl, 0, 24) string.memset(gsl, 0, 24)
return gsl return gsl
@@ -136,19 +136,19 @@ def _new_name_table(pool: memhub.MemBuddy*) -> rawptr[GSList[NameEntry]]:
# NameEntry hardcoded size: Next(8) + Name(8) = 16 bytes # NameEntry hardcoded size: Next(8) + Name(8) = 16 bytes
define NENTRY_SIZE = 16 define NENTRY_SIZE = 16
def _name_table_add(table: rawptr[GSList[NameEntry]], def _name_table_add(table: GSList[NameEntry]*,
pool: memhub.MemBuddy*, pool: memhub.MemBuddy*,
name: str) -> int: name: str) -> int:
"""Add a name to the table. Returns 1=duplicate, 0=added""" """Add a name to the table. Returns 1=duplicate, 0=added"""
if table is None or name is None: return 0 if table is None or name is None: return 0
# Check for duplicates # Check for duplicates
cur: rawptr[NameEntry] = table.Head cur: NameEntry* = table.Head
while cur is not None: while cur is not None:
if string.strcmp(cur.Name, name) == 0: if string.strcmp(cur.Name, name) == 0:
return 1 return 1
cur = cur.Next cur = cur.Next
# Add new entry # Add new entry
entry: rawptr[NameEntry] = pool.alloc(NENTRY_SIZE) entry: NameEntry* = pool.alloc(NENTRY_SIZE)
if entry is None: return 0 if entry is None: return 0
string.memset(entry, 0, NENTRY_SIZE) string.memset(entry, 0, NENTRY_SIZE)
entry.Name = name entry.Name = name
@@ -156,11 +156,11 @@ def _name_table_add(table: rawptr[GSList[NameEntry]],
return 0 return 0
def _name_table_contains(table: rawptr[GSList[NameEntry]], def _name_table_contains(table: GSList[NameEntry]*,
name: str) -> int: name: str) -> int:
"""Return 1 if name is in the table, else 0""" """Return 1 if name is in the table, else 0"""
if table is None or name is None: return 0 if table is None or name is None: return 0
cur: rawptr[NameEntry] = table.Head cur: NameEntry* = table.Head
while cur is not None: while cur is not None:
if string.strcmp(cur.Name, name) == 0: if string.strcmp(cur.Name, name) == 0:
return 1 return 1
@@ -222,7 +222,7 @@ def _is_phi(text: str) -> int:
return 0 return 0
def _check_uses_in_line(table: rawptr[GSList[NameEntry]], def _check_uses_in_line(table: GSList[NameEntry]*,
text: str, text: str,
def_name: str) -> int: def_name: str) -> int:
"""Check that all SSA name uses in the line are defined. """Check that all SSA name uses in the line are defined.
@@ -254,10 +254,10 @@ def _check_uses_in_line(table: rawptr[GSList[NameEntry]],
def _name_matches_at(text: str, start: int, length: int, def _name_matches_at(text: str, start: int, length: int,
table: rawptr[GSList[NameEntry]]) -> int: table: GSList[NameEntry]*) -> int:
"""Return 1 if text[start:start+length] matches an entry in the name table, else 0.""" """Return 1 if text[start:start+length] matches an entry in the name table, else 0."""
if table is None: return 0 if table is None: return 0
cur: rawptr[NameEntry] = table.Head cur: NameEntry* = table.Head
while cur is not None: while cur is not None:
if cur.Name is not None: if cur.Name is not None:
if _str_matches_at(text, start, length, cur.Name) == 1: if _str_matches_at(text, start, length, cur.Name) == 1:
@@ -282,20 +282,20 @@ def _str_matches_at(text: str, start: int, length: int,
# Main verification functions # Main verification functions
# ============================================================ # ============================================================
def verify_function(pool: memhub.MemBuddy*, def verify_function(pool: memhub.MemBuddy*,
func: rawptr[Function], func: Function*,
result: rawptr[VerifyResult]) -> int: result: VerifyResult*) -> int:
"""Verify a function's SSA correctness; result must be created via """Verify a function's SSA correctness; result must be created via
_new_verify_result. Returns the error count (0 = pass). _new_verify_result. Returns the error count (0 = pass).
""" """
if func is None or result is None: return 1 if func is None or result is None: return 1
# Create name table # Create name table
name_table: rawptr[GSList[NameEntry]] = _new_name_table(pool) name_table: GSList[NameEntry]* = _new_name_table(pool)
if name_table is None: return 1 if name_table is None: return 1
# 1. Add function params to the name table (params are defined) # 1. Add function params to the name table (params are defined)
params: rawptr[GSList[Param]] = func.Params params: GSList[Param]* = func.Params
param: rawptr[Param] = None param: Param* = None
if params is not None: if params is not None:
param = params.Head param = params.Head
while param is not None: while param is not None:
@@ -304,8 +304,8 @@ def verify_function(pool: memhub.MemBuddy*,
param = param.Next param = param.Next
# 1b. Add block names to the table (block labels like %then are valid br/phi targets) # 1b. Add block names to the table (block labels like %then are valid br/phi targets)
blocks: rawptr[GSList[BasicBlock]] = func.Blocks blocks: GSList[BasicBlock]* = func.Blocks
blk_iter: rawptr[BasicBlock] = None blk_iter: BasicBlock* = None
if blocks is not None: if blocks is not None:
blk_iter = blocks.Head blk_iter = blocks.Head
while blk_iter is not None: while blk_iter is not None:
@@ -322,7 +322,7 @@ def verify_function(pool: memhub.MemBuddy*,
blk_iter = blk_iter.Next blk_iter = blk_iter.Next
# 2. Walk all blocks # 2. Walk all blocks
blk: rawptr[BasicBlock] = None blk: BasicBlock* = None
if blocks is not None: if blocks is not None:
blk = blocks.Head blk = blocks.Head
while blk is not None: while blk is not None:
@@ -330,9 +330,9 @@ def verify_function(pool: memhub.MemBuddy*,
if blk.IsTerminated == 0: if blk.IsTerminated == 0:
# Also check whether the last line is a terminator # Also check whether the last line is a terminator
has_term: int = 0 has_term: int = 0
line_check: rawptr[Line] = None line_check: Line* = None
if blk.Lines is not None: if blk.Lines is not None:
lines_check: rawptr[GSList[Line]] = blk.Lines lines_check: GSList[Line]* = blk.Lines
line_check = lines_check.Head line_check = lines_check.Head
while line_check is not None: while line_check is not None:
if line_check.Buf is not None: if line_check.Buf is not None:
@@ -350,9 +350,9 @@ def verify_function(pool: memhub.MemBuddy*,
# Walk instruction lines in the block # Walk instruction lines in the block
seen_non_phi: int = 0 seen_non_phi: int = 0
line: rawptr[Line] = None line: Line* = None
if blk.Lines is not None: if blk.Lines is not None:
lines: rawptr[GSList[Line]] = blk.Lines lines: GSList[Line]* = blk.Lines
line = lines.Head line = lines.Head
while line is not None: while line is not None:
if line.Buf is not None: if line.Buf is not None:
@@ -396,12 +396,12 @@ def verify_function(pool: memhub.MemBuddy*,
return result.ErrorCount return result.ErrorCount
def verify_module(pool: memhub.MemBuddy*, mod: rawptr[LLVMModule], result: rawptr[VerifyResult]) -> int: def verify_module(pool: memhub.MemBuddy*, mod: LLVMModule*, result: VerifyResult*) -> int:
"""Verify SSA correctness of all functions in the module. """Verify SSA correctness of all functions in the module.
Returns the total error count. Returns the total error count.
""" """
if mod is None or result is None: return 1 if mod is None or result is None: return 1
func: rawptr[Function] = mod.FuncHead func: Function* = mod.FuncHead
while func is not None: while func is not None:
if func.IsDeclared == 0: if func.IsDeclared == 0:
# Verify only definitions with a body; skip declarations # Verify only definitions with a body; skip declarations
numpy/__init__.vp
+18 -18
View File
@@ -34,9 +34,9 @@ class ndarray[T]:
ndim: int ndim: int
size: sizet size: sizet
owns_data: int owns_data: int
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
def __new__(self, pool: rawptr[memhub.MemManager], n: sizet): def __new__(self, pool: memhub.MemManager*, n: sizet):
self.pool = pool self.pool = pool
self.data = pool.alloc(n * T.__sizeof__()) self.data = pool.alloc(n * T.__sizeof__())
if self.data: if self.data:
@@ -261,7 +261,7 @@ Uint8Array: t.CTypedef = ndarray[uchar]
# Internal helpers (specialized for float64 by default) # Internal helpers (specialized for float64 by default)
# Use _alloc_ndarray_t[T] / _empty_like_t[T] for other types # Use _alloc_ndarray_t[T] / _empty_like_t[T] for other types
# ============================================================ # ============================================================
def _alloc_ndarray(pool: rawptr[memhub.MemManager]) -> ndarray[double]*: def _alloc_ndarray(pool: memhub.MemManager*) -> ndarray[double]*:
a: ndarray[double]* = pool.alloc(ndarray[double].__sizeof__()) a: ndarray[double]* = pool.alloc(ndarray[double].__sizeof__())
if a: if a:
string.memset(a, 0, ndarray[double].__sizeof__()) string.memset(a, 0, ndarray[double].__sizeof__())
@@ -296,7 +296,7 @@ def _empty_like(a: ndarray[double]*) -> ndarray[double]*:
# ============================================================ # ============================================================
# Array creation functions (float64 default) # Array creation functions (float64 default)
# ============================================================ # ============================================================
def array(pool: rawptr[memhub.MemManager], data: double*, n: sizet) -> ndarray[double]*: def array(pool: memhub.MemManager*, data: double*, n: sizet) -> ndarray[double]*:
a: ndarray[double]* = _alloc_ndarray(pool) a: ndarray[double]* = _alloc_ndarray(pool)
if not a: return None if not a: return None
a.data = pool.alloc(n * double.__sizeof__()) a.data = pool.alloc(n * double.__sizeof__())
@@ -312,7 +312,7 @@ def array(pool: rawptr[memhub.MemManager], data: double*, n: sizet) -> ndarray[d
a.owns_data = 1 a.owns_data = 1
return a return a
def zeros(pool: rawptr[memhub.MemManager], n: sizet) -> ndarray[double]*: def zeros(pool: memhub.MemManager*, n: sizet) -> ndarray[double]*:
a: ndarray[double]* = _alloc_ndarray(pool) a: ndarray[double]* = _alloc_ndarray(pool)
if not a: return None if not a: return None
a.data = pool.alloc(n * double.__sizeof__()) a.data = pool.alloc(n * double.__sizeof__())
@@ -328,19 +328,19 @@ def zeros(pool: rawptr[memhub.MemManager], n: sizet) -> ndarray[double]*:
a.owns_data = 1 a.owns_data = 1
return a return a
def ones(pool: rawptr[memhub.MemManager], n: sizet) -> ndarray[double]*: def ones(pool: memhub.MemManager*, n: sizet) -> ndarray[double]*:
a: ndarray[double]* = zeros(pool, n) a: ndarray[double]* = zeros(pool, n)
if not a: return None if not a: return None
a.fill(double(1.0)) a.fill(double(1.0))
return a return a
def full(pool: rawptr[memhub.MemManager], n: sizet, val: double) -> ndarray[double]*: def full(pool: memhub.MemManager*, n: sizet, val: double) -> ndarray[double]*:
a: ndarray[double]* = zeros(pool, n) a: ndarray[double]* = zeros(pool, n)
if not a: return None if not a: return None
a.fill(val) a.fill(val)
return a return a
def arange(pool: rawptr[memhub.MemManager], start: double, stop: double, step: double) -> ndarray[double]*: def arange(pool: memhub.MemManager*, start: double, stop: double, step: double) -> ndarray[double]*:
if step == double(0.0): return None if step == double(0.0): return None
n: sizet = 0 n: sizet = 0
if step > double(0.0): if step > double(0.0):
@@ -362,7 +362,7 @@ def arange(pool: rawptr[memhub.MemManager], start: double, stop: double, step: d
v += step v += step
return a return a
def linspace(pool: rawptr[memhub.MemManager], start: double, stop: double, num: sizet) -> ndarray[double]*: def linspace(pool: memhub.MemManager*, start: double, stop: double, num: sizet) -> ndarray[double]*:
if num == 0: return None if num == 0: return None
a: ndarray[double]* = zeros(pool, num) a: ndarray[double]* = zeros(pool, num)
if not a: return None if not a: return None
@@ -374,7 +374,7 @@ def linspace(pool: rawptr[memhub.MemManager], start: double, stop: double, num:
a.data[i] = start + double(i) * step a.data[i] = start + double(i) * step
return a return a
def empty2d(pool: rawptr[memhub.MemManager], rows: sizet, cols: sizet) -> ndarray[double]*: def empty2d(pool: memhub.MemManager*, rows: sizet, cols: sizet) -> ndarray[double]*:
a: ndarray[double]* = _alloc_ndarray(pool) a: ndarray[double]* = _alloc_ndarray(pool)
if not a: return None if not a: return None
total: sizet = rows * cols total: sizet = rows * cols
@@ -392,23 +392,23 @@ def empty2d(pool: rawptr[memhub.MemManager], rows: sizet, cols: sizet) -> ndarra
_compute_strides(a) _compute_strides(a)
return a return a
def zeros2d(pool: rawptr[memhub.MemManager], rows: sizet, cols: sizet) -> ndarray[double]*: def zeros2d(pool: memhub.MemManager*, rows: sizet, cols: sizet) -> ndarray[double]*:
return empty2d(pool, rows, cols) return empty2d(pool, rows, cols)
def ones2d(pool: rawptr[memhub.MemManager], rows: sizet, cols: sizet) -> ndarray[double]*: def ones2d(pool: memhub.MemManager*, rows: sizet, cols: sizet) -> ndarray[double]*:
a: ndarray[double]* = empty2d(pool, rows, cols) a: ndarray[double]* = empty2d(pool, rows, cols)
if not a: return None if not a: return None
a.fill(double(1.0)) a.fill(double(1.0))
return a return a
def eye(pool: rawptr[memhub.MemManager], n: sizet) -> ndarray[double]*: def eye(pool: memhub.MemManager*, n: sizet) -> ndarray[double]*:
a: ndarray[double]* = empty2d(pool, n, n) a: ndarray[double]* = empty2d(pool, n, n)
if not a: return None if not a: return None
for i in range(n): for i in range(n):
a.data[i * n + i] = double(1.0) a.data[i * n + i] = double(1.0)
return a return a
def diag(pool: rawptr[memhub.MemManager], vals: ndarray[double]*) -> ndarray[double]*: def diag(pool: memhub.MemManager*, vals: ndarray[double]*) -> ndarray[double]*:
n: sizet = vals.size n: sizet = vals.size
a: ndarray[double]* = empty2d(pool, n, n) a: ndarray[double]* = empty2d(pool, n, n)
if not a: return None if not a: return None
@@ -887,10 +887,10 @@ def np_greater_equal(a: ndarray[double]*, b: ndarray[double]*) -> ndarray[double
# ============================================================ # ============================================================
# Additional creation functions (float64 default) # Additional creation functions (float64 default)
# ============================================================ # ============================================================
def empty(pool: rawptr[memhub.MemManager], n: sizet) -> ndarray[double]*: def empty(pool: memhub.MemManager*, n: sizet) -> ndarray[double]*:
return zeros(pool, n) return zeros(pool, n)
def full2d(pool: rawptr[memhub.MemManager], rows: sizet, cols: sizet, val: double) -> ndarray[double]*: def full2d(pool: memhub.MemManager*, rows: sizet, cols: sizet, val: double) -> ndarray[double]*:
a: ndarray[double]* = empty2d(pool, rows, cols) a: ndarray[double]* = empty2d(pool, rows, cols)
if not a: return None if not a: return None
a.fill(val) a.fill(val)
@@ -920,10 +920,10 @@ def ones_like(a: ndarray[double]*) -> ndarray[double]*:
result.fill(double(1.0)) result.fill(double(1.0))
return result return result
def arange1(pool: rawptr[memhub.MemManager], stop: double) -> ndarray[double]*: def arange1(pool: memhub.MemManager*, stop: double) -> ndarray[double]*:
return arange(pool, double(0.0), stop, double(1.0)) return arange(pool, double(0.0), stop, double(1.0))
def linspace2(pool: rawptr[memhub.MemManager], start: double, stop: double) -> ndarray[double]*: def linspace2(pool: memhub.MemManager*, start: double, stop: double) -> ndarray[double]*:
return linspace(pool, start, stop, 50) return linspace(pool, start, stop, 50)
def meshgrid(x: ndarray[double]*, y: ndarray[double]*) -> ndarray[double]*: def meshgrid(x: ndarray[double]*, y: ndarray[double]*) -> ndarray[double]*:
os/_posix.vp
+2 -2
View File
@@ -16,7 +16,7 @@ _mbuddy: memhub.MemBuddy*
# File/Directory Attribute Query # File/Directory Attribute Query
# ============================================================================= # =============================================================================
def _stat(path: str) -> rawptr[posix.Stat]: def _stat(path: str) -> posix.Stat*:
"""Call stat and return a Stat struct pointer. Return None on failure. """Call stat and return a Stat struct pointer. Return None on failure.
Note: the Stat struct is allocated via _mbuddy; the caller must free it.""" Note: the Stat struct is allocated via _mbuddy; the caller must free it."""
st: posix.Stat = posix.Stat() st: posix.Stat = posix.Stat()
@@ -146,7 +146,7 @@ def listdir(path: str, out_names: str*, max_count: ULONG) -> ULONG:
count: ULONG = 0 count: ULONG = 0
while count < max_count: while count < max_count:
entry: rawptr[posix.Dirent] = posix.readdir(dirp) entry: posix.Dirent* = posix.readdir(dirp)
if entry == None: if entry == None:
break break
posix.vp
+16 -16
View File
@@ -162,42 +162,42 @@ class Dirent():
# ============================================================================= # =============================================================================
# File operations (10) # File operations (10)
# ============================================================================= # =============================================================================
extern def open(path: t.CConst | str, oflag: INT, *args) -> INT extern def open(path: const str, oflag: INT, *args) -> INT
extern def close(fd: INT) -> INT extern def close(fd: INT) -> INT
extern def read(fd: INT, buf: bytes, count: sizet) -> ssize_t extern def read(fd: INT, buf: bytes, count: sizet) -> ssize_t
extern def write(fd: INT, buf: t.CConst | bytes, count: sizet) -> ssize_t extern def write(fd: INT, buf: const bytes, count: sizet) -> ssize_t
extern def lseek(fd: INT, offset: off_t, whence: INT) -> off_t extern def lseek(fd: INT, offset: off_t, whence: INT) -> off_t
extern def unlink(path: t.CConst | str) -> INT extern def unlink(path: const str) -> INT
extern def access(path: t.CConst | str, amode: INT) -> INT extern def access(path: const str, amode: INT) -> INT
extern def realpath(path: t.CConst | str, resolved: CHARPTR) -> CHARPTR extern def realpath(path: const str, resolved: CHARPTR) -> CHARPTR
extern def rename(oldpath: t.CConst | str, newpath: t.CConst | str) -> INT extern def rename(oldpath: const str, newpath: const str) -> INT
extern def chmod(path: t.CConst | str, mode: mode_t) -> INT extern def chmod(path: const str, mode: mode_t) -> INT
# ============================================================================= # =============================================================================
# stat series (2) # stat series (2)
# ============================================================================= # =============================================================================
extern def stat(path: t.CConst | str, buf: Stat*) -> INT extern def stat(path: const str, buf: Stat*) -> INT
extern def fstat(fd: INT, buf: Stat*) -> INT extern def fstat(fd: INT, buf: Stat*) -> INT
# ============================================================================= # =============================================================================
# Directory operations (6) # Directory operations (6)
# ============================================================================= # =============================================================================
extern def opendir(name: t.CConst | str) -> DIR extern def opendir(name: const str) -> DIR
extern def readdir(dirp: DIR) -> Dirent* extern def readdir(dirp: DIR) -> Dirent*
extern def closedir(dirp: DIR) -> INT extern def closedir(dirp: DIR) -> INT
extern def mkdir(path: t.CConst | str, mode: mode_t) -> INT extern def mkdir(path: const str, mode: mode_t) -> INT
extern def rmdir(path: t.CConst | str) -> INT extern def rmdir(path: const str) -> INT
extern def getcwd(buf: CHARPTR, size: sizet) -> CHARPTR extern def getcwd(buf: CHARPTR, size: sizet) -> CHARPTR
extern def chdir(path: t.CConst | str) -> INT extern def chdir(path: const str) -> INT
# ============================================================================= # =============================================================================
# Process operations (8) # Process operations (8)
# ============================================================================= # =============================================================================
extern def fork() -> pid_t extern def fork() -> pid_t
extern def execvp(file: t.CConst | str, argv: CHARPTR*) -> INT extern def execvp(file: const str, argv: CHARPTR*) -> INT
extern def execv(path: t.CConst | str, argv: CHARPTR*) -> INT extern def execv(path: const str, argv: CHARPTR*) -> INT
extern def waitpid(pid: pid_t, status: INT*, options: INT) -> pid_t extern def waitpid(pid: pid_t, status: INT*, options: INT) -> pid_t
extern def pipe(fds: INT*) -> INT extern def pipe(fds: INT*) -> INT
extern def dup2(oldfd: INT, newfd: INT) -> INT extern def dup2(oldfd: INT, newfd: INT) -> INT
@@ -208,8 +208,8 @@ extern def getpid() -> pid_t
# ============================================================================= # =============================================================================
# Environment operations (4) # Environment operations (4)
# ============================================================================= # =============================================================================
extern def getenv(name: t.CConst | str) -> CHARPTR extern def getenv(name: const str) -> CHARPTR
extern def setenv(name: t.CConst | str, value: t.CConst | str, overwrite: INT) -> INT extern def setenv(name: const str, value: const str, overwrite: INT) -> INT
extern def sysconf(name: INT) -> LONG extern def sysconf(name: INT) -> LONG
extern def isatty(fd: INT) -> INT extern def isatty(fd: INT) -> INT
random.vp
+6 -6
View File
@@ -63,7 +63,7 @@ def rdseed64() -> uint64:
# Step version (with success flag, matching GCC builtin interface) # Step version (with success flag, matching GCC builtin interface)
# Returns success flag: 1 on success, 0 on failure; random value written to *p # Returns success flag: 1 on success, 0 on failure; random value written to *p
# ============================================================ # ============================================================
def rdrand16_step(p: rawptr[uint16]) -> int: def rdrand16_step(p: uint16*) -> int:
val: uint32 = 0 val: uint32 = 0
ok: uint32 = 0 ok: uint32 = 0
c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)} c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
@@ -74,7 +74,7 @@ def rdrand16_step(p: rawptr[uint16]) -> int:
p[0] = uint16(val) p[0] = uint16(val)
return int(ok) return int(ok)
def rdrand32_step(p: rawptr[uint32]) -> int: def rdrand32_step(p: uint32*) -> int:
val: uint32 = 0 val: uint32 = 0
ok: uint32 = 0 ok: uint32 = 0
c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)} c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
@@ -85,7 +85,7 @@ def rdrand32_step(p: rawptr[uint32]) -> int:
p[0] = val p[0] = val
return int(ok) return int(ok)
def rdrand64_step(p: rawptr[uint64]) -> int: def rdrand64_step(p: uint64*) -> int:
val: uint64 = 0 val: uint64 = 0
ok: uint32 = 0 ok: uint32 = 0
c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)} c.Asm(f"""rdrand {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
@@ -96,7 +96,7 @@ def rdrand64_step(p: rawptr[uint64]) -> int:
p[0] = val p[0] = val
return int(ok) return int(ok)
def rdseed16_step(p: rawptr[uint16]) -> int: def rdseed16_step(p: uint16*) -> int:
val: uint32 = 0 val: uint32 = 0
ok: uint32 = 0 ok: uint32 = 0
c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)} c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
@@ -107,7 +107,7 @@ def rdseed16_step(p: rawptr[uint16]) -> int:
p[0] = uint16(val) p[0] = uint16(val)
return int(ok) return int(ok)
def rdseed32_step(p: rawptr[uint32]) -> int: def rdseed32_step(p: uint32*) -> int:
val: uint32 = 0 val: uint32 = 0
ok: uint32 = 0 ok: uint32 = 0
c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)} c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
@@ -118,7 +118,7 @@ def rdseed32_step(p: rawptr[uint32]) -> int:
p[0] = val p[0] = val
return int(ok) return int(ok)
def rdseed64_step(p: rawptr[uint64]) -> int: def rdseed64_step(p: uint64*) -> int:
val: uint64 = 0 val: uint64 = 0
ok: uint32 = 0 ok: uint32 = 0
c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)} c.Asm(f"""rdseed {c.AsmOut(val, t.ASM_DESCR.OUTPUT_REG)}
requests/download.vp
+1 -1
View File
@@ -374,7 +374,7 @@ def download(url: str, path: str, threads: INT = 1,
job.status = 0 job.status = 0
ctxs[i] = t.CPtr(uint64(job)) ctxs[i] = t.CPtr(uint64(job))
th: rawptr[vt.Thread] = vt.Thread(_dl_worker, ctxs[i]) th: vt.Thread* = vt.Thread(_dl_worker, ctxs[i])
if th is None: if th is None:
stdlib.free(job.buf) stdlib.free(job.buf)
stdlib.free(job.path) stdlib.free(job.path)
requests/https.vp
+14 -14
View File
@@ -219,7 +219,7 @@ def _TlsErrText():
# Core request # Core request
# ============================================================ # ============================================================
def _HttpsRequest(method: str, url: str, verify: bool, ca_file: str, data: str, content_type: str, auth: str = None) -> rawptr[requests.Response]: def _HttpsRequest(method: str, url: str, verify: bool, ca_file: str, data: str, content_type: str, auth: str = None) -> requests.Response*:
"""HTTPS GET/POST core. verify=False skips cert chain/hostname checks (not recommended); """HTTPS GET/POST core. verify=False skips cert chain/hostname checks (not recommended);
verify=True uses ca_file PEM bundle (else system default); auth adds Authorization header on POST only. verify=True uses ca_file PEM bundle (else system default); auth adds Authorization header on POST only.
""" """
@@ -228,7 +228,7 @@ def _HttpsRequest(method: str, url: str, verify: bool, ca_file: str, data: str,
_last_verify_flag = 1 if verify else 0 _last_verify_flag = 1 if verify else 0
resp: rawptr[requests.Response] = requests.create_response() resp: requests.Response* = requests.create_response()
if resp is None: return None if resp is None: return None
if _EnsureReady() != 0: if _EnsureReady() != 0:
@@ -478,7 +478,7 @@ def _HttpsRequest(method: str, url: str, verify: bool, ca_file: str, data: str,
# Public API # Public API
# ============================================================ # ============================================================
def _HttpsRedirectLoop(method: str, url: str, verify: bool, ca_file: str, data: str, content_type: str, auth: str = None) -> rawptr[requests.Response]: def _HttpsRedirectLoop(method: str, url: str, verify: bool, ca_file: str, data: str, content_type: str, auth: str = None) -> requests.Response*:
"""HTTPS GET/POST with redirect following (cross http/https, max 5 hops). """HTTPS GET/POST with redirect following (cross http/https, max 5 hops).
auth is passed through to _HttpsRequest; note Authorization also follows cross-host redirects. auth is passed through to _HttpsRequest; note Authorization also follows cross-host redirects.
""" """
@@ -493,7 +493,7 @@ def _HttpsRedirectLoop(method: str, url: str, verify: bool, ca_file: str, data:
string.strcpy(cur, url) string.strcpy(cur, url)
for hop in range(5): for hop in range(5):
resp: rawptr[requests.Response] = _HttpsRequest(method, cur, verify, ca_file, data, content_type, auth) resp: requests.Response* = _HttpsRequest(method, cur, verify, ca_file, data, content_type, auth)
if resp is None: if resp is None:
requests._mbuddy.free(cur) requests._mbuddy.free(cur)
return None return None
@@ -530,7 +530,7 @@ def _HttpsRedirectLoop(method: str, url: str, verify: bool, ca_file: str, data:
if string.strncmp(nxt, "https://", 8) != 0: if string.strncmp(nxt, "https://", 8) != 0:
requests._mbuddy.free(loc) requests._mbuddy.free(loc)
requests._mbuddy.free(cur) requests._mbuddy.free(cur)
http_resp: rawptr[requests.Response] = requests.get(nxt) http_resp: requests.Response* = requests.get(nxt)
requests._mbuddy.free(nxt) requests._mbuddy.free(nxt)
return http_resp return http_resp
@@ -543,7 +543,7 @@ def _HttpsRedirectLoop(method: str, url: str, verify: bool, ca_file: str, data:
return None return None
def get(url: str, verify: bool = True, ca_file: str = None) -> rawptr[requests.Response]: def get(url: str, verify: bool = True, ca_file: str = None) -> requests.Response*:
"""HTTPS GET (follows 3xx redirects, max 5 hops). verify checks cert chain + hostname; """HTTPS GET (follows 3xx redirects, max 5 hops). verify checks cert chain + hostname;
ca_file is a PEM CA bundle path, None uses system default. Returns Response* or None. ca_file is a PEM CA bundle path, None uses system default. Returns Response* or None.
""" """
@@ -551,7 +551,7 @@ def get(url: str, verify: bool = True, ca_file: str = None) -> rawptr[requests.R
def post(url: str, data: str = None, content_type: str = "application/x-www-form-urlencoded", def post(url: str, data: str = None, content_type: str = "application/x-www-form-urlencoded",
verify: bool = True, ca_file: str = None, auth: str = None) -> rawptr[requests.Response]: verify: bool = True, ca_file: str = None, auth: str = None) -> requests.Response*:
"""HTTPS POST (follows 3xx redirects, max 5 hops). verify checks cert chain + hostname; """HTTPS POST (follows 3xx redirects, max 5 hops). verify checks cert chain + hostname;
ca_file PEM CA bundle (None = system default); auth optional "Bearer <key>", sent when non-empty. ca_file PEM CA bundle (None = system default); auth optional "Bearer <key>", sent when non-empty.
""" """
@@ -563,20 +563,20 @@ def post(url: str, data: str = None, content_type: str = "application/x-www-form
# choices[0].delta.content from data:{json} lines into _st_buf; blocking, returns HTTP status or -1/-2. # choices[0].delta.content from data:{json} lines into _st_buf; blocking, returns HTTP status or -1/-2.
# ============================================================ # ============================================================
def _SseDeltaContent(root: rawptr[json.JsonValue]) -> str: def _SseDeltaContent(root: json.JsonValue*) -> str:
"""Extract choices[0].delta.content from a stream data event; None if absent.""" """Extract choices[0].delta.content from a stream data event; None if absent."""
if root is None or not root.is_object(): if root is None or not root.is_object():
return None return None
cv: rawptr[json.JsonValue] = root["choices"] cv: json.JsonValue* = root["choices"]
if cv is None or not cv.is_array(): if cv is None or not cv.is_array():
return None return None
m0: rawptr[json.JsonValue] = cv.get_item(0) m0: json.JsonValue* = cv.get_item(0)
if m0 is None or not m0.is_object(): if m0 is None or not m0.is_object():
return None return None
dv: rawptr[json.JsonValue] = m0["delta"] dv: json.JsonValue* = m0["delta"]
if dv is None or not dv.is_object(): if dv is None or not dv.is_object():
return None return None
content_v: rawptr[json.JsonValue] = dv["content"] content_v: json.JsonValue* = dv["content"]
if content_v is None or not content_v.is_string(): if content_v is None or not content_v.is_string():
return None return None
return content_v.as_string() return content_v.as_string()
@@ -782,7 +782,7 @@ def post_stream(url: str, data: str, content_type: str = "application/json",
sock.close() sock.close()
requests._mbuddy.free(errmsg) requests._mbuddy.free(errmsg)
return -1 return -1
jpool: rawptr[memhub.MemPool] = memhub.MemPool(pmem, 524288) jpool: memhub.MemPool* = memhub.MemPool(pmem, 524288)
leftover: t.CArray[char, 16384] leftover: t.CArray[char, 16384]
llen: INT = 0 llen: INT = 0
@@ -840,7 +840,7 @@ def post_stream(url: str, data: str, content_type: str = "application/json",
if pl[0] != 0: if pl[0] != 0:
if string.strncmp(pl, "[DONE]", 6) != 0 or pl[6] != 0: if string.strncmp(pl, "[DONE]", 6) != 0 or pl[6] != 0:
jpool.reset() jpool.reset()
ev: rawptr[json.JsonValue] = json.parse(jpool, pl) ev: json.JsonValue* = json.parse(jpool, pl)
dtx: str = _SseDeltaContent(ev) dtx: str = _SseDeltaContent(ev)
if dtx is not None: if dtx is not None:
_StreamAppendContent(dtx) _StreamAppendContent(dtx)
shutil.vp
+1 -1
View File
@@ -193,7 +193,7 @@ def _rmtree_posix(path: str) -> int:
path_len: sizet = len(path) path_len: sizet = len(path)
result: int = 0 result: int = 0
entry: rawptr[posix.Dirent] = posix.readdir(dirp) entry: posix.Dirent* = posix.readdir(dirp)
while entry != None: while entry != None:
name: str = entry.d_name name: str = entry.d_name
# Skip . and .. # Skip . and ..
socket.vp
+2 -2
View File
@@ -90,7 +90,7 @@ extern def bind(fd: u64, addr: SocketAddr*, addrlen: INT) -> INT
extern def listen(fd: u64, backlog: INT) -> INT extern def listen(fd: u64, backlog: INT) -> INT
extern def accept(fd: u64, addr: SocketAddr*, addrlen: INT*) -> u64 extern def accept(fd: u64, addr: SocketAddr*, addrlen: INT*) -> u64
extern def setsockopt(fd: u64, level: INT, optname: INT, optval: t.CPtr, optlen: INT) -> INT extern def setsockopt(fd: u64, level: INT, optname: INT, optval: t.CPtr, optlen: INT) -> INT
extern def gethostbyname(name: t.CConst | str) -> HostEnt* extern def gethostbyname(name: const str) -> HostEnt*
extern def ntohs(netshort: u16) -> u16 extern def ntohs(netshort: u16) -> u16
extern def htons(hostshort: u16) -> u16 extern def htons(hostshort: u16) -> u16
extern def close(fd: u64) -> INT extern def close(fd: u64) -> INT
@@ -123,7 +123,7 @@ def _MakeAddr(host: str, port: INT) -> SocketAddr:
# DNS resolution — gethostbyname returns struct hostent* # DNS resolution — gethostbyname returns struct hostent*
# h_addr_list is char** → h_addr_list[0] is char* → *(uint32_t*)h_addr_list[0] is IP # h_addr_list is char** → h_addr_list[0] is char* → *(uint32_t*)h_addr_list[0] is IP
if platmacro.IS_WINDOWS: if platmacro.IS_WINDOWS:
he_raw: rawptr[w32.winsock2.WSAHostEnt] = w32.winsock2.gethostbyname(host) he_raw: w32.winsock2.WSAHostEnt* = w32.winsock2.gethostbyname(host)
if he_raw is not None: if he_raw is not None:
# he_raw.h_addr_list → he_raw->h_addr_list (char**) # he_raw.h_addr_list → he_raw->h_addr_list (char**)
# c.Deref(uint64(he_raw.h_addr_list, t.CPtr)) → *(uint64_t*)(he_raw->h_addr_list) → h_addr_list[0] # c.Deref(uint64(he_raw.h_addr_list, t.CPtr)) → *(uint64_t*)(he_raw->h_addr_list) → h_addr_list[0]
stdio.vp
+6 -6
View File
@@ -1,11 +1,11 @@
import t, c import t, c
extern def printf(fmt: t.CConst | str, *args) -> int extern def printf(fmt: const str, *args) -> int
extern def fprintf(stream: bytes, fmt: t.CConst | str, *args) -> int extern def fprintf(stream: bytes, fmt: const str, *args) -> int
extern def sprintf(buf: bytes, fmt: t.CConst | str, *args) -> int extern def sprintf(buf: bytes, fmt: const str, *args) -> int
extern def snprintf(buf: bytes, size: sizet, fmt: t.CConst | str, *args) -> int extern def snprintf(buf: bytes, size: sizet, fmt: const str, *args) -> int
extern def puts(s: t.CConst | str) -> int extern def puts(s: const str) -> int
extern def fputs(s: t.CConst | str, stream: bytes) -> int extern def fputs(s: const str, stream: bytes) -> int
extern def fgets(buf: bytes, size: int, stream: bytes) -> bytes extern def fgets(buf: bytes, size: int, stream: bytes) -> bytes
extern def fflush(stream: bytes) -> int extern def fflush(stream: bytes) -> int
stdlib.vp
+1 -1
View File
@@ -6,5 +6,5 @@ extern def malloc(size: sizet) -> t.CPtr
extern def calloc(nmemb: sizet, size: sizet) -> t.CPtr extern def calloc(nmemb: sizet, size: sizet) -> t.CPtr
extern def realloc(p: t.CPtr, size: sizet) -> t.CPtr extern def realloc(p: t.CPtr, size: sizet) -> t.CPtr
extern def free(p: t.CPtr) extern def free(p: t.CPtr)
extern def system(cmd: t.CConst | str) -> int extern def system(cmd: const str) -> int
extern def exit(status: int) extern def exit(status: int)
torch/__init__.vp
+2 -2
View File
@@ -52,7 +52,7 @@ def zeros(pool: memhub.MemBuddy*, rows: sizet,
"""torch.zeros: create a rows x cols all-zero Tensor, optionally allocating a Grad buffer""" """torch.zeros: create a rows x cols all-zero Tensor, optionally allocating a Grad buffer"""
if pool is None: if pool is None:
return None return None
t0: rawptr[Tensor] = pool.alloc(TENSOR_SIZE) t0: Tensor* = pool.alloc(TENSOR_SIZE)
if t0 is None: if t0 is None:
return None return None
string.memset(t0, 0, TENSOR_SIZE) string.memset(t0, 0, TENSOR_SIZE)
@@ -73,7 +73,7 @@ def from_raw(pool: memhub.MemBuddy*, data: t.CPtr,
"""torch.from_raw: wrap existing memory as a Tensor (no copy, not owned)""" """torch.from_raw: wrap existing memory as a Tensor (no copy, not owned)"""
if pool is None: if pool is None:
return None return None
t0: rawptr[Tensor] = pool.alloc(TENSOR_SIZE) t0: Tensor* = pool.alloc(TENSOR_SIZE)
if t0 is None: if t0 is None:
return None return None
string.memset(t0, 0, TENSOR_SIZE) string.memset(t0, 0, TENSOR_SIZE)
traceback.vp
+10 -10
View File
@@ -533,7 +533,7 @@ class TracebackState():
# Sole global state: None = not installed (zero side effects while the sidecar is absent). # Sole global state: None = not installed (zero side effects while the sidecar is absent).
# Pointer + lazy allocation instead of a module-level object constant, which would emit a # Pointer + lazy allocation instead of a module-level object constant, which would emit a
# constructor that may run after Install and wipe the state it wrote. # constructor that may run after Install and wipe the state it wrote.
_State: rawptr[TracebackState] = None _State: TracebackState* = None
# ---- Dump atomic lock / locked output handle ---- # ---- Dump atomic lock / locked output handle ----
@@ -827,7 +827,7 @@ def EntryRva(Index: int) -> uint64:
"""RVA of record Index (record area starts at MapBase + 20). """RVA of record Index (record area starts at MapBase + 20).
The bare `_State` null-check below is REQUIRED: the attribute layer registers `_State` per The bare `_State` null-check below is REQUIRED: the attribute layer registers `_State` per
function before it can resolve this module-level `rawptr[TracebackState]`; without it function before it can resolve this module-level `TracebackState*`; without it
`_State.MapBase` is silently folded to null (see header section 11 A). It also guards `_State.MapBase` is silently folded to null (see header section 11 A). It also guards
against an uninstalled state (returns 0). against an uninstalled state (returns 0).
""" """
@@ -1131,7 +1131,7 @@ def ReadMemCb(hProcess: HANDLE, Addr: ULONGLONG, Buf: VOIDPTR, Size: DWORD,
Read: sizet = 0 Read: sizet = 0
R: BOOL = wm.ReadProcessMemory(hProcess, t.CPtr(Addr), Buf, sizet(Size), &Read) R: BOOL = wm.ReadProcessMemory(hProcess, t.CPtr(Addr), Buf, sizet(Size), &Read)
if pRead != None: if pRead != None:
Rd: rawptr[uint32] = (rawptr[uint32])(pRead) Rd: uint32* = (uint32*)(pRead)
Rd[0] = uint32(Read) Rd[0] = uint32(Read)
if R == 0 and _State != None and _State.ReadMemFailed == 0: if R == 0 and _State != None and _State.ReadMemFailed == 0:
# Record only the first failure (address/size/error); WalkViaDbgHelp prints it next to the # Record only the first failure (address/size/error); WalkViaDbgHelp prints it next to the
@@ -1153,7 +1153,7 @@ def WalkViaDbgHelp(hProcess: HANDLE, hThread: HANDLE, CtxPtr: VOIDPTR,
never enters. It is the only path that can cross a frameless system frame (RBP=0 in the Ctrl+C never enters. It is the only path that can cross a frameless system frame (RBP=0 in the Ctrl+C
context) via the PE unwind tables (.pdata) and reach the real .vp stack. context) via the PE unwind tables (.pdata) and reach the real .vp stack.
STACKFRAME64 fields are accessed through explicit sub-struct pointers (rawptr[dbg.ADDRESS64]): STACKFRAME64 fields are accessed through explicit sub-struct pointers (dbg.ADDRESS64*):
the ADDRESS64 structures sit at offsets 0 / 16 / 32 / 48 (= AddrPC / AddrReturn / AddrFrame / the ADDRESS64 structures sit at offsets 0 / 16 / 32 / 48 (= AddrPC / AddrReturn / AddrFrame /
AddrStack, see includes/w32/win32dbghelp.vp). After zeroing, AddrPC/AddrFrame/AddrStack are AddrStack, see includes/w32/win32dbghelp.vp). After zeroing, AddrPC/AddrFrame/AddrStack are
pre-filled with the context's Rip/Rbp/Rsp and Mode = AddrModeFlat(3); MachineType is passed on pre-filled with the context's Rip/Rbp/Rsp and Mode = AddrModeFlat(3); MachineType is passed on
@@ -1200,10 +1200,10 @@ def WalkViaDbgHelp(hProcess: HANDLE, hThread: HANDLE, CtxPtr: VOIDPTR,
Reason: str = "frame_limit" Reason: str = "frame_limit"
if TRACEBACK_USE_DBGHELP != 0: if TRACEBACK_USE_DBGHELP != 0:
string.memset(FBuf, 0, dbg.STACKFRAME64.__sizeof__()) string.memset(FBuf, 0, dbg.STACKFRAME64.__sizeof__())
ctx: rawptr[wp.CONTEXT] = (rawptr[wp.CONTEXT])(CtxPtr) ctx: wp.CONTEXT* = (wp.CONTEXT*)(CtxPtr)
Pc: rawptr[dbg.ADDRESS64] = (rawptr[dbg.ADDRESS64])(FBuf) Pc: dbg.ADDRESS64* = (dbg.ADDRESS64*)(FBuf)
Fm: rawptr[dbg.ADDRESS64] = (rawptr[dbg.ADDRESS64])(FBuf + 32) Fm: dbg.ADDRESS64* = (dbg.ADDRESS64*)(FBuf + 32)
St: rawptr[dbg.ADDRESS64] = (rawptr[dbg.ADDRESS64])(FBuf + 48) St: dbg.ADDRESS64* = (dbg.ADDRESS64*)(FBuf + 48)
Pc.Offset = ctx.Rip Pc.Offset = ctx.Rip
Pc.Mode = uint32(dbg.ADDR_MODE_FLAT) Pc.Mode = uint32(dbg.ADDR_MODE_FLAT)
Fm.Offset = ctx.Rbp Fm.Offset = ctx.Rbp
@@ -1628,7 +1628,7 @@ def DumpMainThread(IsBreak: int) -> int:
return 0 return 0
# CONTEXT: zero it first, then set ContextFlags (x64 needs the CONTEXT_AMD64 bit). # CONTEXT: zero it first, then set ContextFlags (x64 needs the CONTEXT_AMD64 bit).
string.memset(_State.ContextBuf, 0, wp.CONTEXT.__sizeof__()) string.memset(_State.ContextBuf, 0, wp.CONTEXT.__sizeof__())
ctx: rawptr[wp.CONTEXT] = (rawptr[wp.CONTEXT])(_State.ContextBuf) ctx: wp.CONTEXT* = (wp.CONTEXT*)(_State.ContextBuf)
ctx.ContextFlags = uint32(wp.CONTEXT_FULL) ctx.ContextFlags = uint32(wp.CONTEXT_FULL)
if wp.GetThreadContext(hThread, t.CPtr(_State.ContextBuf)) == 0: if wp.GetThreadContext(hThread, t.CPtr(_State.ContextBuf)) == 0:
N = stdio.snprintf(_State.LineBuf, sizet(TRACEBACK_LINE_CAP), N = stdio.snprintf(_State.LineBuf, sizet(TRACEBACK_LINE_CAP),
@@ -1878,7 +1878,7 @@ def DumpCrashThread(Info: VOIDPTR) -> int:
AtomicLeaveDump() AtomicLeaveDump()
return 0 return 0
Base: uint64 = uint64(GetModuleHandleA(None)) Base: uint64 = uint64(GetModuleHandleA(None))
ctx: rawptr[wp.CONTEXT] = (rawptr[wp.CONTEXT])(_State.ContextBuf) ctx: wp.CONTEXT* = (wp.CONTEXT*)(_State.ContextBuf)
Rip: uint64 = uint64(ctx.Rip) Rip: uint64 = uint64(ctx.Rip)
Rsp: uint64 = uint64(ctx.Rsp) Rsp: uint64 = uint64(ctx.Rsp)
Rbp: uint64 = uint64(ctx.Rbp) Rbp: uint64 = uint64(ctx.Rbp)
zlib/pyzlib.vp
+14 -14
View File
@@ -67,7 +67,7 @@ pyzlib_error_code_val: int = 0
# Structures # Structures
# ============================================================ # ============================================================
class Compress: class Compress:
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
stream: VOIDPTR stream: VOIDPTR
is_initialized: int is_initialized: int
is_finished: int is_finished: int
@@ -140,7 +140,7 @@ class Compress:
if not out_len: if not out_len:
set_error(Z_STREAM_ERROR, "out_len is None") set_error(Z_STREAM_ERROR, "out_len is None")
return None return None
s: rawptr[zdeflate.zdeflate_stream] = self.stream # implicit type conversion s: zdeflate.zdeflate_stream* = self.stream # implicit type conversion
if mode == Z_FINISH: if mode == Z_FINISH:
if not self.header_written: if not self.header_written:
self.header_written = 1 self.header_written = 1
@@ -231,7 +231,7 @@ class Compress:
set_error(Z_MEM_ERROR, "out of memory") set_error(Z_MEM_ERROR, "out of memory")
return None return None
copy_obj.pool = self.pool copy_obj.pool = self.pool
s: rawptr[zdeflate.zdeflate_stream] = self.stream # implicit type conversion s: zdeflate.zdeflate_stream* = self.stream # implicit type conversion
copy_obj.stream = s.copy() copy_obj.stream = s.copy()
if not copy_obj.stream: if not copy_obj.stream:
if self.pool == None: if self.pool == None:
@@ -274,7 +274,7 @@ class Compress:
def delete(self): def delete(self):
if self.is_initialized and self.stream: if self.is_initialized and self.stream:
s: rawptr[zdeflate.zdeflate_stream] = self.stream # implicit type conversion s: zdeflate.zdeflate_stream* = self.stream # implicit type conversion
s.destroy() s.destroy()
if self.pool == None: if self.pool == None:
stdlib.free(self.zdict) stdlib.free(self.zdict)
@@ -290,7 +290,7 @@ class Compress:
class Decompress: class Decompress:
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
stream: VOIDPTR stream: VOIDPTR
is_initialized: int is_initialized: int
eof: int eof: int
@@ -338,7 +338,7 @@ class Decompress:
p7: BYTEPTR = BYTEPTR(self.pool.alloc(1)) p7: BYTEPTR = BYTEPTR(self.pool.alloc(1))
string.memset(p7, 0, 1) string.memset(p7, 0, 1)
return p7 return p7
s: rawptr[zinflate.zinflate_stream] = zinflate.zinflate_create(self.pool, self.wbits) s: zinflate.zinflate_stream* = zinflate.zinflate_create(self.pool, self.wbits)
if not s: if not s:
set_error(Z_MEM_ERROR, "out of memory") set_error(Z_MEM_ERROR, "out of memory")
return None return None
@@ -473,7 +473,7 @@ def set_error(code: int, msg: str):
else: else:
pyzlib_error_msg[0] = '\0' pyzlib_error_msg[0] = '\0'
def clone_bytes(pool: rawptr[memhub.MemManager], src: BYTEPTR, length: sizet) -> BYTEPTR: def clone_bytes(pool: memhub.MemManager*, src: BYTEPTR, length: sizet) -> BYTEPTR:
if not src or length == 0: return None if not src or length == 0: return None
if pool == None: if pool == None:
dst: BYTEPTR = BYTEPTR(stdlib.malloc(length)) dst: BYTEPTR = BYTEPTR(stdlib.malloc(length))
@@ -483,7 +483,7 @@ def clone_bytes(pool: rawptr[memhub.MemManager], src: BYTEPTR, length: sizet) ->
return dst return dst
# buf is a "pointer to pointer" (i8**). Do NOT write `BYTE | t.CPtr[t.CPtr]`: with an embedded `t.CPtr[...]` subscript the declare side (StubGen/VpiReader) does not recognize it as a CPtr marker and collapses it to BYTE = i8, mismatching the definition side's i8** (cross-module ABI mismatch; see includes/zlib/zinflate.vp decompress). Use "pointer alias | t.CPtr" instead. # buf is a "pointer to pointer" (i8**). Do NOT write `BYTE | t.CPtr[t.CPtr]`: with an embedded `t.CPtr[...]` subscript the declare side (StubGen/VpiReader) does not recognize it as a CPtr marker and collapses it to BYTE = i8, mismatching the definition side's i8** (cross-module ABI mismatch; see includes/zlib/zinflate.vp decompress). Use "pointer alias | t.CPtr" instead.
def append_bytes(pool: rawptr[memhub.MemManager], buf: BYTEPTR*, length: sizet*, cap: sizet*, def append_bytes(pool: memhub.MemManager*, buf: BYTEPTR*, length: sizet*, cap: sizet*,
data: BYTEPTR, data_len: sizet) -> int: data: BYTEPTR, data_len: sizet) -> int:
if not data or data_len == 0: return 0 if not data or data_len == 0: return 0
needed: sizet = *length + data_len needed: sizet = *length + data_len
@@ -505,7 +505,7 @@ def append_bytes(pool: rawptr[memhub.MemManager], buf: BYTEPTR*, length: sizet*,
return 0 return 0
def shrink_to_fit(pool: rawptr[memhub.MemManager], buf: BYTEPTR, length: sizet) -> BYTEPTR: def shrink_to_fit(pool: memhub.MemManager*, buf: BYTEPTR, length: sizet) -> BYTEPTR:
if length == 0: if length == 0:
if pool == None: if pool == None:
stdlib.free(buf) stdlib.free(buf)
@@ -541,7 +541,7 @@ def clear_error():
pyzlib_error_msg[0] = '\0' pyzlib_error_msg[0] = '\0'
pyzlib_error_code_val = 0 pyzlib_error_code_val = 0
def compress(pool: rawptr[memhub.MemManager], data: BYTEPTR, data_len: sizet, def compress(pool: memhub.MemManager*, data: BYTEPTR, data_len: sizet,
level: int, wbits: int, out_len: sizet*) -> BYTEPTR: level: int, wbits: int, out_len: sizet*) -> BYTEPTR:
if not data and data_len > 0: if not data and data_len > 0:
set_error(Z_STREAM_ERROR, "data is None but data_len > 0") set_error(Z_STREAM_ERROR, "data is None but data_len > 0")
@@ -604,7 +604,7 @@ def compress(pool: rawptr[memhub.MemManager], data: BYTEPTR, data_len: sizet,
return shrink_to_fit(pool, raw_result, *out_len) return shrink_to_fit(pool, raw_result, *out_len)
def decompress(pool: rawptr[memhub.MemManager], data: BYTEPTR, data_len: sizet, def decompress(pool: memhub.MemManager*, data: BYTEPTR, data_len: sizet,
wbits: int, bufsize: sizet, out_len: sizet*) -> BYTEPTR: wbits: int, bufsize: sizet, out_len: sizet*) -> BYTEPTR:
if not data and data_len > 0: if not data and data_len > 0:
set_error(Z_STREAM_ERROR, "data is None but data_len > 0") set_error(Z_STREAM_ERROR, "data is None but data_len > 0")
@@ -618,7 +618,7 @@ def decompress(pool: rawptr[memhub.MemManager], data: BYTEPTR, data_len: sizet,
return None return None
return shrink_to_fit(pool, result, *out_len) return shrink_to_fit(pool, result, *out_len)
def compressobj(pool: rawptr[memhub.MemManager], level: int, method: int, wbits: int, def compressobj(pool: memhub.MemManager*, level: int, method: int, wbits: int,
memLevel: int, strategy: int, memLevel: int, strategy: int,
zdict: BYTEPTR, zdict_len: sizet) -> Compress*: zdict: BYTEPTR, zdict_len: sizet) -> Compress*:
if pool == None: if pool == None:
@@ -632,7 +632,7 @@ def compressobj(pool: rawptr[memhub.MemManager], level: int, method: int, wbits:
obj.pool = pool obj.pool = pool
actual_wbits: int = wbits actual_wbits: int = wbits
if wbits > MAX_WBITS: actual_wbits = wbits - 16 if wbits > MAX_WBITS: actual_wbits = wbits - 16
s: rawptr[zdeflate.zdeflate_stream] = zdeflate.zdeflate_create(pool, level, actual_wbits, memLevel, strategy) s: zdeflate.zdeflate_stream* = zdeflate.zdeflate_create(pool, level, actual_wbits, memLevel, strategy)
if not s: if not s:
if pool == None: if pool == None:
stdlib.free(obj) stdlib.free(obj)
@@ -662,7 +662,7 @@ def compressobj(pool: rawptr[memhub.MemManager], level: int, method: int, wbits:
return obj return obj
def decompressobj(pool: rawptr[memhub.MemManager], wbits: int, zdict: BYTEPTR, zdict_len: sizet) -> Decompress*: def decompressobj(pool: memhub.MemManager*, wbits: int, zdict: BYTEPTR, zdict_len: sizet) -> Decompress*:
if pool == None: if pool == None:
obj: Decompress* = stdlib.calloc(1, Decompress.__sizeof__()) obj: Decompress* = stdlib.calloc(1, Decompress.__sizeof__())
else: else:
zlib/zdef.vp
+4 -4
View File
@@ -95,13 +95,13 @@ zdeflate_codelen_order: t.CArray[int, 19] = [
# Bit writer - writes bits LSB first into a byte buffer # Bit writer - writes bits LSB first into a byte buffer
# ============================================================ # ============================================================
class zbit_writer: class zbit_writer:
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
buf: BYTE* buf: BYTE*
cap: sizet cap: sizet
byte_pos: sizet byte_pos: sizet
bit_pos: int bit_pos: int
def __init__(self, pool: rawptr[memhub.MemManager]): def __init__(self, pool: memhub.MemManager*):
self.pool = pool self.pool = pool
self.cap = 4096 self.cap = 4096
if pool == None: if pool == None:
@@ -275,10 +275,10 @@ class zbit_reader:
# Memory allocation helper for bare metal # Memory allocation helper for bare metal
# Can be replaced with custom allocator # Can be replaced with custom allocator
# ============================================================ # ============================================================
def zdef_alloc(pool: rawptr[memhub.MemManager], n: sizet) -> VOIDPTR: def zdef_alloc(pool: memhub.MemManager*, n: sizet) -> VOIDPTR:
if pool == None: return stdlib.malloc(n) if pool == None: return stdlib.malloc(n)
return pool.alloc(n) return pool.alloc(n)
def zdef_free(pool: rawptr[memhub.MemManager], p: VOIDPTR): def zdef_free(pool: memhub.MemManager*, p: VOIDPTR):
if pool == None: if pool == None:
stdlib.free(p) stdlib.free(p)
return return
zlib/zdeflate.vp
+5 -5
View File
@@ -8,7 +8,7 @@ import t, c
class zdeflate_stream: class zdeflate_stream:
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
writer: zdef.zbit_writer writer: zdef.zbit_writer
window: BYTE* window: BYTE*
window_pos: int window_pos: int
@@ -92,7 +92,7 @@ class zdeflate_stream:
lit_tree.encode_symbol(256, &self.writer) lit_tree.encode_symbol(256, &self.writer)
def encode_block_data(self, data: UINT8PTR, length: sizet, def encode_block_data(self, data: UINT8PTR, length: sizet,
lit_tree: rawptr[zhuff.zhuff_tree], dist_tree: rawptr[zhuff.zhuff_tree]): lit_tree: zhuff.zhuff_tree*, dist_tree: zhuff.zhuff_tree*):
pos: sizet = 0 pos: sizet = 0
while pos < length: while pos < length:
best_dist: int = 0 best_dist: int = 0
@@ -335,7 +335,7 @@ def zdeflate_count_cl_freqs(all_lengths: INTPTR, total: int, cl_freqs: INTPTR):
# Remaining 1~2 equal-length values are not silently skipped; the outer loop counts them literally (symbol val), so the covered total is exactly total # Remaining 1~2 equal-length values are not silently skipped; the outer loop counts them literally (symbol val), so the covered total is exactly total
def zdeflate_write_cl_encoded(all_lengths: INTPTR, total: int, def zdeflate_write_cl_encoded(all_lengths: INTPTR, total: int,
w: rawptr[zdef.zbit_writer], cl_tree: rawptr[zhuff.zhuff_tree]): w: zdef.zbit_writer*, cl_tree: zhuff.zhuff_tree*):
i: int = 0 i: int = 0
while i < total: while i < total:
if all_lengths[i] == 0: if all_lengths[i] == 0:
@@ -375,7 +375,7 @@ def zdeflate_write_cl_encoded(all_lengths: INTPTR, total: int,
def zdeflate_create(pool: rawptr[memhub.MemManager], level: int, wbits: int, mem_level: int, strategy: int) -> zdeflate_stream*: def zdeflate_create(pool: memhub.MemManager*, level: int, wbits: int, mem_level: int, strategy: int) -> zdeflate_stream*:
n: sizet = zdeflate_stream.__sizeof__() n: sizet = zdeflate_stream.__sizeof__()
s: zdeflate_stream* = zdef.zdef_alloc(pool, n) s: zdeflate_stream* = zdef.zdef_alloc(pool, n)
if not s: return None if not s: return None
@@ -402,7 +402,7 @@ def zdeflate_create(pool: rawptr[memhub.MemManager], level: int, wbits: int, mem
return s return s
def zdeflate_one_shot(pool: rawptr[memhub.MemManager], data: UINT8PTR, length: sizet, def zdeflate_one_shot(pool: memhub.MemManager*, data: UINT8PTR, length: sizet,
level: int, wbits: int, out_len: sizet*) -> uint8*: level: int, wbits: int, out_len: sizet*) -> uint8*:
s: zdeflate_stream* = zdeflate_create(pool, level, wbits, 8, 0) s: zdeflate_stream* = zdeflate_create(pool, level, wbits, 8, 0)
if not s: return None if not s: return None
zlib/zhuff.vp
+4 -4
View File
@@ -15,7 +15,7 @@ class zhuff_code:
@t.Object @t.Object
class zhuff_tree: class zhuff_tree:
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
codes: t.CArray[zhuff_code, ZHUFF_MAX_CODES] codes: t.CArray[zhuff_code, ZHUFF_MAX_CODES]
count: int count: int
max_bits: int max_bits: int
@@ -95,7 +95,7 @@ class zhuff_tree:
else: else:
self.codes[i].code = 0 self.codes[i].code = 0
def encode_symbol(self, symbol: int, writer: rawptr[zdef.zbit_writer]): def encode_symbol(self, symbol: int, writer: zdef.zbit_writer*):
if symbol < 0 or symbol >= self.count: if symbol < 0 or symbol >= self.count:
return return
if self.codes[symbol].bits == 0: if self.codes[symbol].bits == 0:
@@ -304,7 +304,7 @@ class zhuff_decode_node:
class zhuff_decode_tree: class zhuff_decode_tree:
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
nodes: t.CArray[zhuff_decode_node, 2 * ZHUFF_MAX_CODES] nodes: t.CArray[zhuff_decode_node, 2 * ZHUFF_MAX_CODES]
node_count: int node_count: int
root: int root: int
@@ -345,7 +345,7 @@ class zhuff_decode_tree:
else: else:
self.nodes[self.nodes[node].children[dir]].symbol = i self.nodes[self.nodes[node].children[dir]].symbol = i
def decode_symbol(self, reader: rawptr[zdef.zbit_reader]) -> int: def decode_symbol(self, reader: zdef.zbit_reader*) -> int:
node: int = self.root node: int = self.root
while self.nodes[node].symbol == -1: while self.nodes[node].symbol == -1:
bit: uint bit: uint
zlib/zinflate.vp
+6 -6
View File
@@ -8,7 +8,7 @@ import t, c
class zinflate_stream: class zinflate_stream:
pool: rawptr[memhub.MemManager] pool: memhub.MemManager*
reader: zdef.zbit_reader reader: zdef.zbit_reader
window: BYTEPTR window: BYTEPTR
@@ -108,7 +108,7 @@ class zinflate_stream:
return 0 return 0
def read_huffman(self, dt: rawptr[zhuff.zhuff_decode_tree]) -> int: def read_huffman(self, dt: zhuff.zhuff_decode_tree*) -> int:
node: int = dt.root node: int = dt.root
while dt.nodes[node].symbol == -1: while dt.nodes[node].symbol == -1:
bit: UINT bit: UINT
@@ -141,8 +141,8 @@ class zinflate_stream:
lit_tree.build_fixed_lit_tree() lit_tree.build_fixed_lit_tree()
dist_tree.build_fixed_dist_tree() dist_tree.build_fixed_dist_tree()
lit_dt: rawptr[zhuff.zhuff_decode_tree] = zdef.zdef_alloc(self.pool, zhuff.zhuff_decode_tree.__sizeof__()) lit_dt: zhuff.zhuff_decode_tree* = zdef.zdef_alloc(self.pool, zhuff.zhuff_decode_tree.__sizeof__())
dist_dt: rawptr[zhuff.zhuff_decode_tree] = zdef.zdef_alloc(self.pool, zhuff.zhuff_decode_tree.__sizeof__()) dist_dt: zhuff.zhuff_decode_tree* = zdef.zdef_alloc(self.pool, zhuff.zhuff_decode_tree.__sizeof__())
if not lit_dt or not dist_dt: if not lit_dt or not dist_dt:
if lit_dt: zdef.zdef_free(self.pool, lit_dt) if lit_dt: zdef.zdef_free(self.pool, lit_dt)
if dist_dt: zdef.zdef_free(self.pool, dist_dt) if dist_dt: zdef.zdef_free(self.pool, dist_dt)
@@ -430,7 +430,7 @@ class zinflate_stream:
zdef.zdef_free(self.pool, self) zdef.zdef_free(self.pool, self)
def zinflate_one_shot(pool: rawptr[memhub.MemManager], data: UINT8PTR, length: sizet, def zinflate_one_shot(pool: memhub.MemManager*, data: UINT8PTR, length: sizet,
wbits: int, bufsize: sizet, out_len: sizet*) -> uint8*: wbits: int, bufsize: sizet, out_len: sizet*) -> uint8*:
s: zinflate_stream* = zinflate_create(pool, wbits) s: zinflate_stream* = zinflate_create(pool, wbits)
if not s: return None if not s: return None
@@ -441,7 +441,7 @@ def zinflate_one_shot(pool: rawptr[memhub.MemManager], data: UINT8PTR, length: s
return out return out
def zinflate_create(pool: rawptr[memhub.MemManager], wbits: int) -> zinflate_stream*: def zinflate_create(pool: memhub.MemManager*, wbits: int) -> zinflate_stream*:
s: zinflate_stream* = zdef.zdef_alloc(pool, zinflate_stream.__sizeof__()) s: zinflate_stream* = zdef.zdef_alloc(pool, zinflate_stream.__sizeof__())
if not s: return None if not s: return None
string.memset(s, 0, zinflate_stream.__sizeof__()) string.memset(s, 0, zinflate_stream.__sizeof__())