修复了大量存在的问题，增加了假鸭子类型等等机制

lib/includes/c.py

@@ -1,37 +1,41 @@
 # C语法定义模块
+from __future__ import annotations
 
 import ast
 import sys
 import os
+import logging
+from typing import Any, Optional
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
 
 from . import t
+from lib.constants.config import mode as _config_mode
 
-def _to_str(node):
+def _to_str(node: Any) -> str:
     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__
+    NodeType: str = 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)
+        left: str = _to_str(node.left)
+        right: str = _to_str(node.right)
         return f'{left} {node.op} {right}'
     elif NodeType == 'UnaryOp':
-        expr = _to_str(node.expr)
+        expr: str = _to_str(node.expr)
         return f'{node.op}{expr}'
     else:
         return repr(node)
 
 class Asm:
     @staticmethod
-    def _parse_asm_descr(expr):
+    def _parse_asm_descr(expr: ast.AST) -> str:
         """递归解析AST节点，确保获取t.ASM_DESCR的实际值，支持|组合
         处理场景：
         1. t.ASM_DESCR.XXX → 取属性值
@@ -40,8 +44,8 @@ class Asm:
         """
         # 场景1：位或组合（XXX | YYY）
         if isinstance(expr, ast.BinOp):
-            left_val = Asm._parse_asm_descr(expr.left)
-            right_val = Asm._parse_asm_descr(expr.right)
+            left_val: str = Asm._parse_asm_descr(expr.left)
+            right_val: str = Asm._parse_asm_descr(expr.right)
             return left_val + right_val
 
         # 场景2：t.ASM_DESCR.XXX 多层属性访问
@@ -53,13 +57,13 @@ class Asm:
                     expr.value.value.id == 't' and
                     expr.value.attr == 'ASM_DESCR'):
                     # 取 t.ASM_DESCR.XXX 的实际值
-                    AttrName = expr.attr
+                    AttrName: str = 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
+                AttrName: str = expr.attr
                 if hasattr(t.ASM_DESCR, AttrName):
                     return getattr(t.ASM_DESCR, AttrName, "")
 
@@ -71,39 +75,39 @@ class Asm:
         return ""
 
     @staticmethod
-    def _extract_val_expr(translator, expr_node):
+    def _extract_val_expr(translator: Any, expr_node: ast.AST) -> str:
         """从AST表达式节点提取值表达式的字符串形式"""
-        val_ExprNode = translator.HandleExpr(expr_node)[0]
+        val_ExprNode: Any = translator.HandleExpr(expr_node)[0]
         if isinstance(val_ExprNode, str):
             return val_ExprNode
         try:
             return str(val_ExprNode)
         except Exception as _e:
-            if __import__('lib.constants.config', fromlist=['mode']).mode == "strict":
-                import logging; logging.warning(f"异常被忽略: {_e}")
+            if _config_mode == "strict":
+                logging.warning(f"异常被忽略: {_e}")
             return ''
 
     @staticmethod
-    def _parse_asm_template(translator, args):
+    def _parse_asm_template(translator: Any, args: list[ast.AST]) -> tuple[str, list[tuple[str, str]], list[tuple[str, str]], int]:
         """解析f-string或常量模板字符串，返回(asm_code, output_ops, input_ops, operand_seq)"""
-        output_ops = []
-        input_ops = []
-        operand_seq = 0
-        asm_code = ""
-        first_arg = args[0]
+        output_ops: list[tuple[str, str]] = []
+        input_ops: list[tuple[str, str]] = []
+        operand_seq: int = 0
+        asm_code: str = ""
+        first_arg: ast.AST = args[0]
 
         if isinstance(first_arg, ast.JoinedStr):
-            asm_parts = []
+            asm_parts: list[str] = []
             for part in first_arg.values:
                 if isinstance(part, ast.Constant):
                     asm_parts.append(part.value)
                 elif isinstance(part, ast.FormattedValue):
-                    expr = part.value
+                    expr: ast.AST = 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_expr = Asm._extract_val_expr(translator, call_node.args[0]) if len(call_node.args)>=1 else ""
-                        constraint = Asm._parse_asm_descr(call_node.args[1]) if len(call_node.args)>=2 else ""
+                        call_node: ast.Call = expr
+                        val_expr: str = Asm._extract_val_expr(translator, call_node.args[0]) if len(call_node.args)>=1 else ""
+                        constraint: str = Asm._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))
@@ -122,15 +126,15 @@ class Asm:
         return asm_code, output_ops, input_ops, operand_seq
 
     @staticmethod
-    def _parse_asm_operands(translator, args, keywords, output_ops, input_ops, operand_seq):
+    def _parse_asm_operands(translator: Any, args: list[ast.AST], keywords: list[ast.keyword], output_ops: list[tuple[str, str]], input_ops: list[tuple[str, str]], operand_seq: int) -> tuple[list[tuple[str, str]], list[tuple[str, str]], int]:
         """解析位置参数和关键字参数中的输出/输入操作数"""
 
-        def parse_operand(arg):
+        def parse_operand(arg: ast.AST) -> Optional[tuple[str, str, str]]:
             """解析 AsmInp/AsmOut 参数"""
             if isinstance(arg, ast.Call) and isinstance(arg.func, ast.Attribute) and arg.func.value.id == 'c':
-                call_node = arg
-                val_expr = Asm._extract_val_expr(translator, call_node.args[0]) if len(call_node.args)>=1 else ""
-                constraint = Asm._parse_asm_descr(call_node.args[1]) if len(call_node.args)>=2 else ""
+                call_node: ast.Call = arg
+                val_expr: str = Asm._extract_val_expr(translator, call_node.args[0]) if len(call_node.args)>=1 else ""
+                constraint: str = Asm._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)
@@ -140,7 +144,7 @@ class Asm:
 
         # 处理位置参数中的操作数
         for arg in args[1:]:
-            result = parse_operand(arg)
+            result: Optional[tuple[str, str, str]] = parse_operand(arg)
             if result:
                 direction, val_expr, constraint = result
                 if direction == 'out':
@@ -172,8 +176,8 @@ class Asm:
                         if isinstance(elt, ast.Tuple):
                             # 处理列表中的 (value, constraint) 元组格式
                             if len(elt.elts) >= 2:
-                                val_expr = Asm._extract_val_expr(translator, elt.elts[0]) if len(elt.elts) >= 1 else ""
-                                constraint = Asm._parse_asm_descr(elt.elts[1])
+                                val_expr: str = Asm._extract_val_expr(translator, elt.elts[0]) if len(elt.elts) >= 1 else ""
+                                constraint: str = Asm._parse_asm_descr(elt.elts[1])
                                 input_ops.append((val_expr, constraint))
                                 operand_seq += 1
                         else:
@@ -189,24 +193,24 @@ class Asm:
                 elif isinstance(kw.value, ast.Tuple):
                     # 处理 (value, constraint) 元组格式
                     if len(kw.value.elts) >= 2:
-                        val_expr = Asm._extract_val_expr(translator, kw.value.elts[0]) if len(kw.value.elts) >= 1 else ""
-                        constraint = Asm._parse_asm_descr(kw.value.elts[1])
+                        val_expr: str = Asm._extract_val_expr(translator, kw.value.elts[0]) if len(kw.value.elts) >= 1 else ""
+                        constraint: str = Asm._parse_asm_descr(kw.value.elts[1])
                         input_ops.append((val_expr, constraint))
                         operand_seq += 1
 
         return output_ops, input_ops, operand_seq
 
     @staticmethod
-    def _parse_asm_clobbers(args, keywords):
+    def _parse_asm_clobbers(args: list[ast.AST], keywords: list[ast.keyword]) -> list[str]:
         """解析位置参数和关键字参数中的破坏列表"""
-        clobbers = []
+        clobbers: list[str] = []
 
         # 处理位置参数中的破坏列表
         for arg in args[1:]:
             if isinstance(arg, ast.List):
                 # 解析破坏列表（支持|组合）
                 for elt in arg.elts:
-                    clobber_val = Asm._parse_asm_descr(elt)
+                    clobber_val: str = Asm._parse_asm_descr(elt)
                     if clobber_val:
                         clobbers.append(clobber_val)
 
@@ -216,29 +220,29 @@ class Asm:
                 # 处理 op 关键字参数 (clobber，破坏列表)
                 if isinstance(kw.value, ast.List):
                     for elt in kw.value.elts:
-                        clobber_val = Asm._parse_asm_descr(elt)
+                        clobber_val: str = Asm._parse_asm_descr(elt)
                         if clobber_val:
                             clobbers.append(clobber_val)
             elif kw.arg == 'clobber':
                 # 处理 clobber 关键字参数
                 if isinstance(kw.value, ast.List):
                     for elt in kw.value.elts:
-                        clobber_val = Asm._parse_asm_descr(elt)
+                        clobber_val: str = Asm._parse_asm_descr(elt)
                         if clobber_val:
                             clobbers.append(clobber_val)
 
         return clobbers
 
     @staticmethod
-    def _generate_asm_code(asm_code, output_ops, input_ops, clobbers, asm_format):
+    def _generate_asm_code(asm_code: str, output_ops: list[tuple[str, str]], input_ops: list[tuple[str, str]], clobbers: list[str], asm_format: str) -> list[str]:
         """格式化汇编代码并生成最终的__asm__代码字符串"""
         # 格式化汇编代码
-        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])
+        asm_lines: list[str] = [line.strip() for line in asm_code.split('\n') if line.strip()]
+        formatted_asm: str = '\n        '.join([f'"{line}\\n"' for line in asm_lines])
 
         # 拼接约束字符串
         # 输出约束：如果约束已包含 = 或 +，直接使用；否则添加 =
-        def format_constraint(constraint, is_output=True):
+        def format_constraint(constraint: str, is_output: bool = True) -> str:
             if not constraint:
                 return ""
             # 如果约束已包含修饰符，直接返回
@@ -247,12 +251,12 @@ class Asm:
             # 否则添加适当的修饰符
             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 ""
+        out_const: str = ', '.join([f'"{format_constraint(c, True)}"({v})' for v, c in output_ops]) if output_ops else ""
+        in_const: str = ', '.join([f'"{format_constraint(c, False)}"({v})' for v, c in input_ops]) if input_ops else ""
+        clobber_const: str = ', '.join([f'"{x}"' for x in clobbers]) if clobbers else ""
 
         # 构建约束部分：确保冒号格式正确
-        constraint_parts = []
+        constraint_parts: list[str] = []
         # 输出约束
         if output_ops:
             constraint_parts.append(f': {out_const}')
@@ -269,12 +273,12 @@ class Asm:
         if clobbers:
             constraint_parts.append(f': {clobber_const}')
 
-        constraint_str = ' '.join(constraint_parts)
+        constraint_str: str = ' '.join(constraint_parts)
 
         # 生成最终代码
         if asm_format == 'ARM':
             # ARM 使用 .arch 指令和不同的内联汇编语法
-            final_asm = f'__asm__ __volatile__ (\n        {formatted_asm} {constraint_str});'
+            final_asm: str = f'__asm__ __volatile__ (\n        {formatted_asm} {constraint_str});'
         elif asm_format == 'AT&T':
             # AT&T 语法不需要额外标记，GCC 默认就是 AT&T
             final_asm = f'__asm__ __volatile__ (\n        {formatted_asm} {constraint_str});'
@@ -284,11 +288,15 @@ class Asm:
         return [final_asm]
 
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: list[ast.AST], keywords: list[ast.keyword]) -> list[str]:
         if not args:
             return ['__asm__ volatile ("nop");']
 
         # 解析模板
+        asm_code: str
+        output_ops: list[tuple[str, str]]
+        input_ops: list[tuple[str, str]]
+        operand_seq: int
         asm_code, output_ops, input_ops, operand_seq = Asm._parse_asm_template(translator, args)
 
         # 解析操作数
@@ -296,10 +304,10 @@ class Asm:
             translator, args, keywords, output_ops, input_ops, operand_seq)
 
         # 解析破坏列表
-        clobbers = Asm._parse_asm_clobbers(args, keywords)
+        clobbers: list[str] = Asm._parse_asm_clobbers(args, keywords)
 
         # 解析汇编格式
-        asm_format = 'Intel'
+        asm_format: str = 'Intel'
         for kw in keywords:
             if kw.arg == 'format':
                 if isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
@@ -309,19 +317,19 @@ class Asm:
         return Asm._generate_asm_code(asm_code, output_ops, input_ops, clobbers, asm_format)
 
 class AsmInp:
-    def __init__(self, value, constraint):
-        self.value = value
-        self.constraint = constraint
+    def __init__(self, value: Any, constraint: Any) -> None:
+        self.value: Any = value
+        self.constraint: Any = constraint
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[Any]:
         return []
 
 class AsmOut:
-    def __init__(self, value, constraint):
-        self.value = value
-        self.constraint = constraint
+    def __init__(self, value: Any, constraint: Any) -> None:
+        self.value: Any = value
+        self.constraint: Any = constraint
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[Any]:
         return []
 
 class NoBreak:
@@ -334,29 +342,29 @@ class Break:
 
 class Load:
     """解引用a写入b，等价于 *b = *a，无拷贝副作用"""
-    def __init__(self, src, dst):
-        self.src = src
-        self.dst = dst
+    def __init__(self, src: Any, dst: Any) -> None:
+        self.src: Any = src
+        self.dst: Any = dst
 
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         if len(args) >= 2:
-            src = translator.HandleExpr(args[0])[0]
-            dst = translator.HandleExpr(args[1])[0]
+            src: Any = translator.HandleExpr(args[0])[0]
+            dst: Any = translator.HandleExpr(args[1])[0]
             return [f'*({dst}) = *({src})']
         return []
 
 
 class Addr:
     """取地址"""
-    def __init__(self, addr):
-        self.addr = addr
+    def __init__(self, addr: Any) -> None:
+        self.addr: Any = addr
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.Addr() 调用"""
         if args:
-            expr = translator.HandleExpr(args[0])[0]
+            expr: Any = translator.HandleExpr(args[0])[0]
             if isinstance(expr, str):
                 return [f'&{expr}']
             return [f'&{_to_str(expr)}']
@@ -365,14 +373,14 @@ class Addr:
 
 class Deref:
     """解引用"""
-    def __init__(self, ptr):
-        self.ptr = ptr
+    def __init__(self, ptr: Any) -> None:
+        self.ptr: Any = ptr
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.Deref() 调用"""
         if args:
-            expr = translator.HandleExpr(args[0])[0]
+            expr: Any = translator.HandleExpr(args[0])[0]
             if hasattr(expr, 'op') and expr.op == '*':
                 return [expr]
             return [f'*({_to_str(expr)})']
@@ -381,32 +389,32 @@ class Deref:
 
 class DerefAs:
     """解引用写入，等价于 *ptr = value"""
-    def __init__(self, ptr, value):
-        self.ptr = ptr
-        self.value = value
+    def __init__(self, ptr: Any, value: Any) -> None:
+        self.ptr: Any = ptr
+        self.value: Any = value
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.DerefAs() 调用"""
         if len(args) >= 2:
-            ptr = translator.HandleExpr(args[0])[0]
-            val = translator.HandleExpr(args[1])[0]
+            ptr: Any = translator.HandleExpr(args[0])[0]
+            val: Any = 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
+    def __init__(self, key: Any, value: Any) -> None:
+        self.key: Any = key
+        self.value: Any = value
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.Set() 调用"""
         if len(args) >= 2:
-            target = translator.HandleExpr(args[0])[0]
-            value = translator.HandleExpr(args[1])[0]
+            target: Any = translator.HandleExpr(args[0])[0]
+            value: Any = translator.HandleExpr(args[1])[0]
             return [f'{_to_str(target)} = {_to_str(value)}']
         return []
 
@@ -424,10 +432,10 @@ class CReturn:
     3. return 语句使用 insert_value 构建结构体
     4. 调用处使用 extract_value 提取各字段
     """
-    def __init__(self, *ReturnTypes):
-        self.ReturnTypes = ReturnTypes
+    def __init__(self, *ReturnTypes: Any) -> None:
+        self.ReturnTypes: tuple[Any, ...] = ReturnTypes
     
-    def __call__(self, func):
+    def __call__(self, func: Any) -> Any:
         """装饰器调用"""
         # 将返回类型信息附加到函数上
         func._CreturnTypes = self.ReturnTypes
@@ -436,20 +444,20 @@ class CReturn:
 
 class CDefine:
     """#define 宏定义"""
-    def __init__(self, name, value):
-        self.name = name
-        self.value = value
+    def __init__(self, name: Any, value: Any) -> None:
+        self.name: Any = name
+        self.value: Any = value
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CDefine() 调用"""
         if len(args) >= 1:
             if isinstance(args[0], ast.Constant):
-                name = args[0].value
+                name: Any = args[0].value
             else:
                 name = 'MACRO'
             if len(args) >= 2:
-                value = translator.HandleExpr(args[1])[0]
+                value: Any = translator.HandleExpr(args[1])[0]
                 return ['#define ' + str(name) + ' ' + _to_str(value)]
             return ['#define ' + str(name)]
         return []
@@ -457,65 +465,61 @@ class CDefine:
 
 class CIfndef:
     """#ifndef 条件编译"""
-    def __init__(self, condition):
-        self.condition = condition
+    def __init__(self, condition: Any) -> None:
+        self.condition: Any = condition
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CIfndef() 调用"""
         if args:
-            condition = translator.HandleExpr(args[0])[0]
+            condition: Any = translator.HandleExpr(args[0])[0]
             return ['#ifndef ' + _to_str(condition)]
         return ['#if 0']
 
 class CIfdef:
     """#ifdef 条件编译"""
-    def __init__(self, condition):
-        self.condition = condition
+    def __init__(self, condition: Any) -> None:
+        self.condition: Any = condition
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CIfdef() 调用"""
         if args:
-            condition = translator.HandleExpr(args[0])[0]
+            condition: Any = translator.HandleExpr(args[0])[0]
             return ['#ifdef ' + _to_str(condition)]
         return ['#if 0']
 
 class CError:
     """#error 错误信息"""
-    def __init__(self, condition):
-        self.condition = condition
+    def __init__(self, condition: Any) -> None:
+        self.condition: Any = condition
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 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]
+                condition: Any = 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
+    def __init__(self, left: Any, right: Any) -> None:
+        self.left: Any = left
+        self.right: Any = right
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[Any]:
         """处理 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)
+                left: str = str(args[0].value)
             elif isinstance(args[0], ast.Name):
                 left = args[0].id
             else:
@@ -523,21 +527,19 @@ class TokenPast:
             
             # 处理右操作数 - 去掉引号
             if isinstance(args[1], ast.Constant):
-                right = str(args[1].value)
-            elif isinstance(args[1], ast.Str):
-                right = str(args[1].s)
+                right: str = str(args[1].value)
             elif isinstance(args[1], ast.Name):
                 right = args[1].id
             else:
                 right = _to_str(translator.HandleExpr(args[1])[0])
             
             # 返回字符串，但用特殊标记包装，让 _AstNodeToStr 能正确处理
-            result = left + ' ## ' + right
+            result: str = left + ' ## ' + right
             # 使用一个特殊的类来包装结果，让 _AstNodeToStr 直接返回其值
             class TokenPastResult:
-                def __init__(self, value):
-                    self.value = value
-                def __str__(self):
+                def __init__(self, value: str) -> None:
+                    self.value: str = value
+                def __str__(self) -> str:
                     return self.value
             return [TokenPastResult(result)]
         return ['']
@@ -545,67 +547,66 @@ class TokenPast:
 
 class CIf:
     """#if 条件编译"""
-    def __init__(self, condition):
-        self.condition = condition
+    def __init__(self, condition: Any) -> None:
+        self.condition: Any = condition
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CIf() 调用"""
         if args:
-            condition = translator.HandleExpr(args[0])[0]
+            condition: Any = translator.HandleExpr(args[0])[0]
             return ['#if ' + _to_str(condition)]
         return ['#if 0']
 
 
 class CElif:
     """#elif 条件编译"""
-    def __init__(self, condition):
-        self.condition = condition
+    def __init__(self, condition: Any) -> None:
+        self.condition: Any = condition
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CElif() 调用"""
         if args:
-            condition = translator.HandleExpr(args[0])[0]
+            condition: Any = translator.HandleExpr(args[0])[0]
             return ['#elif ' + _to_str(condition)]
         return ['#else']
 
 
 class CElse:
     """#else 条件编译"""
-    def __init__(self):
+    def __init__(self) -> None:
         pass
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CElse() 调用"""
         return ['#else']
 
 
 class CEndif:
     """#endif 条件编译"""
-    def __init__(self):
+    def __init__(self) -> None:
         pass
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CEndif() 调用"""
         return ['#endif']
 
 
 class CUndef:
     """#undef 取消宏定义"""
-    def __init__(self, name):
-        self.name = name
+    def __init__(self, name: Any) -> None:
+        self.name: Any = name
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CUndef(name) 调用"""
-        import ast
         if args:
-            arg = args[0]
+            arg: Any = args[0]
             if isinstance(arg, str):
-                name = arg
+                name: str = arg
             elif isinstance(arg, ast.Name):
                 name = arg.id
             elif isinstance(arg, ast.Constant):
@@ -625,12 +626,12 @@ class LLVMIR:
     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
+    def __init__(self, ir_template: Any, ret_type: Any = None) -> None:
+        self.ir_template: Any = ir_template
+        self.ret_type: Any = ret_type
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         return ['/* LLVMIR */']
 
 
@@ -640,11 +641,11 @@ class LInp:
     用法: c.LInp(expr) - 标记 expr 为输入操作数
     在 c.LLVMIR 的 f-string 中使用，翻译后替换为 %N 形式的操作数引用
     """
-    def __init__(self, value):
-        self.value = value
+    def __init__(self, value: Any) -> None:
+        self.value: Any = value
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[Any]:
         return []
 
 
@@ -654,11 +655,11 @@ class LOut:
     用法: c.LOut(expr) - 标记 expr 为输出操作数
     在 c.LLVMIR 的 f-string 中使用，翻译后替换为 %N 形式的操作数引用
     """
-    def __init__(self, value):
-        self.value = value
+    def __init__(self, value: Any) -> None:
+        self.value: Any = value
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[Any]:
         return []
 
 
@@ -668,20 +669,18 @@ class CPragma:
     用于生成 C 语言的 #pragma 指令。
     例如：c.CPragma("GCC diagnostic push") 生成 #pragma GCC diagnostic push
     """
-    def __init__(self, directive):
-        self.directive = directive
+    def __init__(self, directive: Any) -> None:
+        self.directive: Any = directive
     
     @staticmethod
-    def HandleCall(translator, args, keywords):
+    def HandleCall(translator: Any, args: Any, keywords: Any) -> list[str]:
         """处理 c.CPragma() 调用"""
         if args:
-            arg = args[0]
+            arg: Any = args[0]
             if isinstance(arg, ast.Constant):
-                directive = arg.value
-            elif isinstance(arg, ast.Str):
-                directive = arg.s
+                directive: Any = arg.value
             else:
-                expr = translator.HandleExpr(arg)[0]
+                expr: Any = translator.HandleExpr(arg)[0]
                 directive = _to_str(expr)
             return [f'#pragma {directive}']
         return ['#pragma']
@@ -716,10 +715,10 @@ Library_C = {
 
 class Attribute:
     """函数/变量属性装饰器"""
-    def __init__(self, *attrs):
-        self.attrs = attrs
+    def __init__(self, *attrs: Any) -> None:
+        self.attrs: tuple[Any, ...] = attrs
     
-    def __call__(self, func):
+    def __call__(self, func: Any) -> Any:
         # 将属性附加到函数上
         func._c_attributes = self.attrs
         return func