919 lines
50 KiB
Plaintext
919 lines
50 KiB
Plaintext
from stdint import *
|
||
import ast
|
||
import mlirlite
|
||
import memhub
|
||
import string
|
||
import stdio
|
||
import stdlib
|
||
import viperlib
|
||
import win32.fileio as fileio
|
||
import lib.Stub.StubMerger as StubMerger
|
||
import lib.core.VLogger as VLogger
|
||
import lib.Projectrans.Config as Config
|
||
|
||
import lib.core.Gen.Expr.ExprGenBase as ExprGenBase
|
||
import lib.Stub.StubMerger.StubMergerCollect as StubMergerCollect
|
||
import lib.Stub.StubMerger.StubMergerStore as StubMergerStore
|
||
|
||
|
||
# ============================================================
|
||
# ExprGenCdef - ExprGenMixin split (stage D): cross-module CDefine lookup
|
||
novirtual class ExprGenCdef(ExprGenBase.ExprGenBase):
|
||
"""Cross-module CDefine lookup"""
|
||
|
||
# _build_source_path_from_sha1: build a source .vp/.py path from SHA1 via the StubMerger
|
||
# global store (.vpi missing -> source .py); "lib/..." -> SourceDir, else IncludesDir.
|
||
def _build_source_path_from_sha1(self, sha1: str) -> str:
|
||
"""Build a source .py path from a SHA1 via the global store"""
|
||
if sha1 is None: return None
|
||
if Config.IncludesDir is None: return None
|
||
# get the rel-path array from the StubMerger global store
|
||
rel_arr_ptr: bytes = StubMergerStore.GetSha1StoreRelArrPtr()
|
||
count: int = StubMergerStore.GetSha1StoreCount()
|
||
if rel_arr_ptr is None or count <= 0: return None
|
||
sha1_arr_ptr: bytes = StubMergerStore.GetSha1StoreArrPtr()
|
||
if sha1_arr_ptr is None: return None
|
||
# iterate to find the matching SHA1
|
||
idx_s: int = -1
|
||
for i in range(int(count)):
|
||
sidx: sizet = sizet(i) * 17
|
||
cur_sha1: str = sha1_arr_ptr + sidx
|
||
if cur_sha1[0] == '\0': continue
|
||
if string.strcmp(cur_sha1, sha1) == 0:
|
||
idx_s = i
|
||
break
|
||
if idx_s < 0: return None
|
||
# get the rel path (MAX_REL_PATH_LEN=256, avoids cross-module CDefine issues)
|
||
MAX_RPL: sizet = 256
|
||
ridx: sizet = sizet(idx_s) * MAX_RPL
|
||
rel_path: str = rel_arr_ptr + ridx
|
||
if rel_path[0] == '\0': return None
|
||
# choose base dir: 1) stored includes root IncDir (absolute, supports multiple dirs);
|
||
# 2) prefix heuristic: "lib/" -> SourceDir, "includes/" -> IncludesDir, else SourceDir then IncludesDir.
|
||
base_dir: str = None
|
||
rel_used: str = rel_path
|
||
inc_arr_ptr: bytes = StubMergerStore.GetSha1StoreIncdirArrPtr()
|
||
if inc_arr_ptr is not None:
|
||
iidx: sizet = sizet(idx_s) * StubMerger.MAX_INC_DIR_LEN
|
||
inc_dir: str = inc_arr_ptr + iidx
|
||
if inc_dir[0] != '\0': base_dir = inc_dir
|
||
if base_dir is None and string.strlen(rel_path) >= 4:
|
||
if (rel_path[0] == 'l' and rel_path[1] == 'i' and rel_path[2] == 'b' and rel_path[3] == '/'):
|
||
base_dir = Config.SourceDir if Config.SourceDir is not None else Config.IncludesDir
|
||
if base_dir is None and string.strlen(rel_path) >= 9:
|
||
if (rel_path[0] == 'i' and rel_path[1] == 'n' and rel_path[2] == 'c' and rel_path[3] == 'l' and rel_path[4] == 'u' and rel_path[5] == 'd' and rel_path[6] == 'e' and rel_path[7] == 's' and rel_path[8] == '/'):
|
||
rel_used = rel_path + 9
|
||
base_dir = Config.IncludesDir
|
||
if base_dir is None: base_dir = Config.SourceDir if Config.SourceDir is not None else Config.IncludesDir
|
||
# build full path: {base_dir}/{rel_used}
|
||
base_len: sizet = string.strlen(base_dir)
|
||
rel_len: sizet = string.strlen(rel_used)
|
||
path_len: sizet = base_len + rel_len + 2
|
||
buf: str = stdlib.malloc(path_len)
|
||
if buf is None: return None
|
||
viperlib.snprintf(buf, path_len, "%s/%s", base_dir, rel_used)
|
||
# existence check: if missing under SourceDir and IncludesDir differs, retry IncludesDir
|
||
pf_chk: fileio.File* = fileio.File(buf, fileio.MODE.R)
|
||
if pf_chk.closed:
|
||
pf_chk.close()
|
||
if Config.IncludesDir is not None and base_dir != Config.IncludesDir:
|
||
stdlib.free(buf)
|
||
base_len2: sizet = string.strlen(Config.IncludesDir)
|
||
path_len2: sizet = base_len2 + rel_len + 2
|
||
buf = stdlib.malloc(path_len2)
|
||
if buf is None: return None
|
||
viperlib.snprintf(buf, path_len2, "%s/%s", Config.IncludesDir, rel_used)
|
||
pf_chk2: fileio.File* = fileio.File(buf, fileio.MODE.R)
|
||
if pf_chk2.closed:
|
||
pf_chk2.close()
|
||
stdlib.free(buf)
|
||
return None
|
||
pf_chk2.close()
|
||
else:
|
||
stdlib.free(buf)
|
||
return None
|
||
else: pf_chk.close()
|
||
return buf
|
||
# _pyi_annot_float_kind - 从 .vpi/.pyi 行的注解段（`NAME:` 到 `=` 之间）判定浮点宽度种类：
|
||
# 独立单词 float → 1（f32）；double / 未声明 / 非浮点 → 0。词边界判定避免命中 `double`/`CFloat32`。
|
||
def _pyi_annot_float_kind(self, buf: bytes, start: sizet, end: sizet) -> int:
|
||
"""Return 1 when the annotation text [start,end) declares a 32-bit `float`, else 0."""
|
||
i: sizet = start
|
||
while i + 5 <= end:
|
||
if (buf[i] == 'f' and buf[i + 1] == 'l' and buf[i + 2] == 'o' and buf[i + 3] == 'a' and buf[i + 4] == 't'):
|
||
ok_before: int = 1
|
||
ok_after: int = 1
|
||
if i > start:
|
||
pb: char = buf[i - 1]
|
||
if (pb >= 'A' and pb <= 'Z') or (pb >= 'a' and pb <= 'z') or (pb >= '0' and pb <= '9') or pb == '_': ok_before = 0
|
||
if i + 5 < end:
|
||
pa: char = buf[i + 5]
|
||
if (pa >= 'A' and pa <= 'Z') or (pa >= 'a' and pa <= 'z') or (pa >= '0' and pa <= '9') or pa == '_': ok_after = 0
|
||
if ok_before != 0 and ok_after != 0: return 1
|
||
i += 1
|
||
return 0
|
||
# _lookup_cross_module_cdefine - cross-module CDefine lookup: resolve the source module
|
||
# from from_imports, parse its pyi "NAME: t.CDefine = value", then cache in the current module.
|
||
def _lookup_cross_module_cdefine(self, pool: memhub.MemBuddy*, name: str, from_imports: str, imported_modules: str = None, depth: int = 0, node: ast.AST* = None) -> int64:
|
||
"""Look up a CDefine constant across modules, returning its 64-bit value or -1"""
|
||
# recursion-depth guard: re-export chains + imported_modules walk can loop and OOM;
|
||
# cap at 32 to fail fast on cyclic imports (error carries node line + module chain).
|
||
if depth > 32:
|
||
err_buf: str = pool.alloc(256)
|
||
if err_buf is not None:
|
||
viperlib.snprintf(err_buf, 256, "cross-module CDefine lookup recursion too deep (suspected module import/re-export cycle): %s (depth=%d fi=%s)", name, depth, from_imports if from_imports is not None else "(nil)")
|
||
self.Gen.TypeGenErr.fatal_error(node, err_buf, "InternalCompilerError")
|
||
self.Gen.TypeGenErr.fatal_error(node, "cross-module CDefine lookup recursion too deep (suspected module import/re-export cycle)", "InternalCompilerError")
|
||
# clear the found flag at entry so every early return reports "not found",
|
||
# avoiding a stale success flag left over from a previous recursive call.
|
||
self.Gen.TypeGenCDef.set_cdefine_found(0)
|
||
if name is None: return -1
|
||
if from_imports is None: from_imports = ""
|
||
|
||
# 1. resolve the module name for `name` from from_imports; try exact match first
|
||
# (allow_star_fallback=0) so a star import cannot mislead CDefine constants.
|
||
mod_name_raw: str = self.Gen.ImportsGen.lookup_from_import(from_imports, name, 0)
|
||
if mod_name_raw is None:
|
||
# exact match failed: try the star import fallback
|
||
mod_name_raw = self.Gen.ImportsGen.lookup_from_import(from_imports, name, 1)
|
||
|
||
# truncate module name at NUL: lookup_from_import returns a pointer into from_imports
|
||
# (not NUL-terminated); match _lookup_sha1_from_modname_raw (space/colon/NUL delimited).
|
||
base_mod: str = None
|
||
if mod_name_raw is not None:
|
||
mbl: sizet = 0
|
||
while mod_name_raw[mbl] != ' ' and mod_name_raw[mbl] != '\0' and mod_name_raw[mbl] != ':': mbl += 1
|
||
mb_buf: str = pool.alloc(mbl + 1)
|
||
if mb_buf is not None:
|
||
mi2: sizet
|
||
for mi2 in range(int(mbl)): mb_buf[mi2] = mod_name_raw[mi2]
|
||
mb_buf[mbl] = '\0'
|
||
base_mod = mb_buf
|
||
while base_mod is not None and base_mod[0] == '.': base_mod = base_mod + 1
|
||
|
||
# cross-module CDefine cache (perm_pool, reused across files): key = "name@srcModule"
|
||
# keeps modules isolated so same-name constants from different modules do not cross.
|
||
xkey_buf: str = None
|
||
if base_mod is not None:
|
||
xk_len: sizet = string.strlen(name) + string.strlen(base_mod) + 2
|
||
xkey_buf = pool.alloc(xk_len)
|
||
if xkey_buf is not None:
|
||
viperlib.snprintf(xkey_buf, xk_len, "%s@%s", name, base_mod)
|
||
xval: str = self.Gen.TypeGenCDef.lookup_xmod_cdefine(xkey_buf)
|
||
if self.Gen.TypeGenCDef.is_cdefine_found() != 0:
|
||
if self.Gen.TypeGenCDef.is_cdefine_str() != 0: self.Gen.TypeGenCDef.register_cdefine_string(pool, name, xval)
|
||
elif self.Gen.TypeGenCDef.is_cdefine_double() != 0:
|
||
xd_v: double = string.atof(xval)
|
||
# 缓存里带宽度种类（f32 声明 → 1），否则使用方会把 f32 常量当 double 物化
|
||
xd_f32: int = self.Gen.TypeGenCDef.is_cdefine_float32()
|
||
self.Gen.TypeGenCDef.register_cdefine_double(pool, name, xd_v, xd_f32)
|
||
else:
|
||
xv_i: int64 = string.atoll(xval)
|
||
self.Gen.TypeGenCDef.register_cdefine_constant(pool, name, xv_i)
|
||
return string.atoll(xval)
|
||
|
||
# 2. from_imports failed: fall back to the imported_modules walk (step 9.6);
|
||
# a star fallback may name a wrong module, so keep scanning imported_modules.
|
||
if mod_name_raw is None:
|
||
# from_imports matched nothing (exact and star both failed):
|
||
# go straight to the imported_modules walk (step 9.6).
|
||
if imported_modules is None: return -1
|
||
# skip reading the from_imports module; go directly to the step 9.6 walk.
|
||
# result_found=0 skips steps 3-9 and jumps to 9.6.
|
||
self.Gen.TypeGenCDef.set_cdefine_found(0)
|
||
# iterate imported_modules directly
|
||
im_len: sizet = string.strlen(imported_modules)
|
||
im_ci: sizet = 0
|
||
while im_ci < im_len:
|
||
while im_ci < im_len and imported_modules[im_ci] == ' ': im_ci += 1
|
||
if im_ci >= im_len: break
|
||
im_start: sizet = im_ci
|
||
while im_ci < im_len and imported_modules[im_ci] != ' ': im_ci += 1
|
||
im_end: sizet = im_ci
|
||
im_nlen: sizet = im_end - im_start
|
||
if im_nlen > 0 and im_nlen < 256:
|
||
im_buf: str = pool.alloc(im_nlen + 1)
|
||
if im_buf is not None:
|
||
for mk in range(int(im_nlen)):
|
||
im_buf[mk] = imported_modules[im_start + mk]
|
||
im_buf[im_nlen] = '\0'
|
||
sub_fi: str = pool.alloc(im_nlen + 3)
|
||
if sub_fi is not None:
|
||
sub_fi[0] = '*'
|
||
sub_fi[1] = ':'
|
||
for mk2 in range(int(im_nlen)):
|
||
sub_fi[2 + mk2] = im_buf[mk2]
|
||
sub_fi[2 + im_nlen] = '\0'
|
||
sub_val: int64 = self._lookup_cross_module_cdefine(pool, name, sub_fi, None, depth + 1, node)
|
||
if self.Gen.TypeGenCDef.is_cdefine_found() != 0: return sub_val
|
||
return -1
|
||
|
||
# truncate module name, strip leading dots, find SHA1 via exact+suffix (shared logic)
|
||
sha1: str = self.Gen.CallGenBase._lookup_sha1_from_modname_raw(pool, mod_name_raw)
|
||
if sha1 is None: return -1
|
||
|
||
# 5. get temp_dir
|
||
temp_dir: str = self.Gen.TypeGenBase.get_temp_dir()
|
||
if temp_dir is None: return -1
|
||
|
||
# 6. build the vpi file path
|
||
td_len: sizet = string.strlen(temp_dir)
|
||
pyi_path: str = StubMergerCollect._sliced_path(temp_dir, td_len, sha1, "vpi")
|
||
if pyi_path is None: return -1
|
||
|
||
# 7. read vpi; if missing or too short (empty stub), fall back to the source .vp/.py
|
||
PYI_READ_BUF_SIZE: sizet = 65536
|
||
pyi_buf: bytes = stdlib.malloc(PYI_READ_BUF_SIZE)
|
||
if pyi_buf is None:
|
||
stdlib.free(pyi_path)
|
||
return -1
|
||
pf: fileio.File* = fileio.File(pyi_path, fileio.MODE.R)
|
||
need_py_fallback: int = 0
|
||
bytes_read: LONG = 0
|
||
if pf.closed:
|
||
# .vpi missing: fall back to the source .vp/.py
|
||
need_py_fallback = 1
|
||
else:
|
||
bytes_read = pf.read_all(pyi_buf, PYI_READ_BUF_SIZE)
|
||
pf.close()
|
||
# vpi too short (< 10 bytes): treat as empty stub, fall back to .py
|
||
if bytes_read < 10: need_py_fallback = 1
|
||
else:
|
||
if bytes_read < PYI_READ_BUF_SIZE: pyi_buf[bytes_read] = 0
|
||
# vpi stubs may declare a CDefine name without a value; the real value lives
|
||
# in the source .vp/.py, so trust vpi only when the target name's line has a value.
|
||
cd_sig: int = 0
|
||
name_has_val: int = 0
|
||
cs_name_len: sizet = string.strlen(name)
|
||
cs_total: sizet = string.strlen(pyi_buf)
|
||
cs_i: sizet = 0
|
||
while cs_i + 9 < cs_total:
|
||
if (pyi_buf[cs_i] == 't' and pyi_buf[cs_i + 1] == '.' and pyi_buf[cs_i + 2] == 'C' and pyi_buf[cs_i + 3] == 'D' and pyi_buf[cs_i + 4] == 'e' and pyi_buf[cs_i + 5] == 'f' and pyi_buf[cs_i + 6] == 'i' and pyi_buf[cs_i + 7] == 'n' and pyi_buf[cs_i + 8] == 'e'):
|
||
# check whether the rest of the line has '=' (only valued decls match in vpi)
|
||
cd_eq: int = 0
|
||
cs_j: sizet = cs_i + 9
|
||
while cs_j < cs_total and pyi_buf[cs_j] != '\n':
|
||
if pyi_buf[cs_j] == '=':
|
||
cd_eq = 1
|
||
break
|
||
cs_j += 1
|
||
if cd_eq != 0:
|
||
cd_sig = 1
|
||
# locate line start; check it begins with "name:" (target has a value)
|
||
cs_line_start: sizet = cs_i
|
||
while cs_line_start > 0 and pyi_buf[cs_line_start - 1] != '\n': cs_line_start -= 1
|
||
if cs_i - cs_line_start >= cs_name_len + 1:
|
||
nm_ok: int = 1
|
||
for ki2 in range(int(cs_name_len)):
|
||
if pyi_buf[cs_line_start + ki2] != name[ki2]:
|
||
nm_ok = 0
|
||
break
|
||
if nm_ok == 1 and pyi_buf[cs_line_start + cs_name_len] == ':': name_has_val = 1
|
||
cs_i += 1
|
||
if cd_sig == 0 or name_has_val == 0: need_py_fallback = 1
|
||
stdlib.free(pyi_path)
|
||
|
||
if need_py_fallback != 0:
|
||
# look up the rel path from the SHA1 store; build {base_dir}/{rel_path}
|
||
src_path: str = self._build_source_path_from_sha1(sha1)
|
||
if src_path is None:
|
||
# SHA1 absent from the store = compiler bug (Phase1/Phase2 not populated):
|
||
# report and abort instead of silently returning -1 (avoids bad @UNDEFINED refs).
|
||
err_buf: str = pool.alloc_tagged(4096, memhub.DETSITE_EXPRGENCDEF_263)
|
||
if err_buf is not None:
|
||
viperlib.snprintf(err_buf, 512, "cross-module CDefine lookup failed: SHA1 %s is not in the store (base_mod=%s name=%s). " "Phase1/Phase2 did not correctly populate PopulateSha1MapStore/AppendToSha1MapStore", sha1, base_mod, name)
|
||
VLogger.error(err_buf, "XMOD-CD")
|
||
stdlib.free(pyi_buf)
|
||
return -1
|
||
pf = fileio.File(src_path, fileio.MODE.R)
|
||
stdlib.free(src_path)
|
||
if pf.closed:
|
||
stdlib.free(pyi_buf)
|
||
return -1
|
||
bytes_read = pf.read_all(pyi_buf, PYI_READ_BUF_SIZE)
|
||
pf.close()
|
||
if bytes_read <= 0:
|
||
stdlib.free(pyi_buf)
|
||
return -1
|
||
if bytes_read < PYI_READ_BUF_SIZE: pyi_buf[bytes_read] = 0
|
||
|
||
# 8. search pyi_buf for the "name: t.CDefine = value" line
|
||
# format: NAME: t.CDefine = value
|
||
name_len: sizet = string.strlen(name)
|
||
total_len: sizet = string.strlen(pyi_buf)
|
||
pos: sizet = 0
|
||
result_val: int64 = 0
|
||
result_found: int = 0
|
||
res_is_double: int = 0
|
||
# 浮点宽度种类（1 = 注解声明为 32 位 float）：跨模块缓存与本地注册都要带上，
|
||
# 否则使用方把 f32 常量当 double 物化（`define PI: float = ...` 现场）。
|
||
res_is_f32: int = 0
|
||
res_is_str: int = 0
|
||
while pos < total_len:
|
||
# find line start
|
||
line_start: sizet = pos
|
||
# find line end
|
||
while pos < total_len and pyi_buf[pos] != '\n': pos += 1
|
||
line_len: sizet = pos - line_start
|
||
if pos < total_len:
|
||
pos += 1 # skip '\n'
|
||
|
||
# check whether the line starts with "name:"
|
||
if line_len < name_len + 1: continue
|
||
match_ok: int = 1
|
||
for ki in range(int(name_len)):
|
||
if pyi_buf[line_start + ki] != name[ki]:
|
||
match_ok = 0
|
||
break
|
||
if match_ok == 0: continue
|
||
if pyi_buf[line_start + name_len] != ':': continue
|
||
|
||
# check the line contains the CDefine marker
|
||
has_cdefine: int = 0
|
||
ci: sizet = line_start + name_len + 1
|
||
while ci + 7 <= line_start + line_len:
|
||
if (pyi_buf[ci] == 'C' and pyi_buf[ci + 1] == 'D' and pyi_buf[ci + 2] == 'e' and pyi_buf[ci + 3] == 'f' and pyi_buf[ci + 4] == 'i' and pyi_buf[ci + 5] == 'n' and pyi_buf[ci + 6] == 'e'):
|
||
has_cdefine = 1
|
||
break
|
||
ci += 1
|
||
if has_cdefine == 0: continue
|
||
|
||
# find the value after "="
|
||
eq_pos: sizet = line_start + name_len + 1
|
||
while eq_pos < line_start + line_len and pyi_buf[eq_pos] != '=': eq_pos += 1
|
||
if eq_pos >= line_start + line_len: continue
|
||
# 注解段 = [名字冒号后, '=')，用于判定声明的浮点宽度（如 `PI: float | t.CDefine`）
|
||
annot_start: sizet = line_start + name_len + 1
|
||
annot_end: sizet = eq_pos
|
||
eq_pos += 1 # skip '='
|
||
|
||
# skip spaces
|
||
while eq_pos < line_start + line_len and pyi_buf[eq_pos] == ' ': eq_pos += 1
|
||
|
||
# check for type-ctor forms like t.CUnsignedLong(...) / t.CLong(...) / int(...);
|
||
# if so, skip the "t.CXxx(" prefix, parse inside the parens, ignore trailing ')'.
|
||
is_type_ctor: int = 0
|
||
if eq_pos + 2 < line_start + line_len:
|
||
if pyi_buf[eq_pos] == 't' and pyi_buf[eq_pos + 1] == '.':
|
||
# find the '(' position
|
||
paren_pos: sizet = eq_pos + 2
|
||
while paren_pos < line_start + line_len and pyi_buf[paren_pos] != '(': paren_pos += 1
|
||
if paren_pos < line_start + line_len and pyi_buf[paren_pos] == '(':
|
||
is_type_ctor = 1
|
||
eq_pos = paren_pos + 1 # skip '('
|
||
# skip possible leading spaces inside the parens
|
||
while eq_pos < line_start + line_len and pyi_buf[eq_pos] == ' ': eq_pos += 1
|
||
|
||
# paren-wrapped flag: (1 << 23) / (512) / (A | B)
|
||
is_paren_expr: int = 0
|
||
if eq_pos < line_start + line_len and pyi_buf[eq_pos] == '(':
|
||
is_paren_expr = 1
|
||
eq_pos += 1
|
||
while eq_pos < line_start + line_len and pyi_buf[eq_pos] == ' ': eq_pos += 1
|
||
|
||
# === parse left operand token (number / hex / sign / name) ===
|
||
# sign flag
|
||
is_neg: int = 0
|
||
if eq_pos < line_start + line_len and pyi_buf[eq_pos] == '-':
|
||
is_neg = 1
|
||
eq_pos += 1
|
||
val_str_start: sizet = eq_pos
|
||
val_str_len: sizet = 0
|
||
is_hex: int = 0
|
||
is_float_val: int = 0
|
||
is_name_val: int = 0
|
||
is_str_val: int = 0
|
||
# string value (e.g. ZLIB_VERSION = "1.3.2"): read inside the quotes; without this,
|
||
# cross-module read-back skipped it and reported "CDefine not found".
|
||
if eq_pos < line_start + line_len and pyi_buf[eq_pos] == '"':
|
||
is_str_val = 1
|
||
eq_pos += 1 # skip opening quote
|
||
val_str_start = eq_pos
|
||
while eq_pos < line_start + line_len and pyi_buf[eq_pos] != '"':
|
||
val_str_len += 1
|
||
eq_pos += 1
|
||
if eq_pos < line_start + line_len and pyi_buf[eq_pos] == '"':
|
||
eq_pos += 1 # skip closing quote
|
||
if eq_pos + 1 < line_start + line_len:
|
||
if pyi_buf[eq_pos] == '0' and (pyi_buf[eq_pos + 1] == 'x' or pyi_buf[eq_pos + 1] == 'X'):
|
||
is_hex = 1
|
||
val_str_len = 2
|
||
eq_pos += 2
|
||
elif (pyi_buf[eq_pos] >= 'A' and pyi_buf[eq_pos] <= 'Z') or (pyi_buf[eq_pos] >= 'a' and pyi_buf[eq_pos] <= 'z') or pyi_buf[eq_pos] == '_':
|
||
is_name_val = 1
|
||
while eq_pos < line_start + line_len:
|
||
c_tk: char = pyi_buf[eq_pos]
|
||
if (c_tk >= 'A' and c_tk <= 'Z') or (c_tk >= 'a' and c_tk <= 'z') or (c_tk >= '0' and c_tk <= '9') or c_tk == '_':
|
||
val_str_len += 1
|
||
eq_pos += 1
|
||
else: break
|
||
# continue reading digit/hex chars (string values are read whole, skipped)
|
||
while eq_pos < line_start + line_len and is_name_val == 0 and is_str_val == 0:
|
||
ch: char = pyi_buf[eq_pos]
|
||
if is_hex == 1:
|
||
if ((ch >= '0' and ch <= '9') or (ch >= 'a' and ch <= 'f') or (ch >= 'A' and ch <= 'F')):
|
||
val_str_len += 1
|
||
eq_pos += 1
|
||
else: break
|
||
else:
|
||
if ch >= '0' and ch <= '9':
|
||
val_str_len += 1
|
||
eq_pos += 1
|
||
elif ch == '.' and is_float_val == 0:
|
||
# float value: '3.14159' ('.' allowed only once)
|
||
is_float_val = 1
|
||
val_str_len += 1
|
||
eq_pos += 1
|
||
else: break
|
||
|
||
if val_str_len == 0 and is_str_val == 0: continue
|
||
|
||
# copy the left token into a buffer
|
||
val_buf: str = pool.alloc(val_str_len + 1)
|
||
if val_buf is None: continue
|
||
for vi in range(int(val_str_len)): val_buf[vi] = pyi_buf[val_str_start + vi]
|
||
val_buf[val_str_len] = '\0'
|
||
|
||
# evaluate the left token
|
||
lval: int64 = 0
|
||
l_is_double: int = 0
|
||
ldbl: double = 0.0
|
||
if is_str_val != 0:
|
||
# string CDefine (e.g. ZLIB_VERSION = "1.3.2"): register the string value
|
||
# (including ""), mark result_found + res_is_str so the tail skips integers.
|
||
self.Gen.TypeGenCDef.register_cdefine_string(pool, name, val_buf)
|
||
result_val = 0
|
||
result_found = 1
|
||
res_is_str = 1
|
||
elif is_name_val != 0:
|
||
# True/False literal -> 1/0 (TPC treats bool as integer in CDefine context)
|
||
if string.strcmp(val_buf, "True") == 0: lval = 1
|
||
elif string.strcmp(val_buf, "False") == 0: lval = 0
|
||
else:
|
||
# name reference: look up the current CDefine table (e.g. FOREGROUND_COMBO)
|
||
lval = self.Gen.TypeGenCDef.lookup_cdefine_constant(val_buf)
|
||
if self.Gen.TypeGenCDef.is_cdefine_found() == 0:
|
||
# name not registered: cannot evaluate, skip the line
|
||
continue
|
||
elif is_hex == 1:
|
||
# parse hex manually (skip the 0x prefix) with 64-bit accumulation so
|
||
# 0xFFFFFFFF=4294967295 keeps full precision (constant side truncates to i32 -1).
|
||
hex_result: int64 = 0
|
||
hex_buf: str = val_buf + 2 # skip "0x"
|
||
for hi in range(int(val_str_len - 2)):
|
||
hc: char = hex_buf[hi]
|
||
hd: int = 0
|
||
if hc >= '0' and hc <= '9': hd = hc - '0'
|
||
elif hc >= 'a' and hc <= 'f': hd = hc - 'a' + 10
|
||
elif hc >= 'A' and hc <= 'F': hd = hc - 'A' + 10
|
||
else: break
|
||
hex_result = hex_result * 16 + hd
|
||
lval = hex_result
|
||
elif is_float_val != 0:
|
||
l_is_double = 1
|
||
ldbl = string.atof(val_buf)
|
||
lval = string.atoll(val_buf)
|
||
else: lval = string.atoll(val_buf)
|
||
if is_neg != 0:
|
||
lval = -lval
|
||
if l_is_double != 0: ldbl = -ldbl
|
||
|
||
# skip spaces; check for a binary operator
|
||
while eq_pos < line_start + line_len and pyi_buf[eq_pos] == ' ': eq_pos += 1
|
||
|
||
# parse operator (<< >> | & ^ + - * /)
|
||
cd_op: int = 0
|
||
if eq_pos + 1 < line_start + line_len:
|
||
if pyi_buf[eq_pos] == '<' and pyi_buf[eq_pos + 1] == '<':
|
||
cd_op = 1 # LShift
|
||
eq_pos += 2
|
||
elif pyi_buf[eq_pos] == '>' and pyi_buf[eq_pos + 1] == '>':
|
||
cd_op = 2 # RShift
|
||
eq_pos += 2
|
||
if cd_op == 0 and eq_pos < line_start + line_len:
|
||
if pyi_buf[eq_pos] == '|':
|
||
cd_op = 3 # BitOr
|
||
eq_pos += 1
|
||
elif pyi_buf[eq_pos] == '&':
|
||
cd_op = 4 # BitAnd
|
||
eq_pos += 1
|
||
elif pyi_buf[eq_pos] == '^':
|
||
cd_op = 5 # BitXor
|
||
eq_pos += 1
|
||
elif pyi_buf[eq_pos] == '+':
|
||
cd_op = 6 # Add
|
||
eq_pos += 1
|
||
elif pyi_buf[eq_pos] == '-':
|
||
cd_op = 7 # Sub
|
||
eq_pos += 1
|
||
elif pyi_buf[eq_pos] == '*':
|
||
cd_op = 8 # Mult
|
||
eq_pos += 1
|
||
elif pyi_buf[eq_pos] == '/':
|
||
cd_op = 9 # Div
|
||
eq_pos += 1
|
||
|
||
if cd_op != 0:
|
||
# === parse right operand token ===
|
||
while eq_pos < line_start + line_len and pyi_buf[eq_pos] == ' ': eq_pos += 1
|
||
r_neg: int = 0
|
||
if eq_pos < line_start + line_len and pyi_buf[eq_pos] == '-':
|
||
r_neg = 1
|
||
eq_pos += 1
|
||
r_start: sizet = eq_pos
|
||
r_len: sizet = 0
|
||
r_hex: int = 0
|
||
r_name: int = 0
|
||
if eq_pos + 1 < line_start + line_len:
|
||
if pyi_buf[eq_pos] == '0' and (pyi_buf[eq_pos + 1] == 'x' or pyi_buf[eq_pos + 1] == 'X'):
|
||
r_hex = 1
|
||
r_len = 2
|
||
eq_pos += 2
|
||
elif (pyi_buf[eq_pos] >= 'A' and pyi_buf[eq_pos] <= 'Z') or (pyi_buf[eq_pos] >= 'a' and pyi_buf[eq_pos] <= 'z') or pyi_buf[eq_pos] == '_':
|
||
r_name = 1
|
||
while eq_pos < line_start + line_len:
|
||
c_r: char = pyi_buf[eq_pos]
|
||
if (c_r >= 'A' and c_r <= 'Z') or (c_r >= 'a' and c_r <= 'z') or (c_r >= '0' and c_r <= '9') or c_r == '_':
|
||
r_len += 1
|
||
eq_pos += 1
|
||
else: break
|
||
while eq_pos < line_start + line_len and r_name == 0:
|
||
c_r2: char = pyi_buf[eq_pos]
|
||
if r_hex == 1:
|
||
if ((c_r2 >= '0' and c_r2 <= '9') or (c_r2 >= 'a' and c_r2 <= 'f') or (c_r2 >= 'A' and c_r2 <= 'F')):
|
||
r_len += 1
|
||
eq_pos += 1
|
||
else: break
|
||
else:
|
||
if c_r2 >= '0' and c_r2 <= '9':
|
||
r_len += 1
|
||
eq_pos += 1
|
||
else: break
|
||
if r_len == 0:
|
||
# no right operand after operator: cannot evaluate, skip the line
|
||
continue
|
||
r_buf: str = pool.alloc(r_len + 1)
|
||
if r_buf is None: continue
|
||
for r_i in range(int(r_len)): r_buf[r_i] = pyi_buf[r_start + r_i]
|
||
r_buf[r_len] = '\0'
|
||
rval: int64 = 0
|
||
if r_name != 0:
|
||
# True/False literal -> 1/0
|
||
if string.strcmp(r_buf, "True") == 0: rval = 1
|
||
elif string.strcmp(r_buf, "False") == 0: rval = 0
|
||
else:
|
||
rval = self.Gen.TypeGenCDef.lookup_cdefine_constant(r_buf)
|
||
if self.Gen.TypeGenCDef.is_cdefine_found() == 0:
|
||
# name not registered: cannot evaluate, skip the line
|
||
continue
|
||
elif r_hex != 0:
|
||
rhex_v: int64 = 0
|
||
rh_buf: str = r_buf + 2
|
||
for rh_i in range(int(r_len - 2)):
|
||
rc: char = rh_buf[rh_i]
|
||
rd: int = 0
|
||
if rc >= '0' and rc <= '9': rd = rc - '0'
|
||
elif rc >= 'a' and rc <= 'f': rd = rc - 'a' + 10
|
||
elif rc >= 'A' and rc <= 'F': rd = rc - 'A' + 10
|
||
else: break
|
||
rhex_v = rhex_v * 16 + rd
|
||
rval = rhex_v
|
||
else: rval = string.atoll(r_buf)
|
||
if r_neg != 0: rval = -rval
|
||
# compute the binary expression result (aligned with TPC ConstEvaluator)
|
||
if cd_op == 1: result_val = lval << rval
|
||
elif cd_op == 2: result_val = lval >> rval
|
||
elif cd_op == 3: result_val = lval | rval
|
||
elif cd_op == 4: result_val = lval & rval
|
||
elif cd_op == 5: result_val = lval ^ rval
|
||
elif cd_op == 6: result_val = lval + rval
|
||
elif cd_op == 7: result_val = lval - rval
|
||
elif cd_op == 8: result_val = lval * rval
|
||
else:
|
||
if rval == 0: continue
|
||
result_val = lval // rval
|
||
result_found = 1
|
||
break
|
||
else:
|
||
# single value (no operator): parenthesized values like (512) / (-11) also land here
|
||
if is_paren_expr != 0:
|
||
while eq_pos < line_start + line_len and pyi_buf[eq_pos] == ' ': eq_pos += 1
|
||
if eq_pos < line_start + line_len and pyi_buf[eq_pos] == ')': eq_pos += 1
|
||
if is_float_val != 0:
|
||
# float CDefine (e.g. U_M_PI = 3.14159...): cache as double for double
|
||
# constant generation; int part serves the int path (is_cdefine_double flag).
|
||
# 注解声明为 float 时带上 f32 种类，使用方才能直接出 f32 常量。
|
||
res_is_f32 = self._pyi_annot_float_kind(pyi_buf, annot_start, annot_end)
|
||
self.Gen.TypeGenCDef.register_cdefine_double(pool, name, ldbl, res_is_f32)
|
||
result_val = lval
|
||
result_found = 1
|
||
res_is_double = 1
|
||
else:
|
||
result_val = lval
|
||
result_found = 1
|
||
break
|
||
|
||
# 9.5 if not found in this module, recurse into submodules for `from .X import NAME` /
|
||
# `from .X import *` (e.g. ast.__init__ re-exports CONST_INT from .base).
|
||
if result_found == 0:
|
||
# base_mod was computed at function entry (mod_name_raw with leading dots removed);
|
||
# the submodule recursion uses it to build the full "base_mod.X" name.
|
||
name_len_rc: sizet = string.strlen(name)
|
||
rc_pos: sizet = 0
|
||
while rc_pos < total_len and result_found == 0:
|
||
# find line start
|
||
rc_line_start: sizet = rc_pos
|
||
# find line end
|
||
while rc_pos < total_len and pyi_buf[rc_pos] != '\n': rc_pos += 1
|
||
rc_line_len: sizet = rc_pos - rc_line_start
|
||
if rc_pos < total_len: rc_pos += 1
|
||
|
||
# check whether the line starts with "from " (module import)
|
||
if rc_line_len < 12: continue
|
||
if pyi_buf[rc_line_start] != 'f' or pyi_buf[rc_line_start+1] != 'r' or pyi_buf[rc_line_start+2] != 'o' or pyi_buf[rc_line_start+3] != 'm' or pyi_buf[rc_line_start+4] != ' ': continue
|
||
|
||
# extract the module token (skip leading dots); support both relative
|
||
# `from .base import X` (join base_mod.base) and absolute `from vqt6._types import *`.
|
||
rc_is_rel: int = 0
|
||
rc_sub_start: sizet = rc_line_start + 5
|
||
while rc_sub_start < rc_line_start + rc_line_len and pyi_buf[rc_sub_start] == '.':
|
||
rc_is_rel = 1
|
||
rc_sub_start += 1
|
||
rc_sub_end: sizet = rc_sub_start
|
||
while rc_sub_end < rc_line_start + rc_line_len and pyi_buf[rc_sub_end] != ' ' and pyi_buf[rc_sub_end] != '\t': rc_sub_end += 1
|
||
rc_sub_len: sizet = rc_sub_end - rc_sub_start
|
||
if rc_sub_len == 0: continue
|
||
|
||
# check whether the line contains "import"
|
||
rc_has_import: int = 0
|
||
rc_ipos: sizet = rc_sub_end
|
||
while rc_ipos + 6 <= rc_line_start + rc_line_len:
|
||
if pyi_buf[rc_ipos] == 'i' and pyi_buf[rc_ipos+1] == 'm' and pyi_buf[rc_ipos+2] == 'p' and pyi_buf[rc_ipos+3] == 'o' and pyi_buf[rc_ipos+4] == 'r' and pyi_buf[rc_ipos+5] == 't':
|
||
rc_has_import = 1
|
||
break
|
||
rc_ipos += 1
|
||
if rc_has_import == 0: continue
|
||
|
||
# check NAME is in the import list, or the import is *; handle multi-line
|
||
# imports: scan from "import" up to ")" when a "(" is present.
|
||
rc_imp_start: sizet = rc_ipos + 6
|
||
rc_star: int = 0
|
||
rc_name_match: int = 0
|
||
|
||
# determine the scan range: single line or multi-line (inside parens)
|
||
rc_scan_end: sizet = rc_line_start + rc_line_len
|
||
rc_has_paren: int = 0
|
||
rc_pp: sizet = rc_imp_start
|
||
while rc_pp < rc_line_start + rc_line_len:
|
||
if pyi_buf[rc_pp] == '(':
|
||
rc_has_paren = 1
|
||
break
|
||
if pyi_buf[rc_pp] == '*': rc_star = 1
|
||
rc_pp += 1
|
||
if rc_has_paren != 0:
|
||
# multi-line import: scan from after "(" to ")"
|
||
rc_scan_end = rc_pp + 1
|
||
rc_paren_closed: int = 0
|
||
rc_sp: sizet = rc_pp + 1
|
||
while rc_sp < total_len and rc_paren_closed == 0:
|
||
if pyi_buf[rc_sp] == ')':
|
||
rc_paren_closed = 1
|
||
rc_scan_end = rc_sp
|
||
break
|
||
rc_sp += 1
|
||
if rc_paren_closed == 0: rc_scan_end = total_len
|
||
|
||
# scan from rc_imp_start to rc_scan_end for NAME and *
|
||
rc_cpos: sizet = rc_imp_start
|
||
while rc_cpos < rc_scan_end:
|
||
rc_ch: char = pyi_buf[rc_cpos]
|
||
if rc_ch == '*': rc_star = 1
|
||
# check NAME matches as a whole word
|
||
if rc_cpos + name_len_rc <= rc_scan_end:
|
||
rc_match: int = 1
|
||
rc_ki: sizet
|
||
for rc_ki in range(int(name_len_rc)):
|
||
if pyi_buf[rc_cpos + rc_ki] != name[rc_ki]:
|
||
rc_match = 0
|
||
break
|
||
if rc_match == 1:
|
||
# check the preceding char is a non-identifier char
|
||
rc_before_ok: int = 0
|
||
if rc_cpos == rc_imp_start: rc_before_ok = 1
|
||
else:
|
||
rc_before_ch: char = pyi_buf[rc_cpos - 1]
|
||
if rc_before_ch == ' ' or rc_before_ch == '\t' or rc_before_ch == '(' or rc_before_ch == ',' or rc_before_ch == '\n' or rc_before_ch == '\r': rc_before_ok = 1
|
||
# check the following char is a non-identifier char
|
||
rc_after_ok: int = 0
|
||
rc_after_pos: sizet = rc_cpos + name_len_rc
|
||
if rc_after_pos >= rc_scan_end: rc_after_ok = 1
|
||
else:
|
||
rc_after_ch: char = pyi_buf[rc_after_pos]
|
||
if rc_after_ch == ' ' or rc_after_ch == '\t' or rc_after_ch == ')' or rc_after_ch == ',' or rc_after_ch == '\r' or rc_after_ch == '\n': rc_after_ok = 1
|
||
if rc_before_ok == 1 and rc_after_ok == 1: rc_name_match = 1
|
||
rc_cpos += 1
|
||
|
||
if rc_star == 0 and rc_name_match == 0: continue
|
||
|
||
# copy the submodule name into a new buffer (pyi_buf + rc_sub_start is not NUL-terminated)
|
||
rc_sub_buf: str = pool.alloc(rc_sub_len + 1)
|
||
if rc_sub_buf is None: continue
|
||
rc_si: sizet
|
||
for rc_si in range(int(rc_sub_len)): rc_sub_buf[rc_si] = pyi_buf[rc_sub_start + rc_si]
|
||
rc_sub_buf[rc_sub_len] = '\0'
|
||
|
||
# build the full module name: relative import -> package + "." + token (the base
|
||
# must be the package, not the module name); absolute import -> token as-is.
|
||
rc_full_mod: str = None
|
||
if rc_is_rel != 0:
|
||
rc_base_mod: str = base_mod
|
||
rc_pkg: str = self.Gen.CallGenBase._module_package_from_sha1(pool, sha1)
|
||
if rc_pkg is not None: rc_base_mod = rc_pkg
|
||
rc_full_len: sizet = string.strlen(rc_base_mod) + 1 + rc_sub_len + 1
|
||
rc_full_buf: str = pool.alloc(rc_full_len)
|
||
if rc_full_buf is None: continue
|
||
viperlib.snprintf(rc_full_buf, rc_full_len, "%s.%s", rc_base_mod, rc_sub_buf)
|
||
rc_full_mod = rc_full_buf
|
||
else:
|
||
if string.strcmp(rc_sub_buf, base_mod) == 0: continue
|
||
rc_full_mod = rc_sub_buf
|
||
|
||
# loop guard: if base_mod already ends with "."+rc_sub_buf (ast.base + .base),
|
||
# the recursion is re-appending the same segment -> skip (infinite-growth root cause).
|
||
rc_blen: sizet = string.strlen(base_mod)
|
||
if rc_blen > rc_sub_len + 1:
|
||
rc_tail: str = base_mod + (rc_blen - rc_sub_len)
|
||
if rc_tail[0] == '.' and string.strncmp(rc_tail + 1, rc_sub_buf, rc_sub_len) == 0: continue
|
||
|
||
# build a temporary from_imports "name:full_mod"
|
||
rc_fi_len: sizet = name_len_rc + 1 + string.strlen(rc_full_mod) + 1
|
||
rc_fi: str = pool.alloc(rc_fi_len)
|
||
if rc_fi is None: continue
|
||
viperlib.snprintf(rc_fi, rc_fi_len, "%s:%s", name, rc_full_mod)
|
||
|
||
# recursive call to search the submodule
|
||
rc_sub_val: int64 = self._lookup_cross_module_cdefine(pool, name, rc_fi, None, depth + 1, node)
|
||
if self.Gen.TypeGenCDef.is_cdefine_found() != 0:
|
||
result_val = rc_sub_val
|
||
result_found = 1
|
||
|
||
stdlib.free(pyi_buf)
|
||
|
||
# 9.6 star-fallback module had no match: fall back to walking imported_modules,
|
||
# e.g. `from stdint import *` names stdint but SHARE_READ lives in `import win32.fileio`.
|
||
if result_found == 0 and imported_modules is not None:
|
||
im2_len: sizet = string.strlen(imported_modules)
|
||
im2_ci: sizet = 0
|
||
while im2_ci < im2_len and result_found == 0:
|
||
while im2_ci < im2_len and imported_modules[im2_ci] == ' ': im2_ci += 1
|
||
if im2_ci >= im2_len: break
|
||
im2_start: sizet = im2_ci
|
||
while im2_ci < im2_len and imported_modules[im2_ci] != ' ': im2_ci += 1
|
||
im2_end: sizet = im2_ci
|
||
im2_nlen: sizet = im2_end - im2_start
|
||
if im2_nlen > 0 and im2_nlen < 256:
|
||
im2_buf: str = pool.alloc(im2_nlen + 1)
|
||
if im2_buf is not None:
|
||
for mk3 in range(int(im2_nlen)):
|
||
im2_buf[mk3] = imported_modules[im2_start + mk3]
|
||
im2_buf[im2_nlen] = '\0'
|
||
sub_fi2: str = pool.alloc(im2_nlen + 3)
|
||
if sub_fi2 is not None:
|
||
sub_fi2[0] = '*'
|
||
sub_fi2[1] = ':'
|
||
for mk4 in range(int(im2_nlen)):
|
||
sub_fi2[2 + mk4] = im2_buf[mk4]
|
||
sub_fi2[2 + im2_nlen] = '\0'
|
||
sub_val2: int64 = self._lookup_cross_module_cdefine(pool, name, sub_fi2, None, depth + 1, node)
|
||
if self.Gen.TypeGenCDef.is_cdefine_found() != 0:
|
||
result_val = sub_val2
|
||
result_found = 1
|
||
|
||
# 10. cache into the current module's CDefine table and the cross-module perm_pool;
|
||
# float CDefines are already cached as double, so only integers are written here.
|
||
if result_found != 0:
|
||
if res_is_str != 0:
|
||
# string CDefine: the value was already registered in the match loop (val_buf is
|
||
# the hit line's content, valid across the function); only write the cross cache.
|
||
if base_mod is not None:
|
||
ck_len_s: sizet = string.strlen(name) + string.strlen(base_mod) + 2
|
||
ckey_s: str = pool.alloc(ck_len_s)
|
||
if ckey_s is not None:
|
||
viperlib.snprintf(ckey_s, ck_len_s, "%s@%s", name, base_mod)
|
||
self.Gen.TypeGenCDef.register_xmod_cdefine(ckey_s, val_buf, 0, 1)
|
||
elif res_is_double == 0:
|
||
self.Gen.TypeGenCDef.register_cdefine_constant(pool, name, result_val)
|
||
# cross-module cache (perm_pool, reused across files), integers: key matches the
|
||
# entry query "name@srcModule" (truncated base_mod, leading dots removed).
|
||
if base_mod is not None:
|
||
ck_len: sizet = string.strlen(name) + string.strlen(base_mod) + 2
|
||
ckey_buf: str = pool.alloc(ck_len)
|
||
if ckey_buf is not None:
|
||
viperlib.snprintf(ckey_buf, ck_len, "%s@%s", name, base_mod)
|
||
cbuf_i: str = pool.alloc(32)
|
||
if cbuf_i is not None:
|
||
viperlib.snprintf(cbuf_i, 32, "%lld", result_val)
|
||
self.Gen.TypeGenCDef.register_xmod_cdefine(ckey_buf, cbuf_i, 0, 0)
|
||
else:
|
||
# float: fetch %.17g text from the local table and write the cross cache (lossless)
|
||
if base_mod is not None:
|
||
ck_len2: sizet = string.strlen(name) + string.strlen(base_mod) + 2
|
||
ckey2: str = pool.alloc(ck_len2)
|
||
if ckey2 is not None:
|
||
viperlib.snprintf(ckey2, ck_len2, "%s@%s", name, base_mod)
|
||
dval_cc: double = self.Gen.TypeGenCDef.lookup_cdefine_double(name)
|
||
if self.Gen.TypeGenCDef.is_cdefine_double() != 0:
|
||
cbuf_d: str = pool.alloc(64)
|
||
if cbuf_d is not None:
|
||
stdio.snprintf(cbuf_d, 64, "%.17g", dval_cc)
|
||
# 浮点种类随缓存一起带上（1=f64 / 2=f32），供后续使用方直接物化宽度
|
||
self.Gen.TypeGenCDef.register_xmod_cdefine(ckey2, cbuf_d, self.Gen.TypeGenCDef.xmod_float_kind(), 0)
|
||
self.Gen.TypeGenCDef.set_cdefine_found(1)
|
||
else: self.Gen.TypeGenCDef.set_cdefine_found(0)
|
||
|
||
return result_val
|
||
# _is_cdefine_name_pattern - CDefine names follow ALL_CAPS (A-Z, 0-9, _ with >=1 uppercase);
|
||
# lowercase keywords/variables won't match, avoiding fail-fast false positives. 1=match, 0=no.
|
||
def _is_cdefine_name_pattern(self, name: str) -> int:
|
||
"""Return 1 if name follows the CDefine convention (uppercase letters, digits, underscore)"""
|
||
if name is None: return 0
|
||
has_upper: int = 0
|
||
i: sizet = 0
|
||
while name[i] != '\0':
|
||
c: char = name[i]
|
||
if c >= 'a' and c <= 'z': return 0
|
||
if c >= 'A' and c <= 'Z': has_upper = 1
|
||
i += 1
|
||
return has_upper
|
||
# ============================================================
|
||
# Translate a variable reference (Name node) -> load
|
||
def _const_int_for_cdefine(self, pool: memhub.MemBuddy*, name: str, value: int64) -> mlirlite.Value*:
|
||
"""Materialize a CDefine integer constant as an LLVM constant (TPC TypeConvert aligned)
|
||
|
||
位宽优先用 define 的**已知位宽**（右侧显式强转或声明注解，见 register_cdefine_constant 的 bits）；
|
||
没有位宽记录时按**推断位宽**物化（值的最小可存宽度；0x80000000 → 32）。
|
||
这样 `define X: WORD = WORD(...)` 的 X 保持 u16、`X | Y` 里两个同宽 u16 不会被提升成
|
||
i32；无注解的 `define A = 0x80000000` 也不会退化成 i64 把 `A | B` 放大到 64 位，
|
||
而小值 define 说成 8/16 也在算术提升下不会溢出。
|
||
"""
|
||
dbits: int = 0
|
||
if name is not None: dbits = self.Gen.TypeGenCDef.lookup_cdefine_bits(name)
|
||
if dbits == 8 or dbits == 16 or dbits == 32 or dbits == 64:
|
||
return mlirlite.const_int(pool, dbits, self._cdefine_bits_value(value, dbits))
|
||
# 无位宽记录（例如只从 .vpi 跨模块引入、未登记 bits）→ 按**推断位宽**物化：
|
||
# 值的最小可存宽度（2^31..2^32-1 取 32 位无符号位型，不退化成 i64；
|
||
# 小值取 8/16，参与算术时由整数提升先升到 i32，不会溢出）。
|
||
wmin: int = self.Gen.AssignGen.define_min_width(value)
|
||
return mlirlite.const_int(pool, wmin, self._cdefine_bits_value(value, wmin))
|
||
|
||
# ============================================================
|
||
# cdefine_use_width_value - materialize CDefine constants at the use-site width (TPC-aligned)
|
||
def _cdefine_bits_value(self, value: int64, bits: int) -> int64:
|
||
"""把值按位宽处理：**只有在当前位宽的两种解释下都装不下时才截断**，否则原样保留。
|
||
|
||
「左侧只会看到截断了的数据」：超宽的值先按 bits 取低位（如 WORD(0x80000000) → 0）。
|
||
但不该把"无符号可容、有符号装不下"的**正值**重解释成负数：旧实现无条件
|
||
`(value << 56) >> 56`，8 位下的 160 被读成 -96，正值静默变负 —— 现场
|
||
Gargantua `_start` 的 `string.memset(fb, 0, GW * GH * 4)`（GW=160, GH=90）
|
||
被折成 -34560，作为长度写穿映射区 → #PF。位型不变（const_int 本就按位宽截断），
|
||
只是不再翻转可容正值的语义。实现仍避开大掩码字面量（见下）。
|
||
"""
|
||
if bits == 8:
|
||
if value >= -128 and value <= 127: return value
|
||
if value > 127 and (value >> 8) == 0: return value
|
||
return (value << 56) >> 56
|
||
if bits == 16:
|
||
if value >= -32768 and value <= 32767: return value
|
||
if value > 32767 and (value >> 16) == 0: return value
|
||
return (value << 48) >> 48
|
||
if bits == 32:
|
||
if value >= -2147483647 - 1 and value <= 2147483647: return value
|
||
if value > 2147483647 and (value >> 32) == 0: return value
|
||
return (value << 32) >> 32
|
||
return value
|
||
|
||
def cdefine_use_width_value(self, pool: memhub.MemBuddy*, node: ast.AST*, name: str, value: int64, target_ty: mlirlite.LLVMType*, use_ctx: str = None) -> mlirlite.Value*:
|
||
"""Materialize a CDefine integer constant at a known use-site width, or None on fallback"""
|
||
bits: int = self.Gen.ExprGenBase.get_llvm_type_bits(target_ty)
|
||
if bits != 8 and bits != 16 and bits != 32 and bits != 64: return None
|
||
wmin: int = self.Gen.AssignGen.define_min_width(value)
|
||
if bits < wmin:
|
||
# "representable range at the use site" uses the same rule as the check = TPC
|
||
# DefineWidthLoHi = [-(2^(bits-1)), 2^bits - 1]; literals built from safe 2147483647.
|
||
m31: int64 = 2147483647
|
||
lo: int64 = -m31 - 1
|
||
hi: int64 = m31 * 2 + 1
|
||
if bits == 8:
|
||
lo = -128
|
||
hi = 255
|
||
elif bits == 16:
|
||
lo = -32768
|
||
hi = 65535
|
||
ctx: str = ""
|
||
if use_ctx is not None:
|
||
# this language's str is i8* with no `str + str`: `+` degrades to pointer add.
|
||
# Build strings with f-string interpolation / string.strcat / viperlib.snprintf.
|
||
ctx = f"({use_ctx})"
|
||
self.Gen.TypeGenErr.fatal_error(node, f"[VPC] define constant use site width insufficient: constant '{name}' actual value {value} " f"needs at least {wmin} bits (minimum representable width W_min), " f"but the use site{ctx} provides only {bits} bits " f"(the acceptable range for this bit width under both signed/unsigned interpretation: {lo}..{hi}). " f"silent truncation/downgrade is forbidden, compilation aborted. " f"fix: widen the type of the use site{ctx} to at least {wmin} bits " f"(e.g. int{wmin}T / CUInt{wmin}T or wider types), or use a smaller constant value.", "TypeError")
|
||
return None
|
||
return mlirlite.const_int(pool, bits, self._cdefine_bits_value(value, bits)) |