TermiNexus
6a7b27e14f
c.py 删除 CElif/CElse/CEndif 三个类及其 Library_C 登记；HandlesSpecialCall 删除无人调用的 _HandleCIfLlvm；_REMOVED_CIF_CALL_MSG 的报文补齐 CElif/CElse/CEndif 六个拼写。Converter.py 去掉已无意义的注释掉守卫与 c.CIfndef/c.CEndif 时代注释，示例改为仍在用的 c.CUndef/c.CPragma；ExprParser/ConstEvaluator/HandlesIf 的注释把内部标记统一写成 c.@CIfdef 与 cif 标记。
223 lines
10 KiB
Python
223 lines
10 KiB
Python
from __future__ import annotations
|
|
from typing import TYPE_CHECKING
|
|
if TYPE_CHECKING:
|
|
from lib.core.translator import Translator
|
|
import vast as ast
|
|
import llvmlite.ir as ir
|
|
from lib.core.Handles.HandlesBase import BaseHandle
|
|
from lib.core.ConstEvaluator import ConstEvaluator, EvalContext
|
|
|
|
|
|
class IfHandle(BaseHandle):
|
|
def _get_attr_full_name(self, node: ast.expr) -> str | None:
|
|
if isinstance(node, ast.Attribute):
|
|
parts: list[str] = []
|
|
cur: ast.expr = node
|
|
while isinstance(cur, ast.Attribute):
|
|
parts.append(cur.attr)
|
|
cur = cur.value
|
|
if isinstance(cur, ast.Name):
|
|
parts.append(cur.id)
|
|
parts.reverse()
|
|
return '.'.join(parts)
|
|
return None
|
|
|
|
def _is_cif_call(self, node: ast.expr) -> bool:
|
|
"""判定 If.test 是否为 cif/celif 的内部标记调用（c.@CIf 族，解析期合成）。
|
|
|
|
标记属性名带前导 '@'（词法器不可产出），故用户写的 c.CIf(...) 不会命中。
|
|
"""
|
|
if isinstance(node, ast.Call):
|
|
if isinstance(node.func, ast.Attribute):
|
|
if isinstance(node.func.value, ast.Name) and node.func.value.id == 'c':
|
|
return node.func.attr in ('@CIf', '@CIfdef', '@CIfndef')
|
|
if isinstance(node.func, ast.Name):
|
|
return node.func.id in ('@CIf', '@CIfdef', '@CIfndef')
|
|
return False
|
|
|
|
def _resolve_macro_name(self, arg: ast.expr) -> str | None:
|
|
if isinstance(arg, ast.Name):
|
|
return arg.id
|
|
if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
|
|
return arg.value
|
|
if isinstance(arg, ast.Attribute):
|
|
full_name: str | None = self._get_attr_full_name(arg)
|
|
if full_name:
|
|
return full_name
|
|
return None
|
|
|
|
def _evaluate_cif_condition(self, node: ast.Call) -> int | None:
|
|
if not isinstance(node, ast.Call):
|
|
return None
|
|
args: list[ast.expr] = node.args
|
|
if not args:
|
|
return 0
|
|
kind: str | None = None
|
|
if isinstance(node.func, ast.Attribute):
|
|
kind = node.func.attr
|
|
elif isinstance(node.func, ast.Name):
|
|
kind = node.func.id
|
|
else:
|
|
return None
|
|
if kind == '@CIfdef':
|
|
name: str | None = self._resolve_macro_name(args[0])
|
|
if name is None:
|
|
return 0
|
|
return 1 if self._is_macro_defined(name) else 0
|
|
elif kind == '@CIfndef':
|
|
name: str | None = self._resolve_macro_name(args[0])
|
|
if name is None:
|
|
return 1
|
|
return 0 if self._is_macro_defined(name) else 1
|
|
elif kind == '@CIf':
|
|
return self._eval_const_expr(args[0])
|
|
return None
|
|
|
|
def _is_macro_defined(self, name: str) -> bool:
|
|
Gen: "Translator.LlvmGen" = self.Trans.LlvmGen
|
|
if hasattr(Gen, '_define_constants') and name in Gen._define_constants:
|
|
return True
|
|
if self.Trans.SymbolTable.is_define(name):
|
|
return True
|
|
platform_macros: dict[str, int] = self._get_platform_macros()
|
|
return name in platform_macros
|
|
|
|
def _get_macro_value(self, name: str) -> int | float | None:
|
|
Gen: "Translator.LlvmGen" = self.Trans.LlvmGen
|
|
if hasattr(Gen, '_define_constants') and name in Gen._define_constants:
|
|
val: int | float | None = Gen._define_constants[name]
|
|
# 治本修复：本模块全局变量初始化值优先，避免跨模块同名 CDefine 覆盖
|
|
try:
|
|
if hasattr(Gen, 'module') and name in Gen.module.globals:
|
|
_gv: Any = Gen.module.globals[name]
|
|
if getattr(_gv, 'initializer', None) is not None:
|
|
_iv: Any = _gv.initializer
|
|
if hasattr(_iv, 'constant') and isinstance(_iv.constant, (int, float)):
|
|
val = _iv.constant
|
|
except Exception:
|
|
pass
|
|
if isinstance(val, (int, float)):
|
|
return val
|
|
info: "SymbolTable.SymbolInfo" = self.Trans.SymbolTable.lookup(name)
|
|
if info:
|
|
if info.IsDefine:
|
|
val: int | float | None = info.DefineValue
|
|
if isinstance(val, (int, float)):
|
|
return val
|
|
platform_macros: dict[str, int] = self._get_platform_macros()
|
|
if name in platform_macros:
|
|
return platform_macros[name]
|
|
return None
|
|
|
|
def _get_platform_macros(self) -> dict[str, int]:
|
|
Gen: "Translator.LlvmGen" = self.Trans.LlvmGen
|
|
macros: dict[str, int] = {}
|
|
pi: dict[str, object] = Gen._platform_info
|
|
ptr_size: int = getattr(Gen, 'ptr_size', 8)
|
|
# 根据目标平台设置宏（从三元组推导）
|
|
if pi.get('is_windows'):
|
|
macros['_WIN32'] = 1
|
|
if not pi.get('is_32bit'):
|
|
macros['_WIN64'] = 1
|
|
macros['WIN64'] = 1
|
|
macros['WIN32'] = 1
|
|
if pi.get('is_linux'):
|
|
macros['__linux__'] = 1
|
|
if pi.get('is_macos'):
|
|
macros['__APPLE__'] = 1
|
|
macros['__MACH__'] = 1
|
|
if pi.get('is_x86_64'):
|
|
macros['__x86_64__'] = 1
|
|
macros['__x86_64'] = 1
|
|
macros['_M_X64'] = 1
|
|
elif pi.get('is_arm64'):
|
|
macros['__aarch64__'] = 1
|
|
macros['_M_ARM64'] = 1
|
|
if not pi.get('is_32bit') and pi.get('is_linux'):
|
|
macros['__LP64__'] = 1
|
|
elif pi.get('is_32bit'):
|
|
macros['_ILP32'] = 1
|
|
macros['SIZEOF_VOID_P'] = ptr_size
|
|
macros['__SIZEOF_POINTER__'] = ptr_size
|
|
macros['NDEBUG'] = 0
|
|
return macros
|
|
|
|
def _eval_const_expr(self, node: ast.expr) -> int | None:
|
|
Gen: "Translator.LlvmGen" = self.Trans.LlvmGen
|
|
ctx: EvalContext = EvalContext(Gen=Gen, symtab=self.Trans.SymbolTable, translator=self.Trans)
|
|
result: int | float | bool | None = ConstEvaluator.eval_full(node, ctx)
|
|
if result is None:
|
|
# 保留 cif 标记的嵌套调用处理（HandlesIf 特有逻辑）
|
|
if isinstance(node, ast.Call) and self._is_cif_call(node):
|
|
return self._evaluate_cif_condition(node)
|
|
return None
|
|
# HandlesIf 需要 bool/float → int 转换（#if 条件编译语义）
|
|
if isinstance(result, bool):
|
|
return 1 if result else 0
|
|
if isinstance(result, float):
|
|
return 1 if result != 0.0 else 0
|
|
return result
|
|
|
|
def _CifExprText(self, node: ast.expr) -> str:
|
|
"""cif/celif 标记调用内层条件表达式的源码文本（供 FailFast 报文，失败取占位）。"""
|
|
try:
|
|
if isinstance(node, ast.Call) and node.args:
|
|
return ast.unparse(node.args[0])
|
|
return ast.unparse(node)
|
|
except Exception:
|
|
return '<condition>'
|
|
|
|
def _HandleIfLlvm(self, Node: ast.If) -> None:
|
|
Gen: "Translator.LlvmGen" = self.Trans.LlvmGen
|
|
if self._is_cif_call(Node.test):
|
|
compile_time_val: int | None = self._evaluate_cif_condition(Node.test)
|
|
if compile_time_val is None:
|
|
# cif/celif 条件必须是编译期常量：求不出 ⇒ FailFast（不再回退运行时分支）。
|
|
from lib.core.LLVMCG.FuncGen import FailFastError
|
|
expr_text: str = self._CifExprText(Node.test)
|
|
Message: str = (
|
|
f"'cif' / 'celif' condition is not a compile-time constant: {expr_text}. "
|
|
f"Only CDefine constants, literals, their arithmetic/comparison/boolean/"
|
|
f"bitwise operators and the 'defined(NAME)' predicate are allowed.")
|
|
raise FailFastError(Message + (Gen._get_node_info() if Gen else ''))
|
|
if compile_time_val:
|
|
self.Trans.BodyHandler.HandleBodyLlvm(Node.body)
|
|
elif Node.orelse:
|
|
if isinstance(Node.orelse, list) and len(Node.orelse) == 1 and isinstance(Node.orelse[0], ast.If):
|
|
self._HandleIfLlvm(Node.orelse[0])
|
|
else:
|
|
self.Trans.BodyHandler.HandleBodyLlvm(Node.orelse)
|
|
return
|
|
Cond: ir.Value | None = self.Trans.ExprHandler.HandleExprLlvm(Node.test)
|
|
if not Cond:
|
|
return
|
|
is_const: bool = isinstance(Cond, ir.Constant) and isinstance(Cond.type, ir.IntType) and Cond.type.width == 1
|
|
if is_const:
|
|
if Cond.constant:
|
|
self.Trans.BodyHandler.HandleBodyLlvm(Node.body)
|
|
elif Node.orelse:
|
|
if isinstance(Node.orelse, list) and len(Node.orelse) == 1 and isinstance(Node.orelse[0], ast.If):
|
|
self._HandleIfLlvm(Node.orelse[0])
|
|
else:
|
|
self.Trans.BodyHandler.HandleBodyLlvm(Node.orelse)
|
|
return
|
|
if not isinstance(Cond.type, ir.IntType) or Cond.type.width != 1:
|
|
Cond = self._CoerceCondToBool(Gen, Node.test, Cond)
|
|
ThenBB: ir.Block = Gen.func.append_basic_block(name="then")
|
|
ElseBB: ir.Block | None = Gen.func.append_basic_block(name="else") if Node.orelse else None
|
|
MergeBB: ir.Block = Gen.func.append_basic_block(name="endif")
|
|
if not Gen.builder.block.is_terminated:
|
|
Gen.builder.cbranch(Cond, ThenBB, ElseBB if ElseBB else MergeBB)
|
|
Gen.builder.position_at_start(ThenBB)
|
|
self.Trans.BodyHandler.HandleBodyLlvm(Node.body)
|
|
if not Gen.builder.block.is_terminated:
|
|
Gen.builder.branch(MergeBB)
|
|
if ElseBB:
|
|
Gen.builder.position_at_start(ElseBB)
|
|
self.Trans.BodyHandler.HandleBodyLlvm(Node.orelse)
|
|
if not Gen.builder.block.is_terminated:
|
|
Gen.builder.branch(MergeBB)
|
|
if not MergeBB.is_terminated:
|
|
Gen.builder.position_at_start(MergeBB)
|
|
else:
|
|
Gen.builder.position_at_end(MergeBB) |