将部分 | t.CPtr 修正为 rawptr[T]
This commit is contained in:
TermiNexus committed
1 parent
eb01a45024
commit
9e2ccbfab7
58 files changed
+3543
-3564
No files matched your search
@@ -92,10 +92,10 @@ def TranslateFileGetTrans(mb: rawptr[memhub.MemBuddy], file_path: str,
|
||||
return None
|
||||
if bytes_read < SRC_BUF_SIZE:
|
||||
src_buf[bytes_read] = 0
|
||||
lx: ast.Lexer | t.CPtr = ast.new_lexer(mb)
|
||||
lx: rawptr[ast.Lexer] = ast.new_lexer(mb)
|
||||
ast._lexer_init(lx, src_buf, mb)
|
||||
tokens: ast.Token | t.CPtr = ast.tokenize(lx)
|
||||
tree: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens)
|
||||
tokens: rawptr[ast.Token] = ast.tokenize(lx)
|
||||
tree: rawptr[ast.AST] = ast.parse_tokens(mb, tokens)
|
||||
# parse 完成后 AST 树已独立，释放源代码缓冲区（避免 1MB/文件泄漏）
|
||||
stdlib.free(src_buf)
|
||||
if tree is None:
|
||||
|
||||
@@ -609,14 +609,14 @@ def RunPhase1(mb: rawptr[memhub.MemBuddy], includes_dir: str, temp_dir: str,
|
||||
src_buf_r[bytes_read_r] = 0
|
||||
|
||||
# 解析 AST
|
||||
lx_r: ast.Lexer | t.CPtr = ast.new_lexer(mb)
|
||||
lx_r: rawptr[ast.Lexer] = ast.new_lexer(mb)
|
||||
if lx_r is None:
|
||||
stdlib.free(src_buf_r)
|
||||
p1a_fl += 1
|
||||
continue
|
||||
ast._lexer_init(lx_r, src_buf_r, mb)
|
||||
tokens_r: ast.Token | t.CPtr = ast.tokenize(lx_r)
|
||||
tree_r: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens_r)
|
||||
tokens_r: rawptr[ast.Token] = ast.tokenize(lx_r)
|
||||
tree_r: rawptr[ast.AST] = ast.parse_tokens(mb, tokens_r)
|
||||
if tree_r is None:
|
||||
stdlib.free(src_buf_r)
|
||||
p1a_fl += 1
|
||||
@@ -767,15 +767,15 @@ def RunPhase1(mb: rawptr[memhub.MemBuddy], includes_dir: str, temp_dir: str,
|
||||
continue
|
||||
if bytes_read_pv < Phase1.SRC_BUF_SIZE:
|
||||
src_buf_pv[bytes_read_pv] = 0
|
||||
lx_pv: ast.Lexer | t.CPtr = ast.new_lexer(mb)
|
||||
lx_pv: rawptr[ast.Lexer] = ast.new_lexer(mb)
|
||||
if lx_pv is None:
|
||||
stdlib.free(src_buf_pv)
|
||||
p1bpre_failed += 1
|
||||
VLogger.error(f"[Phase 1b-pre] {file_path_pv} | 词法器分配失败（OOM）", "Phase1")
|
||||
continue
|
||||
ast._lexer_init(lx_pv, src_buf_pv, mb)
|
||||
tokens_pv: ast.Token | t.CPtr = ast.tokenize(lx_pv)
|
||||
tree_pv: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens_pv)
|
||||
tokens_pv: rawptr[ast.Token] = ast.tokenize(lx_pv)
|
||||
tree_pv: rawptr[ast.AST] = ast.parse_tokens(mb, tokens_pv)
|
||||
if tree_pv is None:
|
||||
stdlib.free(src_buf_pv)
|
||||
p1bpre_failed += 1
|
||||
@@ -972,14 +972,14 @@ def RunPhase1(mb: rawptr[memhub.MemBuddy], includes_dir: str, temp_dir: str,
|
||||
src_buf[bytes_read] = 0
|
||||
|
||||
# 解析 AST
|
||||
lx: ast.Lexer | t.CPtr = ast.new_lexer(mb)
|
||||
lx: rawptr[ast.Lexer] = ast.new_lexer(mb)
|
||||
if lx is None:
|
||||
stdlib.free(src_buf)
|
||||
failed += 1
|
||||
continue
|
||||
ast._lexer_init(lx, src_buf, mb)
|
||||
tokens: ast.Token | t.CPtr = ast.tokenize(lx)
|
||||
tree: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens)
|
||||
tokens: rawptr[ast.Token] = ast.tokenize(lx)
|
||||
tree: rawptr[ast.AST] = ast.parse_tokens(mb, tokens)
|
||||
if tree is None:
|
||||
VLogger.error(f"AST 解析失败: {file_path}", "Phase1")
|
||||
stdlib.free(src_buf)
|
||||
|
||||
@@ -121,30 +121,30 @@ def _ScanClassInheritance(mb: rawptr[memhub.MemBuddy],
|
||||
src_buf[bytes_read] = 0
|
||||
|
||||
# 解析 AST
|
||||
lx: ast.Lexer | t.CPtr = ast.new_lexer(mb)
|
||||
lx: rawptr[ast.Lexer] = ast.new_lexer(mb)
|
||||
if lx is None:
|
||||
stdlib.free(src_buf)
|
||||
continue
|
||||
ast._lexer_init(lx, src_buf, mb)
|
||||
tokens: ast.Token | t.CPtr = ast.tokenize(lx)
|
||||
tree: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens)
|
||||
tokens: rawptr[ast.Token] = ast.tokenize(lx)
|
||||
tree: rawptr[ast.AST] = ast.parse_tokens(mb, tokens)
|
||||
if tree is None:
|
||||
stdlib.free(src_buf)
|
||||
continue
|
||||
|
||||
# 遍历 AST 顶层节点，收集 ClassDef
|
||||
ch: list[ast.AST | t.CPtr] | t.CPtr = tree.children
|
||||
ch: list[rawptr[ast.AST]] | t.CPtr = tree.children
|
||||
if ch is not None:
|
||||
cn: sizet = len(ch)
|
||||
for ci in range(cn):
|
||||
child: ast.AST | t.CPtr = ch.get(ci)
|
||||
child: rawptr[ast.AST] = ch.get(ci)
|
||||
if child is None:
|
||||
continue
|
||||
kd: int = child.kind()
|
||||
if kd != ast.ASTKind.ClassDef:
|
||||
continue
|
||||
|
||||
cd: ast.ClassDef | t.CPtr = (ast.ClassDef | t.CPtr)(child)
|
||||
cd: rawptr[ast.ClassDef] = rawptr[ast.ClassDef](child)
|
||||
if cd is None or cd.name is None:
|
||||
continue
|
||||
|
||||
@@ -294,25 +294,25 @@ def _PreRegisterAllGenericTemplates(mb: rawptr[memhub.MemBuddy],
|
||||
stdlib.free(src_buf_pg)
|
||||
continue
|
||||
# 泛型文件：永久池解析 → 注册模板（节点/表进 perm_pool，跨 reset 存活）
|
||||
lx_pg: ast.Lexer | t.CPtr = ast.new_lexer(perm)
|
||||
lx_pg: rawptr[ast.Lexer] = ast.new_lexer(perm)
|
||||
if lx_pg is None:
|
||||
stdlib.free(src_buf_pg)
|
||||
continue
|
||||
ast._lexer_init(lx_pg, src_buf_pg, perm)
|
||||
tokens_pg: ast.Token | t.CPtr = ast.tokenize(lx_pg)
|
||||
tree_pg: ast.AST | t.CPtr = ast.parse_tokens(perm, tokens_pg)
|
||||
tokens_pg: rawptr[ast.Token] = ast.tokenize(lx_pg)
|
||||
tree_pg: rawptr[ast.AST] = ast.parse_tokens(perm, tokens_pg)
|
||||
if tree_pg is None:
|
||||
stdlib.free(src_buf_pg)
|
||||
continue
|
||||
# 遍历顶层 ClassDef，注册泛型模板（type_params 非 None）
|
||||
ch_pg: list[ast.AST | t.CPtr] | t.CPtr = tree_pg.children
|
||||
ch_pg: list[rawptr[ast.AST]] | t.CPtr = tree_pg.children
|
||||
if ch_pg is not None:
|
||||
cn_pg: sizet = len(ch_pg)
|
||||
for ci_pg in range(cn_pg):
|
||||
child_pg: ast.AST | t.CPtr = ch_pg.get(ci_pg)
|
||||
child_pg: rawptr[ast.AST] = ch_pg.get(ci_pg)
|
||||
if child_pg is None or child_pg.kind() != ast.ASTKind.ClassDef:
|
||||
continue
|
||||
cd_pg: ast.ClassDef | t.CPtr = (ast.ClassDef | t.CPtr)(child_pg)
|
||||
cd_pg: rawptr[ast.ClassDef] = rawptr[ast.ClassDef](child_pg)
|
||||
if cd_pg is None or cd_pg.name is None:
|
||||
continue
|
||||
tp_pg: list[str] | t.CPtr = cd_pg.type_params
|
||||
@@ -351,7 +351,7 @@ def _FindClassDefSha1(class_names_buf: bytes, def_sha1s_buf: bytes,
|
||||
# 命中即置 need_list/need_dict；误报无害（最多多编译两个空壳模块）。
|
||||
# ============================================================
|
||||
|
||||
def _AnnIsContainer(ann: ast.AST | t.CPtr) -> int:
|
||||
def _AnnIsContainer(ann: rawptr[ast.AST]) -> int:
|
||||
"""注解是否为 list/dict 容器（Name 裸名或 Subscript list[...]/dict[...]）
|
||||
|
||||
数组初始化（t.CArray[...] / 裸数组注解）返回 0，避免 _ScanTreeForContainers
|
||||
@@ -360,7 +360,7 @@ def _AnnIsContainer(ann: ast.AST | t.CPtr) -> int:
|
||||
while ann is not None:
|
||||
ak_c: int = ann.kind()
|
||||
if ak_c == ast.ASTKind.Name:
|
||||
nm_c: ast.Name | t.CPtr = (ast.Name | t.CPtr)(ann)
|
||||
nm_c: rawptr[ast.Name] = rawptr[ast.Name](ann)
|
||||
if nm_c.id is not None:
|
||||
if string.strcmp(nm_c.id, "list") == 0:
|
||||
return 1
|
||||
@@ -368,14 +368,14 @@ def _AnnIsContainer(ann: ast.AST | t.CPtr) -> int:
|
||||
return 1
|
||||
return 0
|
||||
elif ak_c == ast.ASTKind.Subscript:
|
||||
sub_c: ast.Subscript | t.CPtr = (ast.Subscript | t.CPtr)(ann)
|
||||
sub_c: rawptr[ast.Subscript] = rawptr[ast.Subscript](ann)
|
||||
ann = sub_c.value
|
||||
else:
|
||||
return 0
|
||||
return 0
|
||||
|
||||
|
||||
def _ScanTreeForContainers(node: ast.AST | t.CPtr,
|
||||
def _ScanTreeForContainers(node: rawptr[ast.AST],
|
||||
need_list_box: t.CPtr,
|
||||
need_dict_box: t.CPtr,
|
||||
depth: int = 0):
|
||||
@@ -388,30 +388,30 @@ def _ScanTreeForContainers(node: ast.AST | t.CPtr,
|
||||
return
|
||||
k_s: int = node.kind()
|
||||
if k_s == ast.ASTKind.Name:
|
||||
nm_s: ast.Name | t.CPtr = (ast.Name | t.CPtr)(node)
|
||||
nm_s: rawptr[ast.Name] = rawptr[ast.Name](node)
|
||||
if nm_s.id is not None:
|
||||
if string.strcmp(nm_s.id, "list") == 0:
|
||||
need_list_box[0] = 1
|
||||
elif string.strcmp(nm_s.id, "dict") == 0:
|
||||
need_dict_box[0] = 1
|
||||
elif k_s == ast.ASTKind.Subscript:
|
||||
sub_s: ast.Subscript | t.CPtr = (ast.Subscript | t.CPtr)(node)
|
||||
sub_s: rawptr[ast.Subscript] = rawptr[ast.Subscript](node)
|
||||
_ScanTreeForContainers(sub_s.value, need_list_box, need_dict_box, depth + 1)
|
||||
_ScanTreeForContainers(sub_s.slice, need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.BinOp:
|
||||
bop_s: ast.BinOp | t.CPtr = (ast.BinOp | t.CPtr)(node)
|
||||
bop_s: rawptr[ast.BinOp] = rawptr[ast.BinOp](node)
|
||||
_ScanTreeForContainers(bop_s.left, need_list_box, need_dict_box, depth + 1)
|
||||
_ScanTreeForContainers(bop_s.right, need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.Call:
|
||||
cl_s2: ast.Call | t.CPtr = (ast.Call | t.CPtr)(node)
|
||||
cl_s2: rawptr[ast.Call] = rawptr[ast.Call](node)
|
||||
_ScanTreeForContainers(cl_s2.func, need_list_box, need_dict_box, depth + 1)
|
||||
cl_args_s: list[ast.AST | t.CPtr] | t.CPtr = cl_s2.args
|
||||
cl_args_s: list[rawptr[ast.AST]] | t.CPtr = cl_s2.args
|
||||
if cl_args_s is not None:
|
||||
na_s: sizet = len(cl_args_s)
|
||||
i_a2: sizet
|
||||
for i_a2 in range(na_s):
|
||||
_ScanTreeForContainers(cl_args_s.get(i_a2), need_list_box, need_dict_box, depth + 1)
|
||||
cl_kws_s: list[ast.AST | t.CPtr] | t.CPtr = cl_s2.keywords
|
||||
cl_kws_s: list[rawptr[ast.AST]] | t.CPtr = cl_s2.keywords
|
||||
if cl_kws_s is not None:
|
||||
nk_s: sizet = len(cl_kws_s)
|
||||
i_k2: sizet
|
||||
@@ -420,52 +420,52 @@ def _ScanTreeForContainers(node: ast.AST | t.CPtr,
|
||||
if kw_s is not None:
|
||||
_ScanTreeForContainers(kw_s.value, need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.Assign:
|
||||
asn_s: ast.Assign | t.CPtr = (ast.Assign | t.CPtr)(node)
|
||||
asn_s: rawptr[ast.Assign] = rawptr[ast.Assign](node)
|
||||
_ScanTreeForContainers(asn_s.value, need_list_box, need_dict_box, depth + 1)
|
||||
tgts_s: list[ast.AST | t.CPtr] | t.CPtr = asn_s.targets
|
||||
tgts_s: list[rawptr[ast.AST]] | t.CPtr = asn_s.targets
|
||||
if tgts_s is not None:
|
||||
nt_s: sizet = len(tgts_s)
|
||||
i_t2: sizet
|
||||
for i_t2 in range(nt_s):
|
||||
_ScanTreeForContainers(tgts_s.get(i_t2), need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.AnnAssign:
|
||||
aa_s2: ast.AnnAssign | t.CPtr = (ast.AnnAssign | t.CPtr)(node)
|
||||
aa_s2: rawptr[ast.AnnAssign] = rawptr[ast.AnnAssign](node)
|
||||
_ScanTreeForContainers(aa_s2.annotation, need_list_box, need_dict_box, depth + 1)
|
||||
_ScanTreeForContainers(aa_s2.value, need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.FunctionDef:
|
||||
fn_s: ast.FunctionDef | t.CPtr = (ast.FunctionDef | t.CPtr)(node)
|
||||
fn_s: rawptr[ast.FunctionDef] = rawptr[ast.FunctionDef](node)
|
||||
_ScanTreeForContainers(fn_s.returns, need_list_box, need_dict_box, depth + 1)
|
||||
fn_args_s: ast.Arguments | t.CPtr = fn_s.args
|
||||
fn_args_s: rawptr[ast.Arguments] = rawptr[ast.Arguments](fn_s.args)
|
||||
if fn_args_s is not None:
|
||||
fa_s: list[ast.AST | t.CPtr] | t.CPtr = fn_args_s.args
|
||||
fa_s: list[rawptr[ast.AST]] | t.CPtr = fn_args_s.args
|
||||
if fa_s is not None:
|
||||
nf_s: sizet = len(fa_s)
|
||||
i_f2: sizet
|
||||
for i_f2 in range(nf_s):
|
||||
arg_s: ast.Arg | t.CPtr = (ast.Arg | t.CPtr)(fa_s.get(i_f2))
|
||||
arg_s: rawptr[ast.Arg] = rawptr[ast.Arg](fa_s.get(i_f2))
|
||||
if arg_s is not None:
|
||||
_ScanTreeForContainers(arg_s.annotation, need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.ClassDef:
|
||||
cd_s: ast.ClassDef | t.CPtr = (ast.ClassDef | t.CPtr)(node)
|
||||
bases_s: list[ast.AST | t.CPtr] | t.CPtr = cd_s.bases
|
||||
cd_s: rawptr[ast.ClassDef] = rawptr[ast.ClassDef](node)
|
||||
bases_s: list[rawptr[ast.AST]] | t.CPtr = cd_s.bases
|
||||
if bases_s is not None:
|
||||
nb_s: sizet = len(bases_s)
|
||||
i_b2: sizet
|
||||
for i_b2 in range(nb_s):
|
||||
_ScanTreeForContainers(bases_s.get(i_b2), need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.Attribute:
|
||||
at_s: ast.Attribute | t.CPtr = (ast.Attribute | t.CPtr)(node)
|
||||
at_s: rawptr[ast.Attribute] = rawptr[ast.Attribute](node)
|
||||
_ScanTreeForContainers(at_s.value, need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.Tuple:
|
||||
tu_s: ast.Tuple | t.CPtr = (ast.Tuple | t.CPtr)(node)
|
||||
elts_s: list[ast.AST | t.CPtr] | t.CPtr = tu_s.elts
|
||||
tu_s: rawptr[ast.Tuple] = rawptr[ast.Tuple](node)
|
||||
elts_s: list[rawptr[ast.AST]] | t.CPtr = tu_s.elts
|
||||
if elts_s is not None:
|
||||
ne_s: sizet = len(elts_s)
|
||||
i_e2: sizet
|
||||
for i_e2 in range(ne_s):
|
||||
_ScanTreeForContainers(elts_s.get(i_e2), need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.UnaryOp:
|
||||
uop_s: ast.UnaryOp | t.CPtr = (ast.UnaryOp | t.CPtr)(node)
|
||||
uop_s: rawptr[ast.UnaryOp] = rawptr[ast.UnaryOp](node)
|
||||
_ScanTreeForContainers(uop_s.operand, need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.Expr:
|
||||
ex_s: ast.Expr | t.CPtr = (ast.Expr | t.CPtr)(node)
|
||||
@@ -476,7 +476,7 @@ def _ScanTreeForContainers(node: ast.AST | t.CPtr,
|
||||
elif k_s == ast.ASTKind.Compare:
|
||||
cp_s: ast.Compare | t.CPtr = (ast.Compare | t.CPtr)(node)
|
||||
_ScanTreeForContainers(cp_s.left, need_list_box, need_dict_box, depth + 1)
|
||||
cps_s: list[ast.AST | t.CPtr] | t.CPtr = cp_s.comparators
|
||||
cps_s: list[rawptr[ast.AST]] | t.CPtr = cp_s.comparators
|
||||
if cps_s is not None:
|
||||
nc_s: sizet = len(cps_s)
|
||||
i_c2: sizet
|
||||
@@ -484,7 +484,7 @@ def _ScanTreeForContainers(node: ast.AST | t.CPtr,
|
||||
_ScanTreeForContainers(cps_s.get(i_c2), need_list_box, need_dict_box, depth + 1)
|
||||
elif k_s == ast.ASTKind.BoolOp:
|
||||
bo_s: ast.BoolOp | t.CPtr = (ast.BoolOp | t.CPtr)(node)
|
||||
bvs_s: list[ast.AST | t.CPtr] | t.CPtr = bo_s.values
|
||||
bvs_s: list[rawptr[ast.AST]] | t.CPtr = bo_s.values
|
||||
if bvs_s is not None:
|
||||
nv_s: sizet = len(bvs_s)
|
||||
i_v2: sizet
|
||||
@@ -498,7 +498,7 @@ def _ScanTreeForContainers(node: ast.AST | t.CPtr,
|
||||
# need_dict_box[0] = 1
|
||||
# 递归语句块子节点
|
||||
if node.children is not None:
|
||||
ch_s: list[ast.AST | t.CPtr] | t.CPtr = node.children
|
||||
ch_s: list[rawptr[ast.AST]] | t.CPtr = node.children
|
||||
n_s: sizet = len(ch_s)
|
||||
ci_s: sizet
|
||||
for ci_s in range(n_s):
|
||||
|
||||
@@ -293,25 +293,25 @@ def _PreRegisterAppGenericTemplates(mb: rawptr[memhub.MemBuddy],
|
||||
perm_pa: rawptr[memhub.MemBuddy] = CompilerFactory.factory.PermPool
|
||||
if perm_pa is None:
|
||||
perm_pa = mb
|
||||
lx_pa: ast.Lexer | t.CPtr = ast.new_lexer(perm_pa)
|
||||
lx_pa: rawptr[ast.Lexer] = ast.new_lexer(perm_pa)
|
||||
if lx_pa is None:
|
||||
stdlib.free(src_buf_pa)
|
||||
continue
|
||||
ast._lexer_init(lx_pa, src_buf_pa, perm_pa)
|
||||
tokens_pa: ast.Token | t.CPtr = ast.tokenize(lx_pa)
|
||||
tree_pa: ast.AST | t.CPtr = ast.parse_tokens(perm_pa, tokens_pa)
|
||||
tokens_pa: rawptr[ast.Token] = ast.tokenize(lx_pa)
|
||||
tree_pa: rawptr[ast.AST] = ast.parse_tokens(perm_pa, tokens_pa)
|
||||
if tree_pa is None:
|
||||
stdlib.free(src_buf_pa)
|
||||
continue
|
||||
# 遍历顶层 ClassDef，注册泛型模板（type_params 非 None）
|
||||
ch_pa: list[ast.AST | t.CPtr] | t.CPtr = tree_pa.children
|
||||
ch_pa: list[rawptr[ast.AST]] | t.CPtr = tree_pa.children
|
||||
if ch_pa is not None:
|
||||
cn_pa: sizet = len(ch_pa)
|
||||
for ci_pa in range(cn_pa):
|
||||
child_pa: ast.AST | t.CPtr = ch_pa.get(ci_pa)
|
||||
child_pa: rawptr[ast.AST] = ch_pa.get(ci_pa)
|
||||
if child_pa is None or child_pa.kind() != ast.ASTKind.ClassDef:
|
||||
continue
|
||||
cd_pa: ast.ClassDef | t.CPtr = (ast.ClassDef | t.CPtr)(child_pa)
|
||||
cd_pa: rawptr[ast.ClassDef] = rawptr[ast.ClassDef](child_pa)
|
||||
if cd_pa is None or cd_pa.name is None:
|
||||
continue
|
||||
tp_pa: list[str] | t.CPtr = cd_pa.type_params
|
||||
@@ -792,15 +792,15 @@ def RunMultiFileProject(mb: rawptr[memhub.MemBuddy],
|
||||
continue
|
||||
if bytes_read_vp2 < SRC_BUF_SIZE:
|
||||
src_buf_vp2[bytes_read_vp2] = 0
|
||||
lx_vp2: ast.Lexer | t.CPtr = ast.new_lexer(mb)
|
||||
lx_vp2: rawptr[ast.Lexer] = ast.new_lexer(mb)
|
||||
if lx_vp2 is None:
|
||||
stdlib.free(src_buf_vp2)
|
||||
vpi_failed_p2 += 1
|
||||
VLogger.error(f"[Phase A-pre-vpi] {ent_vp2.Path} | 词法器分配失败（OOM）", "PhaseA")
|
||||
continue
|
||||
ast._lexer_init(lx_vp2, src_buf_vp2, mb)
|
||||
tokens_vp2: ast.Token | t.CPtr = ast.tokenize(lx_vp2)
|
||||
tree_vp2: ast.AST | t.CPtr = ast.parse_tokens(mb, tokens_vp2)
|
||||
tokens_vp2: rawptr[ast.Token] = ast.tokenize(lx_vp2)
|
||||
tree_vp2: rawptr[ast.AST] = ast.parse_tokens(mb, tokens_vp2)
|
||||
if tree_vp2 is None:
|
||||
stdlib.free(src_buf_vp2)
|
||||
vpi_failed_p2 += 1
|
||||
|
||||
Reference in new issue
Block a user