1202 lines
71 KiB
Plaintext
1202 lines
71 KiB
Plaintext
import lib.core.Gen.GenTypes as GenTypes
|
||
from stdint import *
|
||
import ast
|
||
import mlirlite
|
||
import memhub
|
||
import string
|
||
import viperlib
|
||
import lib.core.VLogger as VLogger
|
||
import lib.core.Gen.Translator as HT
|
||
import lib.core.CompilerFactory as CompilerFactory
|
||
|
||
from . import ClassGenBase
|
||
|
||
|
||
# Local constant copies (originally defined in HandlesEnum/HandlesClassDef; lost when the file was split).
|
||
# Undefined names fold to 0 in constant context, silently skipping enum member collection and CEnum registration.
|
||
define ENUM_MEMBER_MAX_LOCAL = 128
|
||
define RENUM_CLASS_MAX = 64
|
||
define RENUM_VARIANT_PER_CLASS = 32
|
||
define RENUM_ALIAS_MAX = 512
|
||
|
||
# ClassGenEnum - split from ClassGenMixin (stage D): enum/union/renum definitions and variant tables.
|
||
# ============================================================
|
||
novirtual class ClassGenEnum(ClassGenBase.ClassGenBase):
|
||
"""enum/union/renum definitions and variant tables"""
|
||
|
||
def _resolve_enum_member_type(self, pool: memhub.MemBuddy*, ann_node: ast.AST*, imported_modules: str, from_imports: str) -> mlirlite.LLVMType*:
|
||
"""Resolve an enum member's type annotation to an LLVM integer type"""
|
||
if ann_node is None: return mlirlite.Int32(pool)
|
||
|
||
k: int = ann_node.kind()
|
||
|
||
# Attribute node: t.State / int / int8 etc.
|
||
if k == ast.ASTKind.Attribute:
|
||
at: ast.Attribute* = ast.Attribute*(ann_node)
|
||
if at.attr is None:
|
||
# [S4 fail-fast] Attribute missing the member name (corrupt AST); no silent i32 fallback
|
||
self.Gen.TypeGenErr.fatal_error(ann_node, "enum member type annotation Attribute is missing the member name", "TypeError")
|
||
return mlirlite.Int32(pool) # unreachable (fatal_error already exited)
|
||
# t.State -> default i32
|
||
if string.strcmp(at.attr, "State") == 0: return mlirlite.Int32(pool)
|
||
# [enum bool rule] `t.CBool` and bare `bool` both materialize as 8 bits in enum member annotations,
|
||
# else the same member would split into i1 / i8; the global `t.CBool` stays i1 (only enums differ).
|
||
if string.strcmp(at.attr, "CBool") == 0: return mlirlite.Int8(pool)
|
||
# Other t.CXxx types: unified (CTypedef dynamic table first, fall back to map_builtin_type)
|
||
ty: mlirlite.LLVMType* = self.Gen.TypeGenResolve.resolve_typedef_or_map(pool, at.attr, imported_modules, from_imports)
|
||
if ty is not None: return ty
|
||
# [S4 fail-fast] annotated but unresolvable -> no silent i32 fallback
|
||
self.Gen.TypeGenErr.fatal_error(ann_node, f"failed to resolve enum member type annotation: t.{at.attr}", "NameError")
|
||
return mlirlite.Int32(pool) # unreachable (fatal_error already exited)
|
||
|
||
# Name node: from-import form (State / CInt)
|
||
if k == ast.ASTKind.Name:
|
||
nm: ast.Name* = ast.Name*(ann_node)
|
||
if nm.id is None:
|
||
# [S4 fail-fast] Name missing the identifier (corrupt AST); no silent i32 fallback
|
||
self.Gen.TypeGenErr.fatal_error(ann_node, "enum member type annotation Name is missing the identifier", "TypeError")
|
||
return mlirlite.Int32(pool) # unreachable (fatal_error already exited)
|
||
if string.strcmp(nm.id, "State") == 0: return mlirlite.Int32(pool)
|
||
# Builtin bare integer types (same rule as resolve_annotation_type's Name branch): enum members are
|
||
# integer constants, so `int` / `char` / `bool` pass through; other bare names fail fast on a typedef miss.
|
||
if string.strcmp(nm.id, "int") == 0: return mlirlite.Int32(pool)
|
||
if string.strcmp(nm.id, "char") == 0: return mlirlite.Int8(pool)
|
||
if string.strcmp(nm.id, "bool") == 0:
|
||
# [enum bool rule] enum storage must be byte-addressable, and i1 cannot be an enum width,
|
||
# so an enum member's bool is 8 bits. This does not change the global bool = i1.
|
||
return mlirlite.Int8(pool)
|
||
ty2: mlirlite.LLVMType* = self.Gen.TypeGenResolve.resolve_typedef_or_map(pool, nm.id, imported_modules, from_imports)
|
||
if ty2 is not None: return ty2
|
||
# [S4 fail-fast] annotated but unresolvable -> no silent i32 fallback
|
||
self.Gen.TypeGenErr.fatal_error(ann_node, f"failed to resolve enum member type annotation: {nm.id}", "NameError")
|
||
return mlirlite.Int32(pool) # unreachable (fatal_error already exited)
|
||
|
||
# Marker wrapper (CConst[T] / CVolatile[T] / ...): resolve the wrapped type.
|
||
if k == ast.ASTKind.Subscript:
|
||
sub_em: ast.Subscript* = ast.Subscript*(ann_node)
|
||
if sub_em.value is not None and sub_em.value.kind() == ast.ASTKind.Name:
|
||
em_nm: ast.Name* = ast.Name*(sub_em.value)
|
||
if em_nm.id is not None and (string.strcmp(em_nm.id, "CConst") == 0 or string.strcmp(em_nm.id, "CVolatile") == 0 \
|
||
or string.strcmp(em_nm.id, "BigEndian") == 0 or string.strcmp(em_nm.id, "LittleEndian") == 0 \
|
||
or string.strcmp(em_nm.id, "State") == 0 or string.strcmp(em_nm.id, "CStatic") == 0 \
|
||
or string.strcmp(em_nm.id, "CExport") == 0 or string.strcmp(em_nm.id, "CExtern") == 0 \
|
||
or string.strcmp(em_nm.id, "CRef") == 0 or string.strcmp(em_nm.id, "CTempRef") == 0):
|
||
return self._resolve_enum_member_type(pool, sub_em.slice, imported_modules, from_imports)
|
||
self.Gen.TypeGenErr.fatal_type_error(ann_node, "unsupported enum member type: only scalar types and their markers are allowed")
|
||
return mlirlite.Int32(pool)
|
||
|
||
# BinOp nodes are never enum member types (`T1 | T2` unions retired).
|
||
if k == ast.ASTKind.BinOp:
|
||
self.Gen.TypeGenErr.fatal_type_error(ann_node, "enum member type uses the retired `T1 | T2` union; write the concrete type directly")
|
||
return mlirlite.Int32(pool)
|
||
|
||
# fail-fast: unknown annotation node kind; no silent i32 fallback
|
||
self.Gen.TypeGenErr.fatal_error(ann_node, f"failed to resolve enum member type annotation: {self.Gen.TypeGenResolve.annotation_to_str(ann_node)}", "TypeError")
|
||
return mlirlite.Int32(pool) # unreachable (fatal_error already exited)
|
||
def _is_state_annotation(self, node: ast.AST*) -> int:
|
||
"""Check whether an annotation node is t.State, 1=yes / 0=no"""
|
||
if node is None: return 0
|
||
k: int = node.kind()
|
||
if k == ast.ASTKind.Attribute:
|
||
at: ast.Attribute* = ast.Attribute*(node)
|
||
if at.attr is not None and string.strcmp(at.attr, "State") == 0: return 1
|
||
return 0
|
||
if k == ast.ASTKind.Name:
|
||
nm: ast.Name* = ast.Name*(node)
|
||
if nm.id is not None and string.strcmp(nm.id, "State") == 0: return 1
|
||
return 0
|
||
return 0
|
||
def _enum_annotation_name_is_ptr(self, node: ast.AST*) -> int:
|
||
"""Whether the annotation's top name (Name/Attribute/Subscript) is a pointer form, 1=yes / 0=no"""
|
||
if node is None: return 0
|
||
k: int = node.kind()
|
||
if k == ast.ASTKind.Attribute:
|
||
at: ast.Attribute* = ast.Attribute*(node)
|
||
if at.attr is not None:
|
||
if string.strcmp(at.attr, "CPtr") == 0: return 1
|
||
if string.strcmp(at.attr, "CRef") == 0: return 1
|
||
if string.strcmp(at.attr, "CTempRef") == 0: return 1
|
||
if string.strcmp(at.attr, "CAutoPtr") == 0: return 1
|
||
if string.strcmp(at.attr, "rawptr") == 0: return 1
|
||
if string.strcmp(at.attr, "str") == 0: return 1
|
||
if string.strcmp(at.attr, "bytes") == 0: return 1
|
||
return 0
|
||
if k == ast.ASTKind.Name:
|
||
nm: ast.Name* = ast.Name*(node)
|
||
if nm.id is not None:
|
||
if string.strcmp(nm.id, "CPtr") == 0: return 1
|
||
if string.strcmp(nm.id, "CRef") == 0: return 1
|
||
if string.strcmp(nm.id, "CTempRef") == 0: return 1
|
||
if string.strcmp(nm.id, "CAutoPtr") == 0: return 1
|
||
if string.strcmp(nm.id, "rawptr") == 0: return 1
|
||
if string.strcmp(nm.id, "str") == 0: return 1
|
||
if string.strcmp(nm.id, "bytes") == 0: return 1
|
||
return 0
|
||
if k == ast.ASTKind.Subscript:
|
||
sub: ast.Subscript* = ast.Subscript*(node)
|
||
if sub.value is not None and self._enum_annotation_name_is_ptr(sub.value) != 0: return 1
|
||
if sub.slice is not None: return self._enum_annotation_name_is_ptr(sub.slice)
|
||
return 0
|
||
return 0
|
||
def _enum_member_annotation_is_ptr(self, ann_node: ast.AST*) -> int:
|
||
"""Whether an enum member annotation contains a pointer type, 1=yes / 0=no"""
|
||
return self._enum_annotation_name_is_ptr(ann_node)
|
||
def _extract_int_value(self, node: ast.AST*) -> int64:
|
||
"""Extract an integer value from an AST node, 0 on failure"""
|
||
if node is None: return 0
|
||
k: int = node.kind()
|
||
if k == ast.ASTKind.Constant:
|
||
cn: ast.Constant* = ast.Constant*(node)
|
||
if cn.const_kind == ast.CONST_INT: return cn.int_val
|
||
return 0
|
||
if k == ast.ASTKind.UnaryOp:
|
||
uo: ast.UnaryOp* = ast.UnaryOp*(node)
|
||
if uo.op == ast.OpKind.USub:
|
||
inner: int64 = self._extract_int_value(uo.operand)
|
||
return -inner
|
||
return 0
|
||
return 0
|
||
|
||
# "Visible name vs registered name" fallback check for enum members (same rule source as TPC).
|
||
# Any unrecognized member form makes the visible-name count exceed the registered count -> fail-fast.
|
||
def _enum_elts_visible_names(self, elts: list[ast.AST*]*) -> int:
|
||
"""Count visible names in an element table (shared by Tuple/List)."""
|
||
if elts is None: return 0
|
||
n: int = 0
|
||
for i in range(int(len(elts))): n += self._enum_target_visible_names(elts.get(i))
|
||
return n
|
||
def _enum_target_visible_names(self, node: ast.AST*) -> int:
|
||
"""Count visible names at a member-name position (Name / Tuple / List items, Starred recursion)."""
|
||
if node is None: return 0
|
||
k: int = node.kind()
|
||
if k == ast.ASTKind.Name: return 1
|
||
if k == ast.ASTKind.Tuple:
|
||
tup: ast.Tuple* = ast.Tuple*(node)
|
||
return self._enum_elts_visible_names(tup.elts)
|
||
if k == ast.ASTKind.List:
|
||
lst: ast.List* = ast.List*(node)
|
||
return self._enum_elts_visible_names(lst.elts)
|
||
if k == ast.ASTKind.Starred:
|
||
st: ast.Starred* = ast.Starred*(node)
|
||
return self._enum_target_visible_names(st.value)
|
||
return 0
|
||
def _enum_body_visible_names(self, children: list[ast.AST*]*) -> int:
|
||
"""Total source-visible member names in an enum class body (including forms the registrar rejects)."""
|
||
if children is None: return 0
|
||
n: int = 0
|
||
for ci in range(int(len(children))):
|
||
stmt: ast.AST* = children.get(ci)
|
||
if stmt is None: continue
|
||
sk: int = stmt.kind()
|
||
if sk == ast.ASTKind.Assign:
|
||
ag: ast.Assign* = ast.Assign*(stmt)
|
||
if ag.targets is not None:
|
||
for ti in range(int(len(ag.targets))): n += self._enum_target_visible_names(ag.targets.get(ti))
|
||
elif sk == ast.ASTKind.AnnAssign:
|
||
aa: ast.AnnAssign* = ast.AnnAssign*(stmt)
|
||
n += self._enum_target_visible_names(aa.target)
|
||
elif sk == ast.ASTKind.Expr:
|
||
ex: ast.Expr* = ast.Expr*(stmt)
|
||
n += self._enum_target_visible_names(ex.value)
|
||
return n
|
||
def _enum_first_unregistered_node(self, children: list[ast.AST*]*) -> ast.AST*:
|
||
"""First statement with visible member names the registrar rejects, for fail-fast line location; None if none."""
|
||
if children is None: return None
|
||
for ci in range(int(len(children))):
|
||
stmt: ast.AST* = children.get(ci)
|
||
if stmt is None: continue
|
||
sk: int = stmt.kind()
|
||
if sk == ast.ASTKind.Expr:
|
||
ex: ast.Expr* = ast.Expr*(stmt)
|
||
if self._enum_target_visible_names(ex.value) > 0: return stmt
|
||
elif sk == ast.ASTKind.AnnAssign:
|
||
aa: ast.AnnAssign* = ast.AnnAssign*(stmt)
|
||
if aa.target is not None and aa.target.kind() != ast.ASTKind.Name and self._enum_target_visible_names(aa.target) > 0: return stmt
|
||
elif sk == ast.ASTKind.Assign:
|
||
ag: ast.Assign* = ast.Assign*(stmt)
|
||
if ag.targets is not None:
|
||
for ti in range(int(len(ag.targets))):
|
||
tgt: ast.AST* = ag.targets.get(ti)
|
||
if tgt is not None and tgt.kind() != ast.ASTKind.Name and self._enum_target_visible_names(tgt) > 0: return stmt
|
||
return None
|
||
def _translate_enum_def(self, trans: HT.Translator*, cd: ast.ClassDef*) -> int:
|
||
"""Translate an enum class definition, return 0"""
|
||
if cd is None or cd.name is None or trans is None: return 0
|
||
|
||
pool: memhub.MemBuddy* = trans.Pool
|
||
class_name: str = cd.name
|
||
|
||
# Do not skip by global same-name: cross-module enums may share a name (e.g. FRESULT), and
|
||
# skipping would drop the later module's members. register_enum/add_enum_member are idempotent.
|
||
|
||
children: list[ast.AST*]* = cd.children
|
||
if children is None:
|
||
VLogger.warning(f"{class_name} has no body", "ENUM")
|
||
return 0
|
||
|
||
cn: sizet = len(children)
|
||
|
||
# Temporary arrays holding member info
|
||
member_names_buf: sizet* = pool.alloc(8 * ENUM_MEMBER_MAX_LOCAL)
|
||
member_types_buf: sizet* = pool.alloc(8 * ENUM_MEMBER_MAX_LOCAL)
|
||
member_values_buf: int64* = pool.alloc(8 * ENUM_MEMBER_MAX_LOCAL)
|
||
if member_names_buf is None or member_types_buf is None or member_values_buf is None: return 0
|
||
string.memset(member_names_buf, 0, 8 * ENUM_MEMBER_MAX_LOCAL)
|
||
string.memset(member_types_buf, 0, 8 * ENUM_MEMBER_MAX_LOCAL)
|
||
string.memset(member_values_buf, 0, 8 * ENUM_MEMBER_MAX_LOCAL)
|
||
|
||
member_count: int = 0
|
||
next_val: int64 = 0
|
||
|
||
for ci in range(int(cn)):
|
||
stmt: ast.AST* = children.get(ci)
|
||
if stmt is None: continue
|
||
sk: int = stmt.kind()
|
||
|
||
if sk == ast.ASTKind.AnnAssign:
|
||
aa: ast.AnnAssign* = ast.AnnAssign*(stmt)
|
||
if aa is None or aa.target is None: continue
|
||
|
||
# Get the member name
|
||
if aa.target.kind() != ast.ASTKind.Name: continue
|
||
tgt: ast.Name* = ast.Name*(aa.target)
|
||
if tgt.id is None: continue
|
||
|
||
# [enum spec fail-fast] Members may not be pointer types: rawptr / CRef /
|
||
# CTempRef / CAutoPtr / rawptr[...] / str / bytes and unions carrying a pointer. Checked before type resolution.
|
||
if self._enum_member_annotation_is_ptr(aa.annotation) == 1:
|
||
self.Gen.TypeGenErr.fatal_error(aa, f"enum member '{tgt.id}' cannot be a pointer type (enum values only support integer member types)", "TypeError")
|
||
return 0 # unreachable (fatal_error already exited)
|
||
|
||
# Resolve the member type
|
||
member_ty: mlirlite.LLVMType* = self._resolve_enum_member_type(pool, aa.annotation, trans._imported_modules, trans._from_imports)
|
||
|
||
# [enum spec fail-fast] Member types must be integers: float/void/struct/array have bit
|
||
# width 0 and cannot drive "enum width = widest member"; no silent downgrade.
|
||
member_bits: int = self.Gen.TypeGenErr.get_llvm_type_bits(member_ty)
|
||
if member_bits <= 0:
|
||
self.Gen.TypeGenErr.fatal_error(aa, f"the type of enum member '{tgt.id}' must be an integer type (pointers/floats/void/structs/arrays are not allowed), cannot infer enum width", "TypeError")
|
||
return 0 # unreachable (fatal_error already exited)
|
||
|
||
# Resolve the member value
|
||
has_value: int = 0
|
||
cur_val: int64 = 0
|
||
if aa.value is not None:
|
||
cur_val = self._extract_int_value(aa.value)
|
||
has_value = 1
|
||
else: cur_val = next_val
|
||
|
||
# Next automatic value
|
||
next_val = cur_val + 1
|
||
|
||
# Store
|
||
if member_count < ENUM_MEMBER_MAX_LOCAL:
|
||
member_names_buf[member_count] = sizet(tgt.id)
|
||
member_types_buf[member_count] = sizet(member_ty)
|
||
member_values_buf[member_count] = cur_val
|
||
member_count += 1
|
||
|
||
elif sk == ast.ASTKind.Assign:
|
||
# Handle Assign-form enum members (DEBUG = 0, INFO = 1, ...). Each Name target is a
|
||
# member (A = B = 1 registers both), matching TPC's per-target rule.
|
||
ag: ast.Assign* = ast.Assign*(stmt)
|
||
if ag is None or ag.targets is None: continue
|
||
tgts: list[ast.AST*]* = ag.targets
|
||
tn: sizet = len(tgts)
|
||
if tn == 0: continue
|
||
|
||
# Assign has no annotation; default to i32
|
||
member_ty_a: mlirlite.LLVMType* = mlirlite.Int32(pool)
|
||
|
||
# Resolve the member value (all targets in the statement share it; next_val advances once)
|
||
cur_val_a: int64 = 0
|
||
if ag.value is not None: cur_val_a = self._extract_int_value(ag.value)
|
||
else: cur_val_a = next_val
|
||
next_val = cur_val_a + 1
|
||
|
||
# Store per target (non-Name targets are caught by the registration-side fallback check)
|
||
for ti in range(int(tn)):
|
||
t0: ast.AST* = tgts.get(ti)
|
||
if t0 is None or t0.kind() != ast.ASTKind.Name: continue
|
||
tgt_a: ast.Name* = ast.Name*(t0)
|
||
if tgt_a.id is None: continue
|
||
if member_count < ENUM_MEMBER_MAX_LOCAL:
|
||
member_names_buf[member_count] = sizet(tgt_a.id)
|
||
member_types_buf[member_count] = sizet(member_ty_a)
|
||
member_values_buf[member_count] = cur_val_a
|
||
member_count += 1
|
||
|
||
# [fallback check fail-fast] "Visible member names" vs "actually registered members". Any form the
|
||
# registrar does not recognize makes visible > registered, so fail-fast instead of silently dropping.
|
||
visible_count: int = self._enum_body_visible_names(children)
|
||
if visible_count != member_count:
|
||
diff_count: int = visible_count - member_count
|
||
bad: ast.AST* = self._enum_first_unregistered_node(children)
|
||
bad_desc: str = "(cannot locate the specific statement, check the enum body)"
|
||
if bad is not None: bad_desc = bad.type_name()
|
||
self.Gen.TypeGenErr.fatal_error(bad if bad is not None else cd, f"enum '{class_name}' member registration count mismatch: {visible_count} member names visible in source, " f"but only {member_count} registered ({diff_count} difference would be silently dropped). " f"first unrecognized member form: a statement of shape {bad_desc} -- e.g. comma group with value `A, B = 1`, " f"comma group with annotation `A, B: T`, single name with trailing comma `A,`. " f"expected forms: one `Name` / `Name: T` / `Name = value` per line, " f"or multiple simple identifiers separated by commas (`A, B, C`, trailing comma allowed). " f"fix: rewrite that line as one member per line, or as a plain identifier comma group (remove `= value` / `: T`). " f"(this check compares the number of visible names vs registered names at the registrar, so any unrecognized form hits it, " f"no more members are silently dropped)", "TypeError")
|
||
return 0
|
||
|
||
if member_count == 0:
|
||
VLogger.warning(f"{class_name} has no members", "ENUM")
|
||
return 0
|
||
|
||
# Determine the base type: the widest member type in bits
|
||
base_ty: mlirlite.LLVMType* = mlirlite.Int32(pool)
|
||
max_bits: int = 0
|
||
for mi in range(int(member_count)):
|
||
ty_addr: sizet = member_types_buf[mi]
|
||
if ty_addr == 0: continue
|
||
mty: mlirlite.LLVMType* = (mlirlite.LLVMType*)(ty_addr)
|
||
bits: int = self.Gen.TypeGenErr.get_llvm_type_bits(mty)
|
||
if bits > max_bits:
|
||
max_bits = bits
|
||
base_ty = mty
|
||
|
||
# Register the enum
|
||
entry: GenTypes.EnumEntry* = self.Gen.StmtGenDecl.register_enum(pool, class_name, base_ty)
|
||
if entry is None:
|
||
VLogger.error("failed to register {class_name}", "ENUM")
|
||
return 0
|
||
|
||
# Add members
|
||
for mi in range(int(member_count)):
|
||
fname_addr: sizet = member_names_buf[mi]
|
||
if fname_addr == 0: continue
|
||
mname: str = rawptr(fname_addr)
|
||
fty_addr2: sizet = member_types_buf[mi]
|
||
if fty_addr2 == 0: continue
|
||
mty2: mlirlite.LLVMType* = (mlirlite.LLVMType*)(fty_addr2)
|
||
mval: int64 = member_values_buf[mi]
|
||
if mname is not None and mty2 is not None: self.Gen.StmtGenDecl.add_enum_member(pool, entry, mname, mval, mty2)
|
||
|
||
VLogger.info(f"registered {class_name} with {member_count} members, base_bits={max_bits}", "ENUM")
|
||
return 0
|
||
|
||
def _get_type_size(self, ty: mlirlite.LLVMType*) -> int:
|
||
"""Compute the byte size of an LLVM type including alignment padding"""
|
||
if ty is None: return 0
|
||
match ty:
|
||
case mlirlite.LLVMType.Int(bits):
|
||
return (bits + 7) // 8
|
||
case mlirlite.LLVMType.Float(bits):
|
||
return bits // 8
|
||
case mlirlite.LLVMType.Ptr(pointee):
|
||
return 8
|
||
case mlirlite.LLVMType.Array(elem_ty, count):
|
||
return self._get_type_size(elem_ty) * count
|
||
case mlirlite.LLVMType.Struct(fields, fcount, name):
|
||
# Compute the struct size with field-alignment padding: each field's alignment is its
|
||
# natural alignment and the total is padded to the largest field alignment. packed structs have no padding.
|
||
is_packed: int = self.Gen.StructGen.struct_type_is_packed(ty)
|
||
total: int = 0
|
||
max_align: int = 1
|
||
cur: mlirlite.ParamNode* = fields
|
||
i: int = 0
|
||
while cur is not None and i < fcount:
|
||
if cur.Ty is not None:
|
||
fty: mlirlite.LLVMType* = (mlirlite.LLVMType*)(cur.Ty)
|
||
fsize: int = self._get_type_size(fty)
|
||
falign: int = self._get_type_align(fty)
|
||
# Align the current offset to the field boundary (packed inserts no padding)
|
||
if is_packed == 0 and falign > 0:
|
||
rem: int = total % falign
|
||
if rem != 0: total += falign - rem
|
||
total += fsize
|
||
if is_packed == 0 and falign > max_align: max_align = falign
|
||
cur = cur.Next
|
||
i += 1
|
||
# packed has no tail alignment; non-packed totals are padded to the max field alignment
|
||
if is_packed != 0: return total
|
||
rem2: int = total % max_align
|
||
if rem2 != 0: total += max_align - rem2
|
||
return total
|
||
case _:
|
||
return 8
|
||
def _get_type_align(self, ty: mlirlite.LLVMType*) -> int:
|
||
"""Return the natural alignment of a type in bytes"""
|
||
if ty is None: return 1
|
||
match ty:
|
||
case mlirlite.LLVMType.Int(bits):
|
||
if bits <= 8: return 1
|
||
elif bits <= 16: return 2
|
||
elif bits <= 32: return 4
|
||
else: return 8
|
||
case mlirlite.LLVMType.Float(bits):
|
||
if bits <= 32: return 4
|
||
else: return 8
|
||
case mlirlite.LLVMType.Ptr(pointee):
|
||
return 8
|
||
case mlirlite.LLVMType.Array(elem_ty, count):
|
||
return self._get_type_align(elem_ty)
|
||
case mlirlite.LLVMType.Struct(fields, fcount, name):
|
||
# A packed struct is byte-aligned (alignment 1, no padding)
|
||
if self.Gen.StructGen.struct_type_is_packed(ty) != 0: return 1
|
||
# A struct's alignment is the largest field alignment
|
||
max_align: int = 1
|
||
cur: mlirlite.ParamNode* = fields
|
||
i: int = 0
|
||
while cur is not None and i < fcount:
|
||
if cur.Ty is not None:
|
||
fty: mlirlite.LLVMType* = (mlirlite.LLVMType*)(cur.Ty)
|
||
fa: int = self._get_type_align(fty)
|
||
if fa > max_align: max_align = fa
|
||
cur = cur.Next
|
||
i += 1
|
||
return max_align
|
||
case _:
|
||
return 8
|
||
def _translate_union_def(self, trans: HT.Translator*, cd: ast.ClassDef*) -> int:
|
||
"""Translate a union definition, return 0"""
|
||
if cd is None or cd.name is None or trans is None: return 0
|
||
|
||
pool: memhub.MemBuddy* = trans.Pool
|
||
class_name: str = cd.name
|
||
|
||
# Namespace isolation: mark visible in the current file (before the existing check)
|
||
self.Gen.StructGen.add_visible_struct(pool, class_name)
|
||
|
||
# Check whether already registered (SHA1 distinguishes cross-module same-name classes)
|
||
existing: GenTypes.StructEntry* = self.Gen.StructGen.find_struct_by_module(class_name, trans.ModuleSha1)
|
||
if existing is not None:
|
||
# Phase B: register the existing named struct into the current module
|
||
if existing.Ty is not None: mlirlite.module_add_named_type(trans.Module, pool, existing.Ty)
|
||
# SHA1 was already set by register_struct; no need to set it again
|
||
return 0
|
||
|
||
children: list[ast.AST*]* = cd.children
|
||
if children is None:
|
||
VLogger.warning("{class_name} has no body", "UNION")
|
||
return 0
|
||
|
||
cn: sizet = len(children)
|
||
|
||
# Temporary arrays holding field info
|
||
field_names_buf: sizet* = pool.alloc(8 * GenTypes.FIELD_MAX)
|
||
field_types_buf: sizet* = pool.alloc(8 * GenTypes.FIELD_MAX)
|
||
if field_names_buf is None or field_types_buf is None: return 0
|
||
string.memset(field_names_buf, 0, 8 * GenTypes.FIELD_MAX)
|
||
string.memset(field_types_buf, 0, 8 * GenTypes.FIELD_MAX)
|
||
|
||
field_count: int = 0
|
||
max_size: int = 0
|
||
|
||
for ci in range(int(cn)):
|
||
stmt: ast.AST* = children.get(ci)
|
||
if stmt is None: continue
|
||
sk: int = stmt.kind()
|
||
|
||
if sk == ast.ASTKind.AnnAssign:
|
||
aa: ast.AnnAssign* = ast.AnnAssign*(stmt)
|
||
if aa is None or aa.target is None: continue
|
||
|
||
# Get the field name
|
||
if aa.target.kind() != ast.ASTKind.Name: continue
|
||
tgt: ast.Name* = ast.Name*(aa.target)
|
||
if tgt.id is None: continue
|
||
|
||
# Resolve the field type
|
||
field_ty: mlirlite.LLVMType* = self.Gen.TypeGenResolve.resolve_annotation_type(pool, aa.annotation, trans._imported_modules, trans._from_imports, trans, 0)
|
||
if field_ty is None:
|
||
# Phase A-pre (declare_only=1): a dependency class may not be registered yet;
|
||
# return 1 so multi-pass convergence kicks in (renum returns 1 = skip this class)
|
||
if trans._declare_only == 1: return 1
|
||
# Phase B (declare_only=0): a real type resolution error; fail-fast
|
||
type_name: str = self.Gen.TypeGenResolve.annotation_to_str(aa.annotation)
|
||
self.Gen.TypeGenErr.fatal_error(aa, f"'{type_name}' is not defined", "NameError")
|
||
field_ty = mlirlite.Int32(pool)
|
||
|
||
# Compute the field size and update max_size
|
||
fsize: int = self._get_type_size(field_ty)
|
||
if fsize > max_size: max_size = fsize
|
||
|
||
# Store into the array
|
||
if field_count < GenTypes.FIELD_MAX:
|
||
field_names_buf[field_count] = sizet(tgt.id)
|
||
field_types_buf[field_count] = sizet(field_ty)
|
||
field_count += 1
|
||
|
||
if field_count == 0:
|
||
VLogger.warning(f"{class_name} has no fields", "UNION")
|
||
return 0
|
||
|
||
if max_size < 1: max_size = 1
|
||
|
||
# Create the union's LLVM type: Struct([Array(Int8, max_size)]), i.e. { [max_size x i8] }
|
||
i8_ty: mlirlite.LLVMType* = mlirlite.Int8(pool)
|
||
array_ty: mlirlite.LLVMType* = mlirlite.Array(pool, i8_ty, max_size)
|
||
|
||
# Build the ParamNode list (single field: byte array)
|
||
pnode: mlirlite.ParamNode* = pool.alloc(mlirlite.ParamNode.__sizeof__())
|
||
if pnode is None: return 0
|
||
string.memset(pnode, 0, mlirlite.ParamNode.__sizeof__())
|
||
pnode.Ty = array_ty
|
||
|
||
# Build the named struct type name: "sha1.ClassName" or "ClassName"
|
||
union_type_name: str = class_name
|
||
if trans.ModuleSha1 is not None:
|
||
union_name_buf: str = pool.alloc(64)
|
||
if union_name_buf is not None:
|
||
viperlib.snprintf(union_name_buf, 64, "%s.%s", trans.ModuleSha1, class_name)
|
||
union_type_name = union_name_buf
|
||
|
||
union_ty: mlirlite.LLVMType* = mlirlite.Struct(pool, pnode, 1, union_type_name)
|
||
if union_ty is None:
|
||
VLogger.error(f"failed to create type for {class_name}", "UNION")
|
||
return 0
|
||
|
||
# Deep-copy the newly registered union struct_ty to stdlib (survives cross-file reset).
|
||
# Needed even under StdlibAlloc=1 (after Phase2 mark2): else reset_to(mark2) leaves entry.Ty dangling.
|
||
if trans._declare_only == 0 or self.Gen.StructGen.get_stdlib_alloc() != 0:
|
||
union_copy: mlirlite.LLVMType* = mlirlite.DeepCopyType(CompilerFactory.factory.PermPool, union_ty)
|
||
if union_copy is not None: union_ty = union_copy
|
||
|
||
# Register the named struct into the module
|
||
mlirlite.module_add_named_type(trans.Module, pool, union_ty)
|
||
|
||
# Register into HandlesStruct (SHA1 is set directly at registration to avoid picking the wrong entry)
|
||
entry: GenTypes.StructEntry* = self.Gen.StructGen.register_struct(pool, class_name, union_ty, trans.ModuleSha1)
|
||
if entry is None:
|
||
VLogger.error(f"failed to register {class_name}", "UNION")
|
||
return 0
|
||
|
||
# Mark visible in the current file (namespace isolation)
|
||
self.Gen.StructGen.add_visible_struct(pool, class_name)
|
||
|
||
# Mark as a union (using entry directly to avoid cross-module same-name lookup errors)
|
||
entry.IsUnion = 1
|
||
|
||
# Add field info (all fields have Index=0 because they share offset 0)
|
||
for fi in range(int(field_count)):
|
||
fname_addr: sizet = field_names_buf[fi]
|
||
if fname_addr == 0: continue
|
||
fname: str = rawptr(fname_addr)
|
||
fty_addr2: sizet = field_types_buf[fi]
|
||
if fty_addr2 == 0: continue
|
||
fty2: mlirlite.LLVMType* = (mlirlite.LLVMType*)(fty_addr2)
|
||
if fname is not None and fty2 is not None: self.Gen.StructGen.add_field(pool, entry, fname, fty2, None, None)
|
||
|
||
VLogger.info(f"registered {class_name} with {field_count} fields, max_size={max_size}", "UNION")
|
||
return 0
|
||
def _get_annotation_field_size(self, pool: memhub.MemBuddy*, annotation: ast.AST*) -> int:
|
||
"""Compute the annotation type's byte size for REnum layout"""
|
||
if annotation is None: return 8
|
||
k: int = annotation.kind()
|
||
# Union type A | B -> pointer size 8
|
||
if k == ast.ASTKind.BinOp: return 8
|
||
# Name(id) or Attribute(attr) -> resolve the type name
|
||
type_name: str = None
|
||
if k == ast.ASTKind.Name:
|
||
nm: ast.Name* = ast.Name*(annotation)
|
||
if nm is not None: type_name = nm.id
|
||
elif k == ast.ASTKind.Attribute:
|
||
at: ast.Attribute* = ast.Attribute*(annotation)
|
||
if at is not None: type_name = at.attr
|
||
if type_name is None: return 8
|
||
# [stage 3] Unified sizing: library typedefs (BYTE/DWORD etc.) resolve through normal library
|
||
# analysis; the hardcoded size table below is only a fallback for t/c core primitives.
|
||
dyn_sz: int = self.Gen.TypeGenResolve.get_type_size_bytes(pool, type_name, None, None)
|
||
if dyn_sz > 0: return dyn_sz
|
||
# Builtin short names
|
||
if string.strcmp(type_name, "sizet") == 0 or string.strcmp(type_name, "size_t") == 0: return 8
|
||
if string.strcmp(type_name, "int8") == 0 or string.strcmp(type_name, "uint8") == 0: return 1
|
||
if string.strcmp(type_name, "uchar") == 0: return 1
|
||
if string.strcmp(type_name, "int16") == 0 or string.strcmp(type_name, "uint16") == 0: return 2
|
||
if string.strcmp(type_name, "short") == 0 or string.strcmp(type_name, "ushort") == 0: return 2
|
||
if string.strcmp(type_name, "int32") == 0 or string.strcmp(type_name, "uint32") == 0: return 4
|
||
if string.strcmp(type_name, "int") == 0 or string.strcmp(type_name, "uint") == 0: return 4
|
||
if string.strcmp(type_name, "long") == 0 or string.strcmp(type_name, "ulong") == 0: return 4
|
||
if string.strcmp(type_name, "int64") == 0 or string.strcmp(type_name, "uint64") == 0: return 8
|
||
if string.strcmp(type_name, "longlong") == 0 or string.strcmp(type_name, "ulonglong") == 0: return 8
|
||
if string.strcmp(type_name, "ptrdifft") == 0: return 8
|
||
# Builtin types
|
||
if string.strcmp(type_name, "int") == 0: return 4
|
||
if string.strcmp(type_name, "CInt") == 0: return 4
|
||
if string.strcmp(type_name, "CInt8T") == 0: return 1
|
||
if string.strcmp(type_name, "CInt16T") == 0: return 2
|
||
if string.strcmp(type_name, "CInt32T") == 0: return 4
|
||
if string.strcmp(type_name, "CInt64T") == 0: return 8
|
||
if string.strcmp(type_name, "CChar") == 0: return 1
|
||
if string.strcmp(type_name, "CDouble") == 0: return 8
|
||
if string.strcmp(type_name, "CFloat") == 0: return 4
|
||
if string.strcmp(type_name, "CPtr") == 0: return 8
|
||
if string.strcmp(type_name, "CSizeT") == 0: return 8
|
||
if string.strcmp(type_name, "str") == 0: return 8
|
||
if string.strcmp(type_name, "bytes") == 0: return 8
|
||
if string.strcmp(type_name, "bool") == 0: return 1
|
||
# Registered struct type
|
||
struct_ty: mlirlite.LLVMType* = self.Gen.StructGen.get_struct_type(type_name)
|
||
if struct_ty is not None:
|
||
sz: int = self._get_type_size(struct_ty)
|
||
if sz > 0: return sz
|
||
# Unregistered type -> default pointer size 8 (may be self- or forward-referenced)
|
||
return 8
|
||
def _translate_renum_def(self, trans: HT.Translator*, cd: ast.ClassDef*) -> int:
|
||
"""Translate an REnum class definition, return 0"""
|
||
if cd is None or cd.name is None or trans is None: return 0
|
||
|
||
pool: memhub.MemBuddy* = trans.Pool
|
||
class_name: str = cd.name
|
||
|
||
# Namespace isolation: mark visible in the current file
|
||
self.Gen.StructGen.add_visible_struct(pool, class_name)
|
||
|
||
# Check whether already registered (SHA1 distinguishes cross-module same-name classes)
|
||
existing: GenTypes.StructEntry* = self.Gen.StructGen.find_struct_by_module(class_name, trans.ModuleSha1)
|
||
if existing is not None:
|
||
# existing only guarantees the struct entry, not the REnum semantics (variant table): the entry
|
||
# lives in StructTable across phases, but the variant table is a per-Generator field reset each time.
|
||
if self._is_renum_class_name(class_name) != 0:
|
||
if existing.Ty is not None: mlirlite.module_add_named_type(trans.Module, pool, existing.Ty)
|
||
return 0
|
||
# Variant table missing: neutralize the old entry so find_struct_by_module no longer matches,
|
||
# then fall through to full registration to fix both the layout and the variant table.
|
||
if existing.Name is not None: existing.Name[0] = '\0'
|
||
existing.Ty = None
|
||
existing.FieldCount = 0
|
||
|
||
children: list[ast.AST*]* = cd.children
|
||
if children is None:
|
||
# [D32 fail-fast] Previously only warned and returned: the variant table was silently unregistered,
|
||
# so _is_renum_class_name stayed 0 and variant construction lost its tag. No silent skip here.
|
||
self.Gen.TypeGenErr.fatal_error(cd, f"REnum class '{class_name}' has no class body (children is None), cannot register the variant table", "TypeError")
|
||
return 0
|
||
|
||
cn: sizet = len(children)
|
||
|
||
# At most 32 variants per class, 16 fields per variant; variant_field_sizes[i][j] = variant i's field j size.
|
||
variant_field_sizes: sizet* = pool.alloc(8 * 64 * 16)
|
||
if variant_field_sizes is None: return 0
|
||
string.memset(variant_field_sizes, 0, 8 * 64 * 16)
|
||
|
||
variant_count: int = 0
|
||
max_field_count: int = 0 # max field count across all variants
|
||
|
||
for ci in range(int(cn)):
|
||
stmt: ast.AST* = children.get(ci)
|
||
if stmt is None: continue
|
||
sk: int = stmt.kind()
|
||
|
||
if sk == ast.ASTKind.ClassDef:
|
||
# Nested variant class
|
||
variant_cd: ast.ClassDef* = ast.ClassDef*(stmt)
|
||
if variant_cd is None or variant_cd.children is None:
|
||
variant_count += 1
|
||
continue
|
||
variant_children: list[ast.AST*]* = variant_cd.children
|
||
vcn: sizet = len(variant_children)
|
||
field_idx: int = 0
|
||
for vi in range(int(vcn)):
|
||
vstmt: ast.AST* = variant_children.get(vi)
|
||
if vstmt is None: continue
|
||
vk: int = vstmt.kind()
|
||
if vk != ast.ASTKind.AnnAssign: continue
|
||
vaa: ast.AnnAssign* = ast.AnnAssign*(vstmt)
|
||
if vaa is None or vaa.target is None or vaa.annotation is None: continue
|
||
if vaa.target.kind() != ast.ASTKind.Name: continue
|
||
# Extract the field name
|
||
vnm: ast.Name* = ast.Name*(vaa.target)
|
||
# Compute the field size
|
||
fsize: int = self._get_annotation_field_size(pool, vaa.annotation)
|
||
if variant_count < 32 and field_idx < 16:
|
||
# variant_field_sizes[variant_count][field_idx] = fsize
|
||
offset: sizet = variant_count * 16 + field_idx
|
||
variant_field_sizes[offset] = sizet(fsize)
|
||
# Register the variant field-name alias directly, resolving its actual type for match
|
||
# binding. Self-referencing annotations fail to resolve here and fall back to the slot type.
|
||
if vnm is not None and vnm.id is not None:
|
||
mem_ty_l: mlirlite.LLVMType* = None
|
||
if trans is not None: mem_ty_l = self.Gen.TypeGenResolve.resolve_annotation_type(pool, vaa.annotation, trans._imported_modules, trans._from_imports, trans, 0)
|
||
self._register_renum_field_alias(pool, class_name, vnm.id, field_idx + 1, mem_ty_l, variant_cd.name)
|
||
field_idx += 1
|
||
if field_idx > max_field_count: max_field_count = field_idx
|
||
variant_count += 1
|
||
elif sk == ast.ASTKind.Assign:
|
||
# Assign-form payload-less variants (e.g. `Empty = 1`): same rule as TPC, still a variant (occupies
|
||
# a slot) with no fields. Tags are assigned by _register_renum_variants (explicit values first).
|
||
ag_v: ast.Assign* = ast.Assign*(stmt)
|
||
if ag_v is None or ag_v.targets is None: continue
|
||
tgts_v: list[ast.AST*]* = ag_v.targets
|
||
if len(tgts_v) == 0: continue
|
||
t0_v: ast.AST* = tgts_v.get(0)
|
||
if t0_v is None or t0_v.kind() != ast.ASTKind.Name: continue
|
||
tgt_v: ast.Name* = ast.Name*(t0_v)
|
||
if tgt_v.id is None: continue
|
||
variant_count += 1
|
||
|
||
if variant_count == 0:
|
||
# [D32 fail-fast] Same as above: variant_count 0 previously returned silently, skipping registration.
|
||
# For `class X(t.REnum)` the count must be > 0; 0 means the AST variant classes were lost.
|
||
self.Gen.TypeGenErr.fatal_error(cd, f"REnum class '{class_name}' has 0 variants (nested variant classes lost), cannot register the variant table", "TypeError")
|
||
return 0
|
||
|
||
# Compute the max field size for each position.
|
||
# Position 0 = __tag (i32, 4 bytes); positions 1+ = variant fields.
|
||
total_positions: int = max_field_count + 1 # +1 for tag
|
||
if total_positions < 2:
|
||
total_positions = 2 # at least {i32, i32}
|
||
|
||
position_max_sizes: sizet* = pool.alloc(8 * total_positions)
|
||
if position_max_sizes is None: return 0
|
||
string.memset(position_max_sizes, 0, 8 * total_positions)
|
||
|
||
# Position 0 = tag = 4 bytes
|
||
position_max_sizes[0] = sizet(4)
|
||
|
||
# Positions 1+: take the max field size across all variants at each position
|
||
for pos in range(1, int(total_positions)):
|
||
pos_max: sizet = 0
|
||
for vi in range(int(variant_count)):
|
||
if vi >= 64:
|
||
break # variant_field_sizes 64-class slot cap; guards against out-of-bounds reads
|
||
field_pos: int = pos - 1 # variant fields start at position 0
|
||
if field_pos >= 16:
|
||
continue # beyond the 16-field-per-variant cap: not written (memset 0), skip
|
||
offset2: sizet = vi * 16 + field_pos
|
||
fsize_val: sizet = variant_field_sizes[offset2]
|
||
if fsize_val > pos_max: pos_max = fsize_val
|
||
position_max_sizes[pos] = sizet(pos_max)
|
||
|
||
# Build the ParamNode list
|
||
i32_ty: mlirlite.LLVMType* = mlirlite.Int32(pool)
|
||
i64_ty: mlirlite.LLVMType* = mlirlite.Int64(pool)
|
||
|
||
first_node: mlirlite.ParamNode* = None
|
||
tail_node: mlirlite.ParamNode* = None
|
||
|
||
for pos in range(int(total_positions)):
|
||
psize: int = int(position_max_sizes[pos])
|
||
field_ty: mlirlite.LLVMType* = i32_ty
|
||
if psize > 4: field_ty = i64_ty
|
||
pnode: mlirlite.ParamNode* = mlirlite.new_param_node(pool, field_ty)
|
||
if pnode is None: continue
|
||
tail_node = mlirlite.param_list_append(first_node, tail_node, pnode)
|
||
if first_node is None: first_node = tail_node
|
||
|
||
if first_node is None:
|
||
VLogger.error(f"failed to build field list for {class_name}", "RENUM")
|
||
return 0
|
||
|
||
# Build the named struct type name: "sha1.ClassName" or "ClassName"
|
||
renum_type_name: str = class_name
|
||
if trans.ModuleSha1 is not None:
|
||
renum_name_buf: str = pool.alloc(64)
|
||
if renum_name_buf is not None:
|
||
viperlib.snprintf(renum_name_buf, 64, "%s.%s", trans.ModuleSha1, class_name)
|
||
renum_type_name = renum_name_buf
|
||
|
||
renum_ty: mlirlite.LLVMType* = mlirlite.Struct(pool, first_node, total_positions, renum_type_name)
|
||
if renum_ty is None:
|
||
VLogger.error(f"failed to create type for {class_name}", "RENUM")
|
||
return 0
|
||
|
||
# Deep-copy the newly registered REnum struct_ty to stdlib (survives cross-file reset and keeps the
|
||
# same pointer as entry.Ty so find_struct_by_type still matches); required under StdlibAlloc=1 too.
|
||
if trans._declare_only == 0 or self.Gen.StructGen.get_stdlib_alloc() != 0:
|
||
renum_copy: mlirlite.LLVMType* = mlirlite.DeepCopyType(CompilerFactory.factory.PermPool, renum_ty)
|
||
if renum_copy is not None: renum_ty = renum_copy
|
||
|
||
# Register the named struct into the module
|
||
mlirlite.module_add_named_type(trans.Module, pool, renum_ty)
|
||
|
||
# Register into HandlesStruct.
|
||
# A forward-declared placeholder for THIS class may have been created *during the variant walk*
|
||
# above: a variant field like `Pointee: LLVMType*` is `BinOp(LLVMType | rawptr)` (parser's
|
||
# _make_ptr_type expands the C-style suffix into a union, NOT into `rawptr[...]`), so resolving it
|
||
# resolves the class name and calls ensure_forward_class. register_struct de-duplicates by Ty
|
||
# pointer, so it would add a SECOND same-named entry and get_struct_type/find_struct (first match
|
||
# wins) would keep returning the opaque placeholder -> __sizeof__() == 0 at the first use
|
||
# ("registered but size 0, field chain unfilled"). Fill the placeholder in place instead, which is
|
||
# exactly what ensure_forward_class documents ("the definition side fills the same Ty in place").
|
||
entry: GenTypes.StructEntry* = self.Gen.StructGen.find_struct_by_module(class_name, trans.ModuleSha1)
|
||
if entry is not None and entry.IsForwardDecl != 0:
|
||
entry.Ty = renum_ty
|
||
entry.IsForwardDecl = 0
|
||
else:
|
||
entry = self.Gen.StructGen.register_struct(pool, class_name, renum_ty, trans.ModuleSha1)
|
||
if entry is None:
|
||
VLogger.error(f"failed to register {class_name}", "RENUM")
|
||
return 0
|
||
|
||
# Add the __tag field (position 0, i32)
|
||
self.Gen.StructGen.add_field(pool, entry, "__tag", i32_ty, None, None)
|
||
|
||
# Add payload fields (positions 1+, i32 or i64)
|
||
for pos in range(1, int(total_positions)):
|
||
psize2: int = int(position_max_sizes[pos])
|
||
payload_ty: mlirlite.LLVMType* = i32_ty
|
||
if psize2 > 4: payload_ty = i64_ty
|
||
field_name_buf: str = pool.alloc(16)
|
||
if field_name_buf is not None:
|
||
viperlib.snprintf(field_name_buf, 16, "_p%d", pos)
|
||
self.Gen.StructGen.add_field(pool, entry, field_name_buf, payload_ty, None, None)
|
||
|
||
# Register variant names into the global variant table (translate_call detects REnum construction)
|
||
self._register_renum_variants(pool, class_name, cd, variant_count)
|
||
|
||
# Variant field-name aliases were registered during the variant walk, which runs before register_struct;
|
||
# self-referencing annotations left a 0 type slot, so refill it now (see _refill_renum_field_types).
|
||
self._refill_renum_field_types(trans, pool, class_name, cd)
|
||
|
||
VLogger.info(f"registered {class_name} with {variant_count} variants, {total_positions} positions", "RENUM")
|
||
return 0
|
||
def _refill_renum_field_types(self, trans: HT.Translator*, pool: memhub.MemBuddy*, class_name: str, cd: ast.ClassDef*):
|
||
"""After REnum registration, re-resolve variant field types and backfill only aliases whose type slot is still 0."""
|
||
if trans is None or pool is None or class_name is None or cd is None: return
|
||
children: list[ast.AST*]* = cd.children
|
||
if children is None: return
|
||
cn: sizet = len(children)
|
||
for ci in range(int(cn)):
|
||
stmt: ast.AST* = children.get(ci)
|
||
if stmt is None or stmt.kind() != ast.ASTKind.ClassDef: continue
|
||
variant_cd: ast.ClassDef* = ast.ClassDef*(stmt)
|
||
if variant_cd is None or variant_cd.name is None or variant_cd.children is None: continue
|
||
vchildren: list[ast.AST*]* = variant_cd.children
|
||
vcn: sizet = len(vchildren)
|
||
field_idx: int = 0
|
||
for vi in range(int(vcn)):
|
||
vstmt: ast.AST* = vchildren.get(vi)
|
||
if vstmt is None: continue
|
||
if vstmt.kind() != ast.ASTKind.AnnAssign: continue
|
||
vaa: ast.AnnAssign* = ast.AnnAssign*(vstmt)
|
||
if vaa is None or vaa.target is None or vaa.annotation is None:
|
||
# Same rule as the first pass: an invalid AnnAssign does not occupy a payload slot
|
||
continue
|
||
if vaa.target.kind() != ast.ASTKind.Name: continue
|
||
vnm: ast.Name* = ast.Name*(vaa.target)
|
||
if vnm.id is None:
|
||
# Same rule as the first pass: a valid AnnAssign still occupies a payload slot
|
||
field_idx += 1
|
||
continue
|
||
mem_ty_l: mlirlite.LLVMType* = self.Gen.TypeGenResolve.resolve_annotation_type(pool, vaa.annotation, trans._imported_modules, trans._from_imports, trans, 0)
|
||
# Resolved -> trigger the alias dedupe path (backfill when the type slot is 0; skip a non-zero slot)
|
||
if mem_ty_l is not None: self._register_renum_field_alias(pool, class_name, vnm.id, field_idx + 1, mem_ty_l, variant_cd.name)
|
||
field_idx += 1
|
||
def _register_renum_variants(self, pool: memhub.MemBuddy*, class_name: str, cd: ast.ClassDef*, variant_count: int):
|
||
"""Register an REnum class's variant names and tag values into the global table"""
|
||
if pool is None or class_name is None or cd is None: return
|
||
if variant_count == 0: return
|
||
children: list[ast.AST*]* = cd.children
|
||
if children is None: return
|
||
|
||
# Lazily initialize the tables on first registration. They must be stdlib-allocated: if pool-allocated
|
||
# they would be reclaimed by reset_to(mark1) and later matches would read freed memory and crash.
|
||
if self.RenumClassNames is None:
|
||
self.RenumClassNames = CompilerFactory.factory.PermPool.alloc(8 * RENUM_CLASS_MAX)
|
||
self.RenumClassVariantCounts = CompilerFactory.factory.PermPool.alloc(8 * RENUM_CLASS_MAX)
|
||
self.RenumVariantNames = CompilerFactory.factory.PermPool.alloc(8 * RENUM_CLASS_MAX * RENUM_VARIANT_PER_CLASS)
|
||
self.RenumVariantTags = CompilerFactory.factory.PermPool.alloc(8 * RENUM_CLASS_MAX * RENUM_VARIANT_PER_CLASS)
|
||
if (self.RenumClassNames is None or self.RenumClassVariantCounts is None or self.RenumVariantNames is None or self.RenumVariantTags is None):
|
||
# A None table means the perm-pool request failed; returning here left the table empty while the
|
||
# caller still reported "registered", so every REnum case in match dispatch was silently lost.
|
||
self.RenumClassNames = None
|
||
self.Gen.TypeGenErr.fatal_error(cd, f"failed to allocate REnum variant table (class='{class_name}'): PermPool returned NULL, variant table unavailable", "InternalCompilerError")
|
||
return
|
||
string.memset(self.RenumClassNames, 0, 8 * RENUM_CLASS_MAX)
|
||
string.memset(self.RenumClassVariantCounts, 0, 8 * RENUM_CLASS_MAX)
|
||
string.memset(self.RenumVariantNames, 0, 8 * RENUM_CLASS_MAX * RENUM_VARIANT_PER_CLASS)
|
||
string.memset(self.RenumVariantTags, 0, 8 * RENUM_CLASS_MAX * RENUM_VARIANT_PER_CLASS)
|
||
self.RenumClassCount = 0
|
||
# [D30] Register the pointers into the compile-time factory singleton (same lifetime as struct
|
||
# entries); InitClassGen restores them for new Generators instead of zeroing them.
|
||
CompilerFactory.factory.RenumClassNames = self.RenumClassNames
|
||
CompilerFactory.factory.RenumClassVariantCounts = self.RenumClassVariantCounts
|
||
CompilerFactory.factory.RenumVariantNames = self.RenumVariantNames
|
||
CompilerFactory.factory.RenumVariantTags = self.RenumVariantTags
|
||
CompilerFactory.factory.RenumClassCount = self.RenumClassCount
|
||
|
||
#rcv_chk: uint64 = uint64(self.RenumClassVariantCounts)
|
||
# VLogger.error(f"[RENUM-FAIL] RCV={rcv_chk} abnormal (perm_pool address expected after lazy init)", "RENUM")
|
||
|
||
# Check whether already registered (avoid duplicate registration)
|
||
for i in range(int(self.RenumClassCount)):
|
||
existing: str = str(self.RenumClassNames[i])
|
||
if existing is not None and string.strcmp(existing, class_name) == 0: return
|
||
|
||
# Table full
|
||
if self.RenumClassCount >= RENUM_CLASS_MAX:
|
||
# Silently dropping the class made its later `match` lose every case; a
|
||
# real limit breach must be reported instead.
|
||
self.Gen.TypeGenErr.fatal_error(cd, f"REnum class count exceeds the limit {RENUM_CLASS_MAX}: cannot register class='{class_name}'", "InternalCompilerError")
|
||
return
|
||
|
||
# Register the class name (strcpy into perm_pool: after each file's 1a reset the AST raw pointer
|
||
# dangles, and strcmp in _lookup_renum_variant/_is_renum_class_name would read poisoned memory).
|
||
idx: int = self.RenumClassCount
|
||
cn_len_rv: sizet = string.strlen(class_name)
|
||
cn_buf_rv: str = CompilerFactory.factory.PermPool.alloc(cn_len_rv + 1)
|
||
if cn_buf_rv is None:
|
||
self.Gen.TypeGenErr.fatal_error(cd, f"failed to allocate REnum class name copy (class='{class_name}'): PermPool returned NULL", "InternalCompilerError")
|
||
return
|
||
string.strcpy(cn_buf_rv, class_name)
|
||
self.RenumClassNames[idx] = sizet(cn_buf_rv)
|
||
self.RenumClassVariantCounts[idx] = variant_count
|
||
|
||
# Walk children and register variant names + tags. Two forms: `class Some: ...` (payload variant,
|
||
# tags numbered from max(explicit)+1) and `Empty = 1` (payload-less, tag = explicit integer value).
|
||
cn: sizet = len(children)
|
||
# First pass: find the upper bound of Assign variants' explicit integer values (stays -1 if none)
|
||
max_explicit: int = -1
|
||
for ci in range(int(cn)):
|
||
stmt_p: ast.AST* = children.get(ci)
|
||
if stmt_p is None or stmt_p.kind() != ast.ASTKind.Assign: continue
|
||
ag_p: ast.Assign* = ast.Assign*(stmt_p)
|
||
if ag_p is None or ag_p.targets is None or ag_p.value is None: continue
|
||
tgts_p: list[ast.AST*]* = ag_p.targets
|
||
if len(tgts_p) == 0: continue
|
||
t0_p: ast.AST* = tgts_p.get(0)
|
||
if t0_p is None or t0_p.kind() != ast.ASTKind.Name: continue
|
||
if ag_p.value.kind() != ast.ASTKind.Constant: continue
|
||
ev_v: int = int(self._extract_int_value(ag_p.value))
|
||
if ev_v > max_explicit: max_explicit = ev_v
|
||
|
||
# Second pass: write the table in declaration order. slot is the contiguous table index (0..count-1),
|
||
# while the cell stores the tag; they are no longer equal, so a single counter cannot serve both.
|
||
slot: int = 0
|
||
next_class_tag: int = max_explicit + 1
|
||
variant_index: int = 0
|
||
for ci in range(int(cn)):
|
||
if slot >= variant_count: break
|
||
if slot >= RENUM_VARIANT_PER_CLASS:
|
||
# Fixed 32 slots per class: exceeding it would overflow into the next class's slots; report fail-fast
|
||
VLogger.error(f"REnum variant count exceeds the limit {RENUM_VARIANT_PER_CLASS}: {class_name}", "RENUM")
|
||
break
|
||
stmt: ast.AST* = children.get(ci)
|
||
if stmt is None: continue
|
||
sk_rv: int = stmt.kind()
|
||
vname_ptr: sizet = 0
|
||
tag_val: int = 0
|
||
if sk_rv == ast.ASTKind.ClassDef:
|
||
vcd: ast.ClassDef* = ast.ClassDef*(stmt)
|
||
if vcd is None or vcd.name is None: continue
|
||
vname_ptr = sizet(vcd.name)
|
||
tag_val = next_class_tag
|
||
next_class_tag += 1
|
||
elif sk_rv == ast.ASTKind.Assign:
|
||
# Assign-form payload-less variant (same filter as _translate_renum_def's first pass)
|
||
ag_rv: ast.Assign* = ast.Assign*(stmt)
|
||
if ag_rv is None or ag_rv.targets is None: continue
|
||
tgts_rv: list[ast.AST*]* = ag_rv.targets
|
||
if len(tgts_rv) == 0: continue
|
||
t0_rv: ast.AST* = tgts_rv.get(0)
|
||
if t0_rv is None or t0_rv.kind() != ast.ASTKind.Name: continue
|
||
tgt_rv: ast.Name* = ast.Name*(t0_rv)
|
||
if tgt_rv.id is None: continue
|
||
vname_ptr = sizet(tgt_rv.id)
|
||
if ag_rv.value is not None and ag_rv.value.kind() == ast.ASTKind.Constant: tag_val = int(self._extract_int_value(ag_rv.value))
|
||
else:
|
||
# No explicit value: use a separate counter (distinct from the class-variant counter, as
|
||
# TPC's variant_index) so it cannot collide with next_class_tag.
|
||
tag_val = variant_index
|
||
variant_index += 1
|
||
else: continue
|
||
name_offset: sizet = idx * RENUM_VARIANT_PER_CLASS + slot
|
||
# The variant name is also strcpy'd into perm_pool (the AST name dangles after each file's 1a reset)
|
||
vname_src: str = str(vname_ptr)
|
||
vn_len_rv: sizet = string.strlen(vname_src)
|
||
vn_buf_rv: str = CompilerFactory.factory.PermPool.alloc(vn_len_rv + 1)
|
||
if vn_buf_rv is None:
|
||
# Breaking here registered a partial variant table: the class would
|
||
# keep some variants and silently lose every later one.
|
||
self.Gen.TypeGenErr.fatal_error(cd, f"failed to allocate REnum variant name copy (class='{class_name}'): PermPool returned NULL", "InternalCompilerError")
|
||
break
|
||
string.strcpy(vn_buf_rv, vname_src)
|
||
self.RenumVariantNames[name_offset] = sizet(vn_buf_rv)
|
||
self.RenumVariantTags[name_offset] = tag_val
|
||
slot += 1
|
||
|
||
self.RenumClassCount = idx + 1
|
||
# [D30] Write the count back to the factory singleton (new Generators restore from it; otherwise they
|
||
# would see a stale count and miss subsequently registered variants).
|
||
CompilerFactory.factory.RenumClassCount = self.RenumClassCount
|
||
def _lookup_renum_variant(self, variant_name: str) -> str:
|
||
"""Find the REnum class name owning a variant name; None if absent"""
|
||
if variant_name is None or self.RenumClassNames is None: return None
|
||
|
||
for i in range(int(self.RenumClassCount)):
|
||
vcount: int = int(self.RenumClassVariantCounts[i])
|
||
for j in range(int(vcount)):
|
||
name_offset: sizet = i * RENUM_VARIANT_PER_CLASS + j
|
||
vname: str = str(self.RenumVariantNames[name_offset])
|
||
if vname is not None and string.strcmp(vname, variant_name) == 0:
|
||
cls_nm: str = str(self.RenumClassNames[i])
|
||
return cls_nm
|
||
return None
|
||
def RenumTableDump(self) -> str:
|
||
"""Diagnostic variant-table summary to tell 'class never registered' from 'class present but variant missing'."""
|
||
buf: str = CompilerFactory.factory.PermPool.alloc(256)
|
||
if buf is None: return "-"
|
||
buf[0] = '\0'
|
||
cls_first: str = "-"
|
||
v_first: str = "-"
|
||
n_first_v: int = 0
|
||
if self.RenumClassNames is not None and self.RenumClassCount > 0:
|
||
cls_first = str(self.RenumClassNames[0])
|
||
if self.RenumVariantNames is not None and self.RenumClassVariantCounts is not None:
|
||
n_first_v = int(self.RenumClassVariantCounts[0])
|
||
if n_first_v > 0: v_first = str(self.RenumVariantNames[0])
|
||
viperlib.snprintf(buf, 256, "count=%d first=%s vcount=%d vfirst=%s", self.RenumClassCount, cls_first, n_first_v, v_first)
|
||
return buf
|
||
|
||
def _is_renum_by_entry(self, class_name: str) -> int:
|
||
"""Variant-table-free REnum test: a struct definition carrying a `__tag` field is an REnum, so match dispatch keeps variant bindings even if the table is missing."""
|
||
if class_name is None: return 0
|
||
st: mlirlite.LLVMType* = self.Gen.StructGen.get_struct_type(class_name)
|
||
if st is None: return 0
|
||
if self.Gen.StructGen.lookup_field(st, "__tag") is None: return 0
|
||
return 1
|
||
|
||
def _is_renum_class_name(self, class_name: str) -> int:
|
||
"""Check whether a name is a registered REnum class, 1=yes / 0=no"""
|
||
if class_name is None or self.RenumClassNames is None: return 0
|
||
for i in range(int(self.RenumClassCount)):
|
||
existing: str = str(self.RenumClassNames[i])
|
||
if existing is not None and string.strcmp(existing, class_name) == 0: return 1
|
||
return 0
|
||
def _lookup_renum_variant_in_class(self, class_name: str, variant_name: str) -> int:
|
||
"""Find a variant in a given REnum class, return its tag value or -1"""
|
||
if class_name is None or variant_name is None or self.RenumClassNames is None: return -1
|
||
for i in range(int(self.RenumClassCount)):
|
||
existing: str = str(self.RenumClassNames[i])
|
||
if existing is None or string.strcmp(existing, class_name) != 0: continue
|
||
vcount: int = int(self.RenumClassVariantCounts[i])
|
||
for j in range(int(vcount)):
|
||
name_offset: sizet = i * RENUM_VARIANT_PER_CLASS + j
|
||
vname: str = str(self.RenumVariantNames[name_offset])
|
||
if vname is not None and string.strcmp(vname, variant_name) == 0: return int(self.RenumVariantTags[name_offset])
|
||
return -1
|
||
return -1
|
||
def _register_renum_field_alias(self, pool: memhub.MemBuddy*, class_name: str, field_name: str, payload_idx: int, field_ty: mlirlite.LLVMType* = None, variant_name: str = None):
|
||
"""Register an REnum variant field name alias in the global table; optional field type and variant name aid match binding."""
|
||
if pool is None or class_name is None or field_name is None: return
|
||
if payload_idx < 1: return
|
||
|
||
# Lazily initialize the tables (perm_pool: the tables themselves survive each file's 1a reset)
|
||
if self.RenumAliasClass is None:
|
||
alias_pool_rfa: memhub.MemBuddy* = CompilerFactory.factory.PermPool
|
||
self.RenumAliasClass = alias_pool_rfa.alloc(8 * RENUM_ALIAS_MAX)
|
||
self.RenumAliasField = alias_pool_rfa.alloc(8 * RENUM_ALIAS_MAX)
|
||
self.RenumAliasIndex = alias_pool_rfa.alloc(8 * RENUM_ALIAS_MAX)
|
||
self.RenumAliasTy = alias_pool_rfa.alloc(8 * RENUM_ALIAS_MAX)
|
||
self.RenumAliasVariant = alias_pool_rfa.alloc(8 * RENUM_ALIAS_MAX)
|
||
if (self.RenumAliasClass is None or self.RenumAliasField is None or self.RenumAliasIndex is None or self.RenumAliasTy is None or self.RenumAliasVariant is None):
|
||
# Same as the variant table: a silent bail left the alias table empty,
|
||
# so match bindings later failed with an unrelated NameError.
|
||
self.RenumAliasClass = None
|
||
self.Gen.TypeGenErr.fatal_error(None, f"failed to allocate REnum field alias table (class='{class_name}'): PermPool returned NULL", "InternalCompilerError")
|
||
return
|
||
string.memset(self.RenumAliasClass, 0, 8 * RENUM_ALIAS_MAX)
|
||
string.memset(self.RenumAliasField, 0, 8 * RENUM_ALIAS_MAX)
|
||
string.memset(self.RenumAliasIndex, 0, 8 * RENUM_ALIAS_MAX)
|
||
string.memset(self.RenumAliasTy, 0, 8 * RENUM_ALIAS_MAX)
|
||
string.memset(self.RenumAliasVariant, 0, 8 * RENUM_ALIAS_MAX)
|
||
self.RenumAliasCount = 0
|
||
# [D30] Same as above: register the alias table pointers into the factory singleton to survive Generators
|
||
CompilerFactory.factory.RenumAliasClass = self.RenumAliasClass
|
||
CompilerFactory.factory.RenumAliasField = self.RenumAliasField
|
||
CompilerFactory.factory.RenumAliasIndex = self.RenumAliasIndex
|
||
CompilerFactory.factory.RenumAliasTy = self.RenumAliasTy
|
||
CompilerFactory.factory.RenumAliasVariant = self.RenumAliasVariant
|
||
CompilerFactory.factory.RenumAliasCount = self.RenumAliasCount
|
||
|
||
if self.RenumAliasCount >= RENUM_ALIAS_MAX:
|
||
# Dropping the record silently made the variant field bind to a wrong-typed
|
||
# slot (or fail with NameError) instead of reporting the limit breach.
|
||
self.Gen.TypeGenErr.fatal_error(None, f"REnum field alias count exceeds the limit {RENUM_ALIAS_MAX}: cannot register {class_name}.{field_name}", "InternalCompilerError")
|
||
return
|
||
|
||
# Dedupe check (pointer-free): the class slot holds a perm_pool string copy compared with strcmp,
|
||
# so it no longer relies on pointer equality (registration uses AST pointers, lookup uses pool copies).
|
||
for i in range(int(self.RenumAliasCount)):
|
||
cls_existing_ptr: str = rawptr(self.RenumAliasClass[i])
|
||
if cls_existing_ptr is not None and string.strcmp(cls_existing_ptr, class_name) == 0:
|
||
fld_existing_ptr: str = rawptr(self.RenumAliasField[i])
|
||
if fld_existing_ptr is not None and string.strcmp(fld_existing_ptr, field_name) == 0:
|
||
# **变体名也必须一致**：同一 REnum 的不同变体可有**同名字段**
|
||
# （LLVMType.Int.Bits 与 LLVMType.Float.Bits）。旧判据只比 (class, field)，
|
||
# 第二个同名字段被当成重复记录直接丢弃 ⇒ _lookup_renum_member_ty(class,
|
||
# variant, idx) 查不到该记录 ⇒ match 绑定退化为按**物理槽类型**读取
|
||
# （max-payload 槽是 i8*/i64）⇒ 赋给 i32 时误报"隐式窄化禁止"（假阳性）。
|
||
_vn_existing: str = rawptr(self.RenumAliasVariant[i])
|
||
_vn_same: int = 0
|
||
if variant_name is None:
|
||
_vn_same = 1 if _vn_existing is None else 0
|
||
elif _vn_existing is not None:
|
||
_vn_same = 1 if string.strcmp(_vn_existing, variant_name) == 0 else 0
|
||
if _vn_same == 0:
|
||
continue
|
||
# Existing record: if the first pass left the type slot 0 (self-referencing field, see
|
||
# _refill_renum_field_types), backfill the real type now; a non-zero slot is left as is.
|
||
if self.RenumAliasTy[i] == 0 and field_ty is not None:
|
||
ty_copy_rf2: mlirlite.LLVMType* = mlirlite.DeepCopyType(CompilerFactory.factory.PermPool, field_ty)
|
||
if ty_copy_rf2 is not None: self.RenumAliasTy[i] = sizet(ty_copy_rf2)
|
||
return
|
||
|
||
idx: int = self.RenumAliasCount
|
||
# class_name is also strcpy'd into perm_pool (pointer-free: any class_name string from the lookup
|
||
# side matches via strcmp, so no _update_renum_alias_class_ptr is needed).
|
||
cls_len_rfa: sizet = string.strlen(class_name)
|
||
cls_buf_rfa: str = CompilerFactory.factory.PermPool.alloc(cls_len_rfa + 1)
|
||
if cls_buf_rfa is None: return
|
||
string.strcpy(cls_buf_rfa, class_name)
|
||
self.RenumAliasClass[idx] = sizet(cls_buf_rfa)
|
||
# field_name stored as a raw AST pointer dangles after each file's 1a reset; since
|
||
# _lookup_renum_field_alias compares with strcmp, copying into perm_pool does not affect lookup.
|
||
fn_len_rfa: sizet = string.strlen(field_name)
|
||
fn_buf_rfa: str = CompilerFactory.factory.PermPool.alloc(fn_len_rfa + 1)
|
||
if fn_buf_rfa is None: return
|
||
string.strcpy(fn_buf_rfa, field_name)
|
||
self.RenumAliasField[idx] = sizet(fn_buf_rfa)
|
||
self.RenumAliasIndex[idx] = sizet(payload_idx)
|
||
# Deep-copy the member type into perm_pool (pool types dangle after each file's 1a reset; on an
|
||
# unresolved type such as a self reference, store 0 and fall back to the slot type when binding).
|
||
self.RenumAliasTy[idx] = 0
|
||
if field_ty is not None:
|
||
ty_copy_rfa: mlirlite.LLVMType* = mlirlite.DeepCopyType(CompilerFactory.factory.PermPool, field_ty)
|
||
if ty_copy_rfa is not None: self.RenumAliasTy[idx] = sizet(ty_copy_rfa)
|
||
# The variant name is also strcpy'd into perm_pool (variant_cd.name dangles after the 1a reset)
|
||
self.RenumAliasVariant[idx] = 0
|
||
if variant_name is not None:
|
||
vn_len_rfa: sizet = string.strlen(variant_name)
|
||
vn_buf_rfa: str = CompilerFactory.factory.PermPool.alloc(vn_len_rfa + 1)
|
||
if vn_buf_rfa is not None:
|
||
string.strcpy(vn_buf_rfa, variant_name)
|
||
self.RenumAliasVariant[idx] = sizet(vn_buf_rfa)
|
||
self.RenumAliasCount = idx + 1
|
||
# [D30] Write the count back to the factory singleton (new Generators restore from it)
|
||
CompilerFactory.factory.RenumAliasCount = self.RenumAliasCount
|
||
def _lookup_renum_field_alias(self, class_name: str, field_name: str) -> int:
|
||
"""Look up an REnum variant field name's payload index, return it or -1 (class/field compared by content)."""
|
||
if class_name is None or field_name is None or self.RenumAliasClass is None: return -1
|
||
for i in range(int(self.RenumAliasCount)):
|
||
cls_existing_ptr: str = rawptr(self.RenumAliasClass[i])
|
||
if cls_existing_ptr is not None and string.strcmp(cls_existing_ptr, class_name) == 0:
|
||
# field_name is compared by strcmp content (pointers differ, content is the same)
|
||
fld_existing_ptr: str = rawptr(self.RenumAliasField[i])
|
||
if fld_existing_ptr is not None and string.strcmp(fld_existing_ptr, field_name) == 0: return int(self.RenumAliasIndex[i])
|
||
return -1
|
||
def _lookup_renum_field_alias_ty(self, class_name: str, field_name: str) -> mlirlite.LLVMType*:
|
||
"""Look up an REnum variant member's actual LLVM type, or None when the type slot is 0 (binding falls back to the slot type)."""
|
||
if class_name is None or field_name is None or self.RenumAliasTy is None: return None
|
||
for i in range(int(self.RenumAliasCount)):
|
||
cls_existing_ptr: str = rawptr(self.RenumAliasClass[i])
|
||
if cls_existing_ptr is not None and string.strcmp(cls_existing_ptr, class_name) == 0:
|
||
fld_existing_ptr: str = rawptr(self.RenumAliasField[i])
|
||
if fld_existing_ptr is not None and string.strcmp(fld_existing_ptr, field_name) == 0:
|
||
if self.RenumAliasTy[i] == 0: return None
|
||
return (mlirlite.LLVMType*)(self.RenumAliasTy[i])
|
||
return None
|
||
def _lookup_renum_member_ty(self, class_name: str, variant_name: str, payload_idx: int) -> mlirlite.LLVMType*:
|
||
"""Look up a variant member's actual LLVM type by (class, variant name, payload index) for match binding; None if unresolved."""
|
||
if class_name is None or variant_name is None or self.RenumAliasVariant is None: return None
|
||
if payload_idx < 1: return None
|
||
for i in range(int(self.RenumAliasCount)):
|
||
cls_existing_ptr: str = rawptr(self.RenumAliasClass[i])
|
||
if cls_existing_ptr is None or string.strcmp(cls_existing_ptr, class_name) != 0: continue
|
||
if self.RenumAliasVariant[i] == 0: continue
|
||
vnt_ptr: str = rawptr(self.RenumAliasVariant[i])
|
||
if vnt_ptr is None or string.strcmp(vnt_ptr, variant_name) != 0: continue
|
||
if self.RenumAliasIndex[i] != payload_idx: continue
|
||
if self.RenumAliasTy[i] == 0: return None
|
||
return (mlirlite.LLVMType*)(self.RenumAliasTy[i])
|
||
return None |