可用的回归测试通过的标准版本
This commit is contained in:
690
CPython/c.py
690
CPython/c.py
@@ -1,690 +0,0 @@
|
||||
# C语法定义模块
|
||||
|
||||
import ast
|
||||
import sys
|
||||
import os
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
|
||||
|
||||
from . import t
|
||||
|
||||
def _to_str(node):
|
||||
if node is None:
|
||||
return ''
|
||||
if isinstance(node, str):
|
||||
return node
|
||||
if isinstance(node, list):
|
||||
return ' && '.join([_to_str(n) for n in node])
|
||||
NodeType = type(node).__name__
|
||||
if NodeType == 'Constant':
|
||||
return node.value
|
||||
elif NodeType == 'ID':
|
||||
return node.name
|
||||
elif NodeType == 'BinaryOp':
|
||||
left = _to_str(node.left)
|
||||
right = _to_str(node.right)
|
||||
return f'{left} {node.op} {right}'
|
||||
elif NodeType == 'UnaryOp':
|
||||
expr = _to_str(node.expr)
|
||||
return f'{node.op}{expr}'
|
||||
else:
|
||||
return repr(node)
|
||||
|
||||
class Asm:
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
if not args:
|
||||
return ['__asm__ volatile ("nop");']
|
||||
|
||||
# ========== 核心变量 ==========
|
||||
output_ops = [] # (值表达式, 约束符)
|
||||
input_ops = [] # (值表达式, 约束符)
|
||||
clobbers = [] # 破坏列表实际值
|
||||
operand_seq = 0 # 占位符编号
|
||||
|
||||
# ========== 核心修复：递归提取ASM_DESCR值（支持|组合） ==========
|
||||
def parse_asm_descr(expr):
|
||||
"""
|
||||
递归解析AST节点，确保获取t.ASM_DESCR的实际值，支持|组合
|
||||
处理场景：
|
||||
1. t.ASM_DESCR.XXX → 取属性值
|
||||
2. t.ASM_DESCR.XXX | t.ASM_DESCR.YYY → 拼接两个值
|
||||
3. 常量字符串 → 直接返回
|
||||
"""
|
||||
# 场景1：位或组合（XXX | YYY）
|
||||
if isinstance(expr, ast.BinOp):
|
||||
left_val = parse_asm_descr(expr.left)
|
||||
right_val = parse_asm_descr(expr.right)
|
||||
return left_val + right_val
|
||||
|
||||
# 场景2：t.ASM_DESCR.XXX 多层属性访问
|
||||
elif isinstance(expr, ast.Attribute):
|
||||
# 第一步：判断是否是 t.ASM_DESCR 的属性
|
||||
if isinstance(expr.value, ast.Attribute):
|
||||
# 内层是 t.ASM_DESCR
|
||||
if (isinstance(expr.value.value, ast.Name) and
|
||||
expr.value.value.id == 't' and
|
||||
expr.value.attr == 'ASM_DESCR'):
|
||||
# 取 t.ASM_DESCR.XXX 的实际值
|
||||
AttrName = expr.attr
|
||||
if hasattr(t.ASM_DESCR, AttrName):
|
||||
return getattr(t.ASM_DESCR, AttrName, "")
|
||||
|
||||
# 兼容 t.XXX 简化写法（如果有的话）
|
||||
elif isinstance(expr.value, ast.Name) and expr.value.id == 't':
|
||||
AttrName = expr.attr
|
||||
if hasattr(t.ASM_DESCR, AttrName):
|
||||
return getattr(t.ASM_DESCR, AttrName, "")
|
||||
|
||||
# 场景3：直接传常量（如 "r"、"cc"）
|
||||
elif isinstance(expr, ast.Constant):
|
||||
return expr.value
|
||||
|
||||
# 其他场景返回空
|
||||
return ""
|
||||
|
||||
# ========== 步骤1：处理f-string中的内联AsmInp/AsmOut ==========
|
||||
asm_code = ""
|
||||
first_arg = args[0]
|
||||
|
||||
if isinstance(first_arg, ast.JoinedStr):
|
||||
asm_parts = []
|
||||
for part in first_arg.values:
|
||||
if isinstance(part, ast.Constant):
|
||||
asm_parts.append(part.value)
|
||||
elif isinstance(part, ast.FormattedValue):
|
||||
expr = part.value
|
||||
if isinstance(expr, ast.Call) and isinstance(expr.func, ast.Attribute) and expr.func.value.id == 'c':
|
||||
# 解析内联的AsmInp/AsmOut
|
||||
call_node = expr
|
||||
val_ExprNode = translator.HandleExpr(call_node.args[0])[0] if len(call_node.args)>=1 else ""
|
||||
if isinstance(val_ExprNode, str):
|
||||
val_expr = val_ExprNode
|
||||
else:
|
||||
try:
|
||||
val_expr = str(val_ExprNode)
|
||||
except:
|
||||
val_expr = ''
|
||||
constraint = parse_asm_descr(call_node.args[1]) if len(call_node.args)>=2 else ""
|
||||
|
||||
if call_node.func.attr == 'AsmOut':
|
||||
output_ops.append((val_expr, constraint))
|
||||
asm_parts.append(f"%{operand_seq}")
|
||||
operand_seq += 1
|
||||
elif call_node.func.attr == 'AsmInp':
|
||||
input_ops.append((val_expr, constraint))
|
||||
asm_parts.append(f"%{operand_seq}")
|
||||
operand_seq += 1
|
||||
else:
|
||||
asm_parts.append(translator.HandleExpr(expr)[0])
|
||||
asm_code = ''.join(asm_parts)
|
||||
elif isinstance(first_arg, ast.Constant):
|
||||
asm_code = first_arg.value
|
||||
|
||||
# ========== 步骤2：处理参数中的AsmInp/AsmOut和破坏列表 ==========
|
||||
def parse_operand(arg):
|
||||
"""解析 AsmInp/AsmOut 参数"""
|
||||
if isinstance(arg, ast.Call) and isinstance(arg.func, ast.Attribute) and arg.func.value.id == 'c':
|
||||
call_node = arg
|
||||
val_ExprNode = translator.HandleExpr(call_node.args[0])[0] if len(call_node.args)>=1 else ""
|
||||
if isinstance(val_ExprNode, str):
|
||||
val_expr = val_ExprNode
|
||||
else:
|
||||
try:
|
||||
val_expr = str(val_ExprNode)
|
||||
except:
|
||||
val_expr = ''
|
||||
constraint = parse_asm_descr(call_node.args[1]) if len(call_node.args)>=2 else ""
|
||||
|
||||
if call_node.func.attr == 'AsmOut':
|
||||
return ('out', val_expr, constraint)
|
||||
elif call_node.func.attr == 'AsmInp':
|
||||
return ('in', val_expr, constraint)
|
||||
return None
|
||||
|
||||
for arg in args[1:]:
|
||||
result = parse_operand(arg)
|
||||
if result:
|
||||
direction, val_expr, constraint = result
|
||||
if direction == 'out':
|
||||
output_ops.append((val_expr, constraint))
|
||||
operand_seq += 1
|
||||
elif direction == 'in':
|
||||
input_ops.append((val_expr, constraint))
|
||||
operand_seq += 1
|
||||
elif isinstance(arg, ast.List):
|
||||
# 解析破坏列表（支持|组合）
|
||||
for elt in arg.elts:
|
||||
clobber_val = parse_asm_descr(elt)
|
||||
if clobber_val:
|
||||
clobbers.append(clobber_val)
|
||||
|
||||
# ========== 步骤2.5：处理关键字参数 out 和 op ==========
|
||||
for kw in keywords:
|
||||
if kw.arg == 'out':
|
||||
# 处理 out 关键字参数 (输出操作数)
|
||||
if isinstance(kw.value, ast.List):
|
||||
for elt in kw.value.elts:
|
||||
result = parse_operand(elt)
|
||||
if result and result[0] == 'out':
|
||||
output_ops.append((result[1], result[2]))
|
||||
operand_seq += 1
|
||||
elif isinstance(kw.value, ast.Call):
|
||||
result = parse_operand(kw.value)
|
||||
if result and result[0] == 'out':
|
||||
output_ops.append((result[1], result[2]))
|
||||
operand_seq += 1
|
||||
elif kw.arg == 'op':
|
||||
# 处理 op 关键字参数 (clobber，破坏列表)
|
||||
if isinstance(kw.value, ast.List):
|
||||
for elt in kw.value.elts:
|
||||
clobber_val = parse_asm_descr(elt)
|
||||
if clobber_val:
|
||||
clobbers.append(clobber_val)
|
||||
elif kw.arg == 'inp' or kw.arg == 'inputs':
|
||||
# 处理 inp/inputs 关键字参数 (输入操作数，追加到f-string中已有输入之后)
|
||||
if isinstance(kw.value, ast.List):
|
||||
for elt in kw.value.elts:
|
||||
if isinstance(elt, ast.Tuple):
|
||||
# 处理列表中的 (value, constraint) 元组格式
|
||||
if len(elt.elts) >= 2:
|
||||
val_ExprNode = translator.HandleExpr(elt.elts[0])[0] if len(elt.elts) >= 1 else ""
|
||||
if isinstance(val_ExprNode, str):
|
||||
val_expr = val_ExprNode
|
||||
else:
|
||||
try:
|
||||
val_expr = str(val_ExprNode)
|
||||
except:
|
||||
val_expr = ''
|
||||
constraint = parse_asm_descr(elt.elts[1])
|
||||
input_ops.append((val_expr, constraint))
|
||||
operand_seq += 1
|
||||
else:
|
||||
result = parse_operand(elt)
|
||||
if result and result[0] == 'in':
|
||||
input_ops.append((result[1], result[2]))
|
||||
operand_seq += 1
|
||||
elif isinstance(kw.value, ast.Call):
|
||||
result = parse_operand(kw.value)
|
||||
if result and result[0] == 'in':
|
||||
input_ops.append((result[1], result[2]))
|
||||
operand_seq += 1
|
||||
elif isinstance(kw.value, ast.Tuple):
|
||||
# 处理 (value, constraint) 元组格式
|
||||
if len(kw.value.elts) >= 2:
|
||||
val_ExprNode = translator.HandleExpr(kw.value.elts[0])[0] if len(kw.value.elts) >= 1 else ""
|
||||
if isinstance(val_ExprNode, str):
|
||||
val_expr = val_ExprNode
|
||||
else:
|
||||
try:
|
||||
val_expr = str(val_ExprNode)
|
||||
except:
|
||||
val_expr = ''
|
||||
constraint = parse_asm_descr(kw.value.elts[1])
|
||||
input_ops.append((val_expr, constraint))
|
||||
operand_seq += 1
|
||||
elif kw.arg == 'clobber':
|
||||
# 处理 clobber 关键字参数
|
||||
if isinstance(kw.value, ast.List):
|
||||
for elt in kw.value.elts:
|
||||
clobber_val = parse_asm_descr(elt)
|
||||
if clobber_val:
|
||||
clobbers.append(clobber_val)
|
||||
|
||||
# ========== 步骤3：格式化汇编代码 ==========
|
||||
asm_lines = [line.strip() for line in asm_code.split('\n') if line.strip()]
|
||||
formatted_asm = '\n '.join([f'"{line}\\n"' for line in asm_lines])
|
||||
|
||||
# ========== 步骤4：拼接约束字符串 ==========
|
||||
# 输出约束：如果约束已包含 = 或 +，直接使用；否则添加 =
|
||||
def format_constraint(constraint, is_output=True):
|
||||
if not constraint:
|
||||
return ""
|
||||
# 如果约束已包含修饰符，直接返回
|
||||
if '=' in constraint or '+' in constraint:
|
||||
return constraint
|
||||
# 否则添加适当的修饰符
|
||||
return ('=' if is_output else '') + constraint
|
||||
|
||||
out_const = ', '.join([f'"{format_constraint(c, True)}"({v})' for v, c in output_ops]) if output_ops else ""
|
||||
in_const = ', '.join([f'"{format_constraint(c, False)}"({v})' for v, c in input_ops]) if input_ops else ""
|
||||
clobber_const = ', '.join([f'"{x}"' for x in clobbers]) if clobbers else ""
|
||||
|
||||
# 构建约束部分：确保冒号格式正确
|
||||
constraint_parts = []
|
||||
# 输出约束
|
||||
if output_ops:
|
||||
constraint_parts.append(f': {out_const}')
|
||||
elif input_ops or clobbers:
|
||||
constraint_parts.append(':')
|
||||
|
||||
# 输入约束
|
||||
if input_ops:
|
||||
constraint_parts.append(f': {in_const}')
|
||||
elif clobbers:
|
||||
constraint_parts.append(':')
|
||||
|
||||
# 破坏列表
|
||||
if clobbers:
|
||||
constraint_parts.append(f': {clobber_const}')
|
||||
|
||||
constraint_str = ' '.join(constraint_parts)
|
||||
|
||||
# ========== 生成最终代码 ==========
|
||||
final_asm = f'__asm__ __volatile__ (\n {formatted_asm} {constraint_str});'
|
||||
return [final_asm]
|
||||
|
||||
class AsmInp:
|
||||
def __init__(self, value, constraint):
|
||||
self.value = value
|
||||
self.constraint = constraint
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
return []
|
||||
|
||||
class AsmOut:
|
||||
def __init__(self, value, constraint):
|
||||
self.value = value
|
||||
self.constraint = constraint
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
return []
|
||||
|
||||
class NoBreak:
|
||||
""" switch 分支无break """
|
||||
pass
|
||||
|
||||
class Break:
|
||||
""" switch 分支提前break """
|
||||
pass
|
||||
|
||||
class Load:
|
||||
"""解引用a写入b，等价于 *b = *a，无拷贝副作用"""
|
||||
def __init__(self, src, dst):
|
||||
self.src = src
|
||||
self.dst = dst
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
if len(args) >= 2:
|
||||
src = translator.HandleExpr(args[0])[0]
|
||||
dst = translator.HandleExpr(args[1])[0]
|
||||
return [f'*({dst}) = *({src})']
|
||||
return []
|
||||
|
||||
|
||||
class Addr:
|
||||
"""取地址"""
|
||||
def __init__(self, addr):
|
||||
self.addr = addr
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.Addr() 调用"""
|
||||
if args:
|
||||
expr = translator.HandleExpr(args[0])[0]
|
||||
if isinstance(expr, str):
|
||||
return [f'&{expr}']
|
||||
return [f'&{_to_str(expr)}']
|
||||
return ['0']
|
||||
|
||||
|
||||
class Deref:
|
||||
"""解引用"""
|
||||
def __init__(self, ptr):
|
||||
self.ptr = ptr
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.Deref() 调用"""
|
||||
if args:
|
||||
expr = translator.HandleExpr(args[0])[0]
|
||||
if hasattr(expr, 'op') and expr.op == '*':
|
||||
return [expr]
|
||||
return [f'*({_to_str(expr)})']
|
||||
return ['0']
|
||||
|
||||
|
||||
class DerefAs:
|
||||
"""解引用写入，等价于 *ptr = value"""
|
||||
def __init__(self, ptr, value):
|
||||
self.ptr = ptr
|
||||
self.value = value
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.DerefAs() 调用"""
|
||||
if len(args) >= 2:
|
||||
ptr = translator.HandleExpr(args[0])[0]
|
||||
val = translator.HandleExpr(args[1])[0]
|
||||
return [f'*({_to_str(ptr)}) = {_to_str(val)}']
|
||||
return []
|
||||
|
||||
|
||||
class Set:
|
||||
"""设置值"""
|
||||
def __init__(self, key, value):
|
||||
self.key = key
|
||||
self.value = value
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.Set() 调用"""
|
||||
if len(args) >= 2:
|
||||
target = translator.HandleExpr(args[0])[0]
|
||||
value = translator.HandleExpr(args[1])[0]
|
||||
return [f'{_to_str(target)} = {_to_str(value)}']
|
||||
return []
|
||||
|
||||
|
||||
class CReturn:
|
||||
"""多返回值装饰器
|
||||
|
||||
用于实现函数多返回值，通过匿名结构体返回实现。
|
||||
例如：@c.CReturn(t.CInt, t.CInt) 表示函数返回两个 int 值。
|
||||
等价于 -> tuple[t.CInt, t.CInt] 返回类型注解。
|
||||
|
||||
规则：
|
||||
1. CReturn 中有几个类型就说明要返回几个值
|
||||
2. 函数返回类型为匿名结构体 { type1, type2, ... }
|
||||
3. return 语句使用 insert_value 构建结构体
|
||||
4. 调用处使用 extract_value 提取各字段
|
||||
"""
|
||||
def __init__(self, *ReturnTypes):
|
||||
self.ReturnTypes = ReturnTypes
|
||||
|
||||
def __call__(self, func):
|
||||
"""装饰器调用"""
|
||||
# 将返回类型信息附加到函数上
|
||||
func._CreturnTypes = self.ReturnTypes
|
||||
return func
|
||||
|
||||
|
||||
class CDefine:
|
||||
"""#define 宏定义"""
|
||||
def __init__(self, name, value):
|
||||
self.name = name
|
||||
self.value = value
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CDefine() 调用"""
|
||||
if len(args) >= 1:
|
||||
if isinstance(args[0], ast.Constant):
|
||||
name = args[0].value
|
||||
else:
|
||||
name = 'MACRO'
|
||||
if len(args) >= 2:
|
||||
value = translator.HandleExpr(args[1])[0]
|
||||
return ['#define ' + str(name) + ' ' + _to_str(value)]
|
||||
return ['#define ' + str(name)]
|
||||
return []
|
||||
|
||||
|
||||
class CIfndef:
|
||||
"""#ifndef 条件编译"""
|
||||
def __init__(self, condition):
|
||||
self.condition = condition
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CIfndef() 调用"""
|
||||
if args:
|
||||
condition = translator.HandleExpr(args[0])[0]
|
||||
return ['#ifndef ' + _to_str(condition)]
|
||||
return ['#if 0']
|
||||
|
||||
class CIfdef:
|
||||
"""#ifdef 条件编译"""
|
||||
def __init__(self, condition):
|
||||
self.condition = condition
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CIfdef() 调用"""
|
||||
if args:
|
||||
condition = translator.HandleExpr(args[0])[0]
|
||||
return ['#ifdef ' + _to_str(condition)]
|
||||
return ['#if 0']
|
||||
|
||||
class CError:
|
||||
"""#error 错误信息"""
|
||||
def __init__(self, condition):
|
||||
self.condition = condition
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CError() 调用"""
|
||||
if args:
|
||||
# 如果是字符串常量，保留引号
|
||||
if isinstance(args[0], ast.Constant) and isinstance(args[0].value, str):
|
||||
return ['#error "' + args[0].value + '"']
|
||||
elif isinstance(args[0], ast.Str):
|
||||
return ['#error "' + args[0].s + '"']
|
||||
else:
|
||||
condition = translator.HandleExpr(args[0])[0]
|
||||
return ['#error ' + _to_str(condition)]
|
||||
return ['#error "Error: Condition is not met."']
|
||||
|
||||
|
||||
class TokenPast:
|
||||
"""## 连接符"""
|
||||
def __init__(self, left, right):
|
||||
self.left = left
|
||||
self.right = right
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.TokenPast() 调用"""
|
||||
if len(args) >= 2:
|
||||
# 处理左操作数 - 去掉引号
|
||||
if isinstance(args[0], ast.Constant):
|
||||
left = str(args[0].value)
|
||||
elif isinstance(args[0], ast.Str):
|
||||
left = str(args[0].s)
|
||||
elif isinstance(args[0], ast.Name):
|
||||
left = args[0].id
|
||||
else:
|
||||
left = _to_str(translator.HandleExpr(args[0])[0])
|
||||
|
||||
# 处理右操作数 - 去掉引号
|
||||
if isinstance(args[1], ast.Constant):
|
||||
right = str(args[1].value)
|
||||
elif isinstance(args[1], ast.Str):
|
||||
right = str(args[1].s)
|
||||
elif isinstance(args[1], ast.Name):
|
||||
right = args[1].id
|
||||
else:
|
||||
right = _to_str(translator.HandleExpr(args[1])[0])
|
||||
|
||||
# 返回字符串，但用特殊标记包装，让 _AstNodeToStr 能正确处理
|
||||
result = left + ' ## ' + right
|
||||
# 使用一个特殊的类来包装结果，让 _AstNodeToStr 直接返回其值
|
||||
class TokenPastResult:
|
||||
def __init__(self, value):
|
||||
self.value = value
|
||||
def __str__(self):
|
||||
return self.value
|
||||
return [TokenPastResult(result)]
|
||||
return ['']
|
||||
|
||||
|
||||
class CIf:
|
||||
"""#if 条件编译"""
|
||||
def __init__(self, condition):
|
||||
self.condition = condition
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CIf() 调用"""
|
||||
if args:
|
||||
condition = translator.HandleExpr(args[0])[0]
|
||||
return ['#if ' + _to_str(condition)]
|
||||
return ['#if 0']
|
||||
|
||||
|
||||
class CElif:
|
||||
"""#elif 条件编译"""
|
||||
def __init__(self, condition):
|
||||
self.condition = condition
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CElif() 调用"""
|
||||
if args:
|
||||
condition = translator.HandleExpr(args[0])[0]
|
||||
return ['#elif ' + _to_str(condition)]
|
||||
return ['#else']
|
||||
|
||||
|
||||
class CElse:
|
||||
"""#else 条件编译"""
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CElse() 调用"""
|
||||
return ['#else']
|
||||
|
||||
|
||||
class CEndif:
|
||||
"""#endif 条件编译"""
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CEndif() 调用"""
|
||||
return ['#endif']
|
||||
|
||||
|
||||
class CUndef:
|
||||
"""#undef 取消宏定义"""
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CUndef(name) 调用"""
|
||||
import ast
|
||||
if args:
|
||||
arg = args[0]
|
||||
if isinstance(arg, str):
|
||||
name = arg
|
||||
elif isinstance(arg, ast.Name):
|
||||
name = arg.id
|
||||
elif isinstance(arg, ast.Constant):
|
||||
name = str(arg.value)
|
||||
else:
|
||||
name = str(arg)
|
||||
return [f'#undef {name}']
|
||||
return ['#undef']
|
||||
|
||||
|
||||
class LLVMIR:
|
||||
"""内联 LLVM IR
|
||||
|
||||
用法: c.LLVMIR(f"add i32 {c.LInp(a)}, {c.LInp(b)}", t.CInt)
|
||||
或: c.LLVMIR(f"%{c.LOut(result)} = add i32 {c.LInp(a)}, {c.LInp(b)}", t.CInt)
|
||||
|
||||
c.LInp(expr) - 输入操作数，翻译后替换为对应的 LLVM 临时变量名
|
||||
c.LOut(expr) - 输出操作数，翻译后替换为对应的 LLVM 临时变量名
|
||||
"""
|
||||
def __init__(self, ir_template, ret_type=None):
|
||||
self.ir_template = ir_template
|
||||
self.ret_type = ret_type
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
return ['/* LLVMIR */']
|
||||
|
||||
|
||||
class LInp:
|
||||
"""LLVM IR 输入操作数标记
|
||||
|
||||
用法: c.LInp(expr) - 标记 expr 为输入操作数
|
||||
在 c.LLVMIR 的 f-string 中使用，翻译后替换为 %N 形式的操作数引用
|
||||
"""
|
||||
def __init__(self, value):
|
||||
self.value = value
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
return []
|
||||
|
||||
|
||||
class LOut:
|
||||
"""LLVM IR 输出操作数标记
|
||||
|
||||
用法: c.LOut(expr) - 标记 expr 为输出操作数
|
||||
在 c.LLVMIR 的 f-string 中使用，翻译后替换为 %N 形式的操作数引用
|
||||
"""
|
||||
def __init__(self, value):
|
||||
self.value = value
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
return []
|
||||
|
||||
|
||||
class CPragma:
|
||||
"""#pragma 指令
|
||||
|
||||
用于生成 C 语言的 #pragma 指令。
|
||||
例如：c.CPragma("GCC diagnostic push") 生成 #pragma GCC diagnostic push
|
||||
"""
|
||||
def __init__(self, directive):
|
||||
self.directive = directive
|
||||
|
||||
@staticmethod
|
||||
def HandleCall(translator, args, keywords):
|
||||
"""处理 c.CPragma() 调用"""
|
||||
if args:
|
||||
arg = args[0]
|
||||
if isinstance(arg, ast.Constant):
|
||||
directive = arg.value
|
||||
elif isinstance(arg, ast.Str):
|
||||
directive = arg.s
|
||||
else:
|
||||
expr = translator.HandleExpr(arg)[0]
|
||||
directive = _to_str(expr)
|
||||
return [f'#pragma {directive}']
|
||||
return ['#pragma']
|
||||
|
||||
|
||||
# C 库类字典，用于 HandleCSpecialCall
|
||||
Library_C = {
|
||||
'Asm': Asm,
|
||||
'Load': Load,
|
||||
'Addr': Addr,
|
||||
'Deref': Deref,
|
||||
'Set': Set,
|
||||
'AsmInp': AsmInp,
|
||||
'AsmOut': AsmOut,
|
||||
'CDefine': CDefine,
|
||||
'CIfndef': CIfndef,
|
||||
'CIfdef': CIfdef,
|
||||
'CIf': CIf,
|
||||
'CElif': CElif,
|
||||
'CElse': CElse,
|
||||
'CEndif': CEndif,
|
||||
'CUndef': CUndef,
|
||||
'CError': CError,
|
||||
'TokenPast': TokenPast,
|
||||
'CReturn': CReturn,
|
||||
'CPragma': CPragma,
|
||||
'LLVMIR': LLVMIR,
|
||||
'LInp': LInp,
|
||||
'LOut': LOut,
|
||||
}
|
||||
|
||||
|
||||
class Attribute:
|
||||
"""函数/变量属性装饰器"""
|
||||
def __init__(self, *attrs):
|
||||
self.attrs = attrs
|
||||
|
||||
def __call__(self, func):
|
||||
# 将属性附加到函数上
|
||||
func._c_attributes = self.attrs
|
||||
return func
|
||||
1283
CPython/t.py
1283
CPython/t.py
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user