l0n0lc 0.8.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

l0n0lc//347/261/273/346/224/257/346/214/201.py

@@ -0,0 +1,372 @@
+import ast
+import inspect
+import sys
+import traceback
+from .工具 import 全局上下文
+from .cpp类型 import C变量
+from .异常 import Jit错误
+from .代码生成 import 代码生成器, 参数处理器
+from .基础混入 import 错误处理混入, 类型处理混入
+
+
+class 类支持处理器(错误处理混入, 类型处理混入):
+    """处理类定义相关的功能"""
+
+    def __init__(self, transpiler):
+        self.transpiler = transpiler
+
+    def 处理类定义(self, node: ast.ClassDef):
+        """处理类定义"""
+        if node.name != self.transpiler.函数名:
+            self.抛出错误(f"Nested classes not supported: {node.name}", node)
+
+        # 0. 处理基类（继承）
+        self.处理基类(node)
+
+        # 1. 扫描成员变量（支持默认值）
+        self.扫描成员变量(node)
+
+        # 2. 访问方法
+        self.处理类方法(node)
+
+    def 处理基类(self, node: ast.ClassDef):
+        """处理基类继承"""
+        if node.bases:
+            for base in node.bases:
+                if isinstance(base, ast.Name):
+                    base_class = self.transpiler.获取值(base)
+                    if base_class and inspect.isclass(base_class):
+                        self.transpiler.类基类列表.append(base_class)
+                        # 将基类添加到依赖中
+                        try:
+                            base_transpiler = type(self.transpiler)(
+                                base_class, self.transpiler.编译器
+                            )
+                            base_transpiler.编译()  # 需要编译基类以生成头文件和实现
+                            self.transpiler.依赖函数.append(base_transpiler)
+                        except Exception as e:
+                            # 如果基类无法编译，记录警告但不阻止编译
+                            print(
+                                f"Warning: Failed to compile base class '{base_class.__name__}': {str(e)}",
+                                file=sys.stderr,
+                            )
+                            if traceback.format_exc():
+                                print(
+                                    f"Base class compilation traceback:\n{traceback.format_exc()}",
+                                    file=sys.stderr,
+                                )
+
+    def 扫描成员变量(self, node: ast.ClassDef):
+        """扫描类的成员变量"""
+        for stmt in node.body:
+            if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name):
+                self.处理注解赋值(stmt)
+
+            # 检测类变量（以'_'开头的变量，视为静态成员）
+            elif isinstance(stmt, ast.Assign):
+                self.处理赋值语句(stmt)
+
+    def 处理注解赋值(self, stmt: ast.AnnAssign):
+        """处理带有类型注解的赋值语句"""
+        from .表达式处理 import 表达式访问者
+
+        expr_visitor = 表达式访问者(self.transpiler)
+
+        py_type = expr_visitor.获取值(stmt.annotation)
+        c_type = self.解析类型(py_type)
+        # 类型注解：我们已经检查过stmt.target是ast.Name类型
+        member_name = stmt.target.id  # type: ignore[attr-defined]
+
+        # 检查是否是以'_'开头的静态成员
+        if member_name.startswith("_"):
+            # 这是静态成员
+            static_type = str(c_type)
+            static_value = 0  # 默认值，如果没有显式赋值的话
+            if stmt.value is not None:
+                static_value = expr_visitor.获取值(stmt.value)
+            self.transpiler.类静态成员[member_name] = (static_type, static_value)
+        else:
+            # 这是普通实例成员
+            self.transpiler.类成员变量[member_name] = str(c_type)
+
+            # 检查是否有默认值
+            if stmt.value is not None:
+                default_val = expr_visitor.获取值(stmt.value)
+                self.transpiler.类成员默认值[member_name] = default_val
+
+    def 处理赋值语句(self, stmt: ast.Assign):
+        """处理赋值语句（用于类变量）"""
+        from .表达式处理 import 表达式访问者
+
+        expr_visitor = 表达式访问者(self.transpiler)
+
+        for target in stmt.targets:
+            if isinstance(target, ast.Name):
+                # 检查变量名是否以'_'开头
+                static_name = target.id  # type: ignore[attr-defined]
+                if static_name.startswith("_"):
+                    # 这是一个静态成员
+                    static_value = expr_visitor.获取值(stmt.value)
+                    # 尝试推断类型
+                    if isinstance(static_value, bool):
+                        static_type = "bool"
+                    elif isinstance(static_value, int):
+                        static_type = "int64_t"
+                    elif isinstance(static_value, float):
+                        static_type = "double"
+                    elif isinstance(static_value, str):
+                        static_type = "const char*"
+                    else:
+                        static_type = "auto"
+                    self.transpiler.类静态成员[static_name] = (
+                        static_type,
+                        static_value,
+                    )
+
+    def 处理类方法(self, node: ast.ClassDef):
+        """处理类方法"""
+        for stmt in node.body:
+            if isinstance(stmt, ast.FunctionDef):
+                self.处理单个方法(stmt)
+
+    def 处理单个方法(self, node: ast.FunctionDef):
+        """处理单个类方法"""
+        # 设置当前方法名
+        self.transpiler.当前方法名 = node.name
+        # 重置当前方法参数，避免方法间干扰
+        self.transpiler.当前方法参数 = {}
+        # 同时清空列表参数映射
+        self.transpiler.列表参数映射 = {}
+
+        # 处理方法
+        self.访问方法节点(node)
+
+    def 访问方法节点(self, node: ast.FunctionDef):
+        """访问方法节点（类似于原visit_FunctionDef但针对类方法）"""
+        is_init = node.name == "__init__"
+
+        # 检测装饰器
+        decorators = []
+        for decorator in node.decorator_list:
+            if isinstance(decorator, ast.Name):
+                decorators.append(decorator.id)
+                if decorator.id == "classmethod":
+                    self.抛出错误("@classmethod is not supported", decorator)
+
+        is_static = "staticmethod" in decorators
+        is_property = "property" in decorators
+
+        # 检测运算符重载
+        operator_map = {
+            "__add__": "operator+",
+            "__sub__": "operator-",
+            "__mul__": "operator*",
+            "__truediv__": "operator/",
+            "__mod__": "operator%",
+            "__eq__": "operator==",
+            "__ne__": "operator!=",
+            "__lt__": "operator<",
+            "__le__": "operator<=",
+            "__gt__": "operator>",
+            "__ge__": "operator>=",
+            "__getitem__": "operator[]",
+        }
+
+        is_operator = node.name in operator_map
+        method_name = operator_map.get(node.name, node.name)
+
+        # 构造函数名为类名
+        if is_init:
+            method_name = self.transpiler.函数名
+
+        c_ret_type = ""
+
+        # 创建临时代码缓冲区用于方法体（使用 StringIO 优化性能）
+        import io
+        方法缓冲区 = io.StringIO()
+
+        # 保存原始的参数变量字典（用于恢复）
+        original_param_vars = self.transpiler.参数变量
+        self.transpiler.参数变量 = {}  # 临时清空，让 visit_arguments 填充到这里
+
+        # 参数处理
+        args_node = node.args
+        original_args = list(args_node.args)
+
+        # 检查第一个参数 (self/cls)
+        first_arg_name = None
+        first_arg_type = None
+
+        if not is_static and original_args:
+            first_arg = original_args[0]
+            first_arg_name = first_arg.arg
+
+            # 实例方法：第一个参数是 self
+            first_arg_type = f"{self.transpiler.函数名}*"
+
+            # 从参数列表中移除 self，使其不出现在 C++ 参数签名中
+            args_node.args = original_args[1:]
+
+        # 为方法体创建新的作用域
+        # 临时替换全局缓冲区为方法缓冲区
+        原始缓冲区 = self.transpiler.代码缓冲区
+        self.transpiler.代码缓冲区 = 方法缓冲区
+
+        with self.transpiler.代码块上下文:
+            # 注册 self 变量 (作为 this 指针)
+            if first_arg_name and not is_static and first_arg_type:
+                self_var = C变量(first_arg_type, first_arg_name, False)
+                self_var.C名称 = "this"  # 实例方法映射到 C++ this
+                self.transpiler.添加C变量(self_var)
+
+            # 处理方法参数
+
+            param_processor = 参数处理器(self.transpiler)
+            param_processor.处理参数列表(args_node)
+
+            # 将参数从 self.参数变量 复制到 self.当前方法参数
+            self.transpiler.当前方法参数 = dict(self.transpiler.参数变量)
+
+            for stmt in node.body:
+                self.transpiler.visit(stmt)
+
+        # 获取生成的代码块（从临时缓冲区）
+        method_body = 方法缓冲区.getvalue().strip().split('\n') if 方法缓冲区.getvalue().strip() else []
+
+        # 恢复原始缓冲区和参数变量
+        self.transpiler.代码缓冲区 = 原始缓冲区
+        self.transpiler.参数变量 = original_param_vars
+
+        # 确定返回类型
+        c_ret_type = self.推断返回类型(node, is_init)
+
+        # 存储方法信息
+        self.transpiler.类方法列表.append(
+            {
+                "name": method_name,
+                "ret_type": c_ret_type,
+                "body": method_body,
+                "is_init": is_init,
+                "is_static": is_static,
+                "is_property": is_property,
+                "is_operator": is_operator,
+                "params": self._构建当前参数列表字符串(),
+            }
+        )
+
+    def 推断返回类型(self, node: ast.FunctionDef, is_init: bool):
+        """推断方法的返回类型"""
+        if is_init:
+            return ""  # 构造函数无返回类型部分
+
+        from .表达式处理 import 表达式访问者
+
+        expr_visitor = 表达式访问者(self.transpiler)
+
+        ret_py_type = expr_visitor.获取值(node.returns, is_type_annotation=True)
+
+        if isinstance(node.returns, ast.Name):
+            # 处理名称类型注解（如 int, str, float 等）
+            # 处理自定义类类型
+            if inspect.isclass(ret_py_type):
+                # 首先检查是否有类型映射
+                mapped_type = 全局上下文.类型映射表.get(ret_py_type)
+                if mapped_type:
+                    # 使用映射的类型
+                    c_ret_type = mapped_type.目标类型
+                    # 添加需要包含的头文件
+                    if mapped_type.包含目录:
+                        self.transpiler.包含头文件.update(mapped_type.包含目录)
+                elif ret_py_type.__module__ == "builtins":
+                    c_ret_type = str(self.解析类型(ret_py_type))
+                else:
+                    # 用户自定义类
+                    c_ret_type = ret_py_type.__name__
+            else:
+                c_ret_type = str(self.解析类型(ret_py_type))
+        elif isinstance(node.returns, ast.Constant):
+            # 处理字符串类型注解（如 'Vector2D'）
+            if isinstance(ret_py_type, str) and ret_py_type not in [
+                "int",
+                "float",
+                "str",
+                "bool",
+                "void",
+            ]:
+                # 尝试从全局变量中查找对应的类
+                if ret_py_type in self.transpiler.全局变量:
+                    potential_class = self.transpiler.全局变量[ret_py_type]
+                    if inspect.isclass(potential_class):
+                        ret_py_type = potential_class
+
+            # 处理自定义类类型
+            if inspect.isclass(ret_py_type):
+                # 首先检查是否有类型映射
+                mapped_type = 全局上下文.类型映射表.get(ret_py_type)
+                if mapped_type:
+                    # 使用映射的类型
+                    c_ret_type = mapped_type.目标类型
+                    # 添加需要包含的头文件
+                    if mapped_type.包含目录:
+                        self.transpiler.包含头文件.update(mapped_type.包含目录)
+                elif ret_py_type.__module__ == "builtins":
+                    c_ret_type = str(self.解析类型(ret_py_type))
+                else:
+                    # 用户自定义类
+                    c_ret_type = ret_py_type.__name__
+            else:
+                c_ret_type = str(self.解析类型(ret_py_type))
+
+        elif node.returns is None:
+            # 没有类型注解，需要根据函数体推断返回类型
+            # 检查函数体中是否有返回语句
+            return_stmt = None
+            for stmt in node.body:
+                if isinstance(stmt, ast.Return):
+                    return_stmt = stmt
+                    break
+
+            if return_stmt and return_stmt.value is not None:
+                # 有返回语句但没有类型注解，尝试推断返回值类型
+                if isinstance(return_stmt.value, ast.Call):
+                    # 检查函数调用
+                    call_node = return_stmt.value
+                    if isinstance(call_node.func, ast.Name):
+                        # 函数调用，如 Vector2D()
+                        func_name = call_node.func.id
+                        # 检查是否是当前类的构造函数调用
+                        if func_name == self.transpiler.函数名:
+                            # 构造函数调用返回当前类类型
+                            c_ret_type = self.transpiler.函数名
+                        else:
+                            # 其他函数使用auto
+                            c_ret_type = "auto"
+                    else:
+                        # 其他类型的调用使用auto
+                        c_ret_type = "auto"
+                elif isinstance(return_stmt.value, ast.Constant):
+                    # 常量返回值
+                    if isinstance(return_stmt.value.value, bool):
+                        c_ret_type = "bool"
+                    elif isinstance(return_stmt.value.value, int):
+                        c_ret_type = "int64_t"
+                    elif isinstance(return_stmt.value.value, float):
+                        c_ret_type = "double"
+                    else:
+                        c_ret_type = "auto"
+                else:
+                    # 其他表达式使用auto
+                    c_ret_type = "auto"
+            else:
+                # 没有返回语句或返回值为None，设为void
+                c_ret_type = "void"
+        else:
+            c_ret_type = "auto"
+
+        return c_ret_type
+
+    def _构建当前参数列表字符串(self):
+        """构建方法的参数列表字符串"""
+
+        generator = 代码生成器(self.transpiler)
+        return generator.构建当前参数列表字符串()

l0n0lc//347/274/226/350/257/221/344/270/212/344/270/213/346/226/207.py

@@ -0,0 +1,132 @@
+"""
+编译上下文模块
+
+提供编译实例的上下文，代替部分全局状态。
+每个转译器实例拥有独立的编译上下文，避免全局状态滥用。
+"""
+
+from typing import Set, Dict, Any
+
+
+class 编译上下文:
+    """
+    编译实例的上下文
+
+    每个转译器实例拥有独立的编译上下文，用于管理：
+    - 编译栈：防止循环编译
+    - 变量ID生成
+    - 包含头文件
+    - 链接库
+
+    相比全局上下文，这些状态应该是实例级别的，而不是全局的。
+    """
+
+    def __init__(self, 工作目录: str = "./l0n0lcoutput"):
+        """
+        初始化编译上下文
+
+        Args:
+            工作目录: 编译输出目录
+        """
+        self.工作目录 = 工作目录
+        self.编译栈: Set[str] = set()  # 防止循环编译的栈
+        self.最大变量ID = 0  # 变量ID生成器
+        self.包含头文件: Set[str] = set()  # 需要包含的头文件
+        self.链接库: Set[str] = set()  # 需要链接的库
+        self.库搜索目录: Set[str] = set()  # 库搜索目录
+
+    def 生成变量ID(self) -> int:
+        """
+        生成唯一的变量ID
+
+        Returns:
+            新的变量ID
+        """
+        self.最大变量ID += 1
+        return self.最大变量ID
+
+    def 添加包含头文件(self, 头文件: str):
+        """
+        添加需要包含的头文件
+
+        Args:
+            头文件: 头文件路径，如 <stdint.h> 或 "myheader.h"
+        """
+        self.包含头文件.add(头文件)
+
+    def 添加链接库(self, 库名: str):
+        """
+        添加需要链接的库
+
+        Args:
+            库名: 库名称，如 "m" (数学库)
+        """
+        self.链接库.add(库名)
+
+    def 添加库搜索目录(self, 目录: str):
+        """
+        添加库搜索目录
+
+        Args:
+            目录: 库搜索目录路径
+        """
+        self.库搜索目录.add(目录)
+
+    def 入栈编译(self, 标识: str):
+        """
+        将函数标识压入编译栈
+
+        Args:
+            标识: 函数的唯一标识
+
+        Raises:
+            RuntimeError: 如果检测到循环编译
+        """
+        if 标识 in self.编译栈:
+            raise RuntimeError(f"检测到循环编译: {标识}")
+        self.编译栈.add(标识)
+
+    def 出栈编译(self, 标识: str):
+        """
+        将函数标识从编译栈弹出
+
+        Args:
+            标识: 函数的唯一标识
+        """
+        self.编译栈.discard(标识)
+
+    def 是否正在编译(self, 标识: str) -> bool:
+        """
+        检查函数是否正在编译
+
+        Args:
+            标识: 函数的唯一标识
+
+        Returns:
+            是否正在编译
+        """
+        return 标识 in self.编译栈
+
+    def 重置(self):
+        """重置编译上下文（用于重复使用）"""
+        self.编译栈.clear()
+        self.最大变量ID = 0
+        self.包含头文件.clear()
+        self.链接库.clear()
+        self.库搜索目录.clear()
+
+    def 获取状态摘要(self) -> Dict[str, Any]:
+        """
+        获取编译上下文的当前状态摘要
+
+        Returns:
+            包含当前状态的字典
+        """
+        return {
+            "工作目录": self.工作目录,
+            "编译栈大小": len(self.编译栈),
+            "最大变量ID": self.最大变量ID,
+            "包含头文件数量": len(self.包含头文件),
+            "链接库数量": len(self.链接库),
+            "库搜索目录数量": len(self.库搜索目录),
+        }

l0n0lc//347/274/226/350/257/221/347/256/241/347/220/206/345/231/250.py

@@ -0,0 +1,171 @@
+"""
+编译管理器模块
+
+负责管理编译过程、缓存管理和清理操作。
+从 Py转Cpp转译器 中分离出来，实现单一职责原则。
+"""
+
+from typing import List, Optional, Callable, Any
+from .文件管理器 import 文件管理器
+from .编译上下文 import 编译上下文
+from .cpp编译器 import Cpp编译器
+from .日志工具 import 日志
+
+
+class 编译管理器:
+    """
+    编译管理器
+
+    负责：
+    - 编译过程管理
+    - 缓存验证和清理
+    - 依赖管理
+    """
+
+    def __init__(
+        self,
+        文件管理器: 文件管理器,
+        编译器: Cpp编译器,
+        编译上下文: 编译上下文
+    ):
+        """
+        初始化编译管理器
+
+        Args:
+            文件管理器: 文件管理器实例
+            编译器: C++ 编译器实例
+            编译上下文: 编译上下文实例
+        """
+        self.文件管理器 = 文件管理器
+        self.编译器 = 编译器
+        self.编译上下文 = 编译上下文
+
+    def 检查缓存完整性(self, 获取文件名列表) -> List[str]:
+        """
+        检查缓存文件的完整性
+
+        Args:
+            获取文件名列表: 返回 (cpp文件名, 头文件名, 库文件名) 的函数
+
+        Returns:
+            问题列表，如果为空表示缓存完整
+        """
+        try:
+            cpp_file名, 头文件名, 库文件名 = 获取文件名列表()
+
+            issues = []
+
+            # 检查源文件是否存在且可读
+            if self.文件管理器.文件是否存在(cpp_file名):
+                if not self.文件管理器.文件是否可读(cpp_file名):
+                    issues.append(f"源文件不可读: {cpp_file名}")
+            else:
+                issues.append(f"源文件不存在: {cpp_file名}")
+
+            # 检查头文件
+            if self.文件管理器.文件是否存在(头文件名):
+                if not self.文件管理器.文件是否可读(头文件名):
+                    issues.append(f"头文件不可读: {头文件名}")
+
+            # 检查库文件
+            if self.文件管理器.文件是否存在(库文件名):
+                if not self.文件管理器.文件是否可读(库文件名):
+                    issues.append(f"库文件不可读: {库文件名}")
+
+            return issues
+
+        except Exception as e:
+            return [f"缓存完整性检查失败: {str(e)}"]
+
+    def 清理编译文件(self, 文件名列表: List[str]):
+        """
+        清理编译文件
+
+        Args:
+            文件名列表: 需要清理的文件名列表
+        """
+        try:
+            self.文件管理器.清理编译文件(文件名列表)
+
+            # 清理临时文件（使用第一个文件名的基础名称）
+            if 文件名列表:
+                基础名称 = 文件名列表[0].rsplit('.', 1)[0] if '.' in 文件名列表[0] else 文件名列表[0]
+                self.文件管理器.清理临时文件(基础名称)
+
+        except (OSError, IOError) as e:
+            # 清理过程中的错误不应该掩盖原始错误
+            日志.调试(f"清理文件时出错: {e}")
+        except Exception as e:
+            # 其他未预期的异常
+            日志.警告(f"清理文件时发生未预期错误: {e}")
+
+    def 清理所有缓存(self) -> int:
+        """
+        清理所有缓存文件
+
+        Returns:
+            清理的文件数量
+        """
+        try:
+            return self.文件管理器.清理所有缓存()
+        except (OSError, IOError) as e:
+            日志.调试(f"清理缓存时出错: {e}")
+            return 0
+        except Exception as e:
+            日志.警告(f"清理缓存时发生未预期错误: {e}")
+            return 0
+
+    def 配置编译器(
+        self,
+        库目录列表: Optional[List[str]] = None,
+        链接库列表: Optional[List[str]] = None
+    ):
+        """
+        配置编译器
+
+        Args:
+            库目录列表: 库搜索目录列表
+            链接库列表: 需要链接的库列表
+        """
+        if 库目录列表:
+            self.编译器.添加库目录(库目录列表)
+
+        if 链接库列表:
+            self.编译器.添加库(链接库列表)
+
+    def 执行编译(
+        self,
+        源文件列表: List[str],
+        输出路径: str,
+        是否为可执行文件: bool = False,
+        编译选项: Optional[List[str]] = None
+    ):
+        """
+        执行编译
+
+        Args:
+            源文件列表: 源文件路径列表
+            输出路径: 输出文件路径
+            是否为可执行文件: 是否编译为可执行文件
+            编译选项: 额外的编译选项
+        """
+        if 编译选项:
+            for option in 编译选项:
+                self.编译器.添加编译选项(option)
+
+        if 是否为可执行文件:
+            self.编译器.编译文件(源文件列表, 输出路径)
+        else:
+            self.编译器.编译共享库(源文件列表, 输出路径)
+
+    def 获取状态摘要(self) -> dict:
+        """
+        获取编译管理器的状态摘要
+
+        Returns:
+            包含当前状态的字典
+        """
+        return {
+            "文件管理器状态": self.文件管理器.获取状态摘要() if hasattr(self.文件管理器, '获取状态摘要') else {},
+            "编译上下文状态": self.编译上下文.获取状态摘要(),
+        }