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

l0n0lc/cpp/347/261/273/345/236/213.py

@@ -0,0 +1,330 @@
+from typing import Optional
+from .工具 import 生成变量ID
+
+
+class Cpp类型:
+    """
+    预定义的 C++ 类型字符串常量。
+    """
+
+    INT8_T = "int8_t"
+    INT16_T = "int16_t"
+    INT32_T = "int32_t"
+    INT64_T = "int64_t"
+    UINT8_T = "uint8_t"
+    UINT16_T = "uint16_t"
+    UINT32_T = "uint32_t"
+    UINT64_T = "uint64_t"
+    HALF = "half"
+    FLOAT32 = "float"
+    FLOAT64 = "double"
+    字符串 = "char*"
+    静态字符串 = "const char*"
+    StdString = "std::string"
+    布尔 = "bool"
+    任意 = "std::any"
+    自动 = "auto"
+    空指针 = "void*"
+
+
+class 代码块:
+    """
+    用于生成 C++ 代码块的上下文管理器（包含大括号）。
+    """
+
+    def __init__(self, 编译器) -> None:
+        self.编译器 = 编译器
+
+    def __enter__(self, *args, **kwargs):
+        self.编译器.添加代码("{")
+        self.编译器.进入作用域()
+
+    def __exit__(self, *args, **kwargs):
+        self.编译器.退出作用域()
+        self.编译器.添加代码("}\n")
+
+
+class C代码:
+    """
+    表示单行 C++ 代码，主要负责缩进处理。
+    """
+
+    def __init__(self, 代码: str, 层级: int, lineno: Optional[int] = None) -> None:
+        self.代码 = 代码
+        self.层级 = 层级
+        self.lineno = lineno  # 对应的Python源码行号
+
+    def __str__(self) -> str:
+        return "  " * self.层级 + self.代码
+
+
+class C获取下标:
+    """
+    表示 C++ 数组或 Vector 的下标访问表达式。
+    """
+
+    def __init__(self, 变量, 下标) -> None:
+        self.变量 = 变量
+        self.下标 = 下标
+
+    def __str__(self) -> str:
+        return f"{self.变量}[{self.下标}]"
+
+
+class C获取属性:
+    """
+    表示 C++ 对象属性或成员函数访问表达式。
+    自动处理指针 ->、引用 . 以及对象 . 的访问差异。
+    """
+
+    def __init__(self, 变量, 属性) -> None:
+        self.变量 = 变量
+        self.属性 = 属性
+
+    def __str__(self) -> str:
+        # 如果是C变量，根据类型决定访问方式
+        if isinstance(self.变量, C变量):
+            类型名 = self.变量.类型名
+
+            # 指针类型使用 -> 访问
+            if 类型名.endswith("*"):
+                return f"{self.变量}->{self.属性}"
+            # 引用类型使用 . 访问
+            elif 类型名.endswith("&"):
+                return f"{self.变量}.{self.属性}"
+            # 对象类型使用 . 访问
+            else:
+                return f"{self.变量}.{self.属性}"
+
+        # 如果是字符串表达式，需要解析类型
+        elif isinstance(self.变量, str):
+            # 简单的指针检测（以*结尾）
+            if self.变量.endswith("*"):
+                return f"{self.变量}->{self.属性}"
+            # 简单的引用检测（以&结尾）
+            elif self.变量.endswith("&"):
+                return f"{self.变量}.{self.属性}"
+            else:
+                return f"{self.变量}.{self.属性}"
+
+        # 如果是C函数调用（临时对象），需要用括号包围
+        elif isinstance(self.变量, C函数调用):
+            return f"({self.变量}).{self.属性}"
+
+        # 默认使用 . 访问
+        return f"{self.变量}.{self.属性}"
+
+
+class C函数调用:
+    """
+    表示 C++ 函数调用表达式。
+    """
+
+    def __init__(self, 函数名, 参数字符串, 返回C类型=None) -> None:
+        self.函数名 = 函数名
+        self.参数字符串 = 参数字符串
+        self.返回C类型 = 返回C类型
+
+    def __str__(self) -> str:
+        return f"{self.函数名}({self.参数字符串})"
+
+    def __getattr__(self, name):
+        """
+        支持对函数调用返回对象的属性访问。
+        当访问 C函数调用 对象的属性时，返回一个 C获取属性 表达式。
+        """
+        return C获取属性(self, name)
+
+
+class C布尔:
+    """
+    表示 C++ 布尔值 (true/false)。
+    """
+
+    def __init__(self, v) -> None:
+        self.v = v
+
+    def __str__(self) -> str:
+        return "true" if self.v else "false"
+
+
+class C静态调用:
+    """
+    表示 C++ 静态方法调用表达式。
+    """
+
+    def __init__(self, class_name, method_name) -> None:
+        self.class_name = class_name
+        self.method_name = method_name
+
+    def __str__(self) -> str:
+        return f"{self.class_name}::{self.method_name}"
+
+class CInt常量:
+    def __init__(self, v:int) -> None:
+        self.v = v
+
+    def __str__(self) -> str:
+        from .基础映射 import int映射目标
+        return f'{int映射目标}({self.v})'
+    
+class CFloat常量:
+    def __init__(self, v:float) -> None:
+        self.v = v
+        
+    def __str__(self) -> str:
+        from .基础映射 import float映射目标
+        return f'{float映射目标}({self.v})'
+    
+class CString常量:
+    def __init__(self, v:str) -> None:
+        self.v = v
+
+    def __str__(self) -> str:
+        return f'u8"{self.v}"'
+    
+class CBytes常量:
+    def __init__(self, v:bytes) -> None:
+        self.v = v
+
+    def __str__(self) -> str:
+        return f'"{self.v}"'    
+
+class SuperCallWrapper:
+    """包装super()调用，用于处理基类方法访问"""
+
+    def __init__(self, base_class_name: str, transpiler):
+        self.base_class_name = base_class_name
+        self.transpiler = transpiler
+
+    def __getattribute__(self, name):
+        """拦截所有属性访问，包括特殊方法"""
+        # Call object's __getattribute__ first to avoid infinite recursion
+        obj = super().__getattribute__(name)
+
+        # For special method names like __init__, return SuperMethodCall
+        if name.startswith("__") and name.endswith("__") and name != "__getattribute__":
+            transpiler = super().__getattribute__("transpiler")
+            return SuperMethodCall(self.base_class_name, name, transpiler)
+
+        # For other attributes, return normally
+        return obj
+
+    def __getattr__(self, method_name: str):
+        """当访问super().method时返回基类方法调用"""
+        transpiler = super().__getattribute__("transpiler")
+        return SuperMethodCall(self.base_class_name, method_name, transpiler)
+
+    def __call__(self, *args, **kwargs):
+        """当直接调用super()时（构造函数）"""
+        args_str = ", ".join(str(arg) for arg in args)
+        return f"{self.base_class_name}({args_str})"
+
+
+class SuperMethodCall:
+    """表示super().method()调用"""
+
+    def __init__(self, base_class_name: str, method_name: str, transpiler=None):
+        self.base_class_name = base_class_name
+        self.method_name = method_name
+        self.transpiler = transpiler
+
+    def __call__(self, *args):
+        """生成基类方法调用的C++代码"""
+        # Special handling: if this is super().__init__() in a constructor,
+        # don't generate any code since the parent constructor is already called
+        # in the initialization list
+        if (
+            self.method_name == "__init__"
+            and self.transpiler
+            and hasattr(self.transpiler, "当前方法名")
+            and self.transpiler.当前方法名 == "__init__"
+        ):
+            return ""  # No code needed for super().__init__() in constructors
+
+        args_str = ", ".join(str(arg) for arg in args)
+        # C++中调用基类方法：BaseClass::method(args...)
+        return f"{self.base_class_name}::{self.method_name}({args_str})"
+
+    def __str__(self):
+        """用于表达式上下文"""
+        return f"{self.base_class_name}::{self.method_name}"
+
+
+# 导入统一的类型转换器
+from .类型转换 import 类型转换器
+
+
+class 列表初始化列表:
+    """
+    表示 C++ 的初始化列表 {e1, e2, ...}，用于 std::vector 初始化。
+    """
+
+    def __init__(self, 代码: str, 类型名: str, 长度: int) -> None:
+        self.代码 = 代码
+        self.类型名 = 类型名
+        self.长度 = 长度
+
+    def __str__(self) -> str:
+        return self.代码
+
+
+
+
+class 字典初始化列表:
+    """
+    表示 C++ 的字典初始化列表 {{k1, v1}, {k2, v2}, ...}，用于 std::unordered_map。
+    """
+
+    def __init__(self, 代码: str, 键类型名: str, 值类型名: str) -> None:
+        self.代码 = 代码
+        self.键类型名 = 键类型名
+        self.值类型名 = 值类型名
+
+    def __str__(self) -> str:
+        return self.代码
+
+
+
+
+class 集合初始化列表:
+    """
+    表示 C++ 的集合初始化列表 {e1, e2, ...}，用于 std::unordered_set。
+    """
+
+    def __init__(self, 代码: str, 类型名: str) -> None:
+        self.代码 = 代码
+        self.类型名 = 类型名
+
+    def __str__(self) -> str:
+        return self.代码
+
+
+
+
+class C变量:
+    """
+    表示一个 C++ 变量。
+    包含变量类型、名称、生成的 C 变量名以及初始化代码生成逻辑。
+    """
+
+    def __init__(self, 类型名: str, 名称: str, 是否参数: bool, 默认值=None) -> None:
+        self.类型名 = 类型名
+        self.名称 = 名称
+        self.C名称 = 生成变量ID(名称)
+        self.是否参数 = 是否参数
+        self.默认值 = 默认值
+
+    def __str__(self):
+        return self.C名称
+
+    @property
+    def decltype(self):
+        return f"decltype({self})"
+
+    def 初始化代码(self, initial_value, cast_type: str | None = None):
+        """生成变量声明和初始化代码"""
+        if cast_type:
+            return f"{self.类型名} {self.C名称} = (({cast_type})({initial_value}));"
+        else:
+            return f"{self.类型名} {self.C名称} = {initial_value};"

l0n0lc/cpp/347/274/226/350/257/221/345/231/250.py

@@ -0,0 +1,317 @@
+
+from typing import Union, List, Optional
+import subprocess
+import os
+import shutil
+
+
+class Cpp编译器:
+    """
+    C++ 编译器包装类，负责检测编译器、设置参数并执行编译命令。
+    """
+    # 支持的优化级别
+    _支持的优化级别 = {
+        'O0': '-O0',   # 无优化，编译最快
+        'O1': '-O1',   # 基础优化
+        'O2': '-O2',   # 标准优化（默认）
+        'O3': '-O3',   # 最大优化
+        'Os': '-Os',   # 优化代码大小
+        'Ofast': '-Ofast',  # 激进优化（可能破坏标准合规）
+        'Og': '-Og',   # 调试优化
+        'Oz': '-Oz',   # 最小代码大小（类似于 Os 但更激进）
+    }
+
+    def __init__(
+        self,
+        优化级别: str = 'O2',
+        启用LTO: bool = False,
+        启用向量化: bool = False,
+        SIMD指令集: Optional[str] = None
+    ) -> None:
+        """
+        初始化 C++ 编译器
+
+        Args:
+            优化级别: 优化级别，默认为 'O2'
+                - O0: 无优化，编译最快，运行最慢
+                - O1: 基础优化
+                - O2: 标准优化（默认）
+                - O3: 最大优化，编译较慢，运行最快
+                - Os: 优化代码大小
+                - Ofast: 激进优化（可能破坏标准合规）
+                - Og: 调试优化
+                - Oz: 最小代码大小
+            启用LTO: 是否启用链接时优化（LTO），默认为 False
+            启用向量化: 是否启用 SIMD 向量化优化，默认为 False
+            SIMD指令集: 指定 SIMD 指令集（None 表示自动检测）
+                可选值: SSE2, SSE4_2, AVX, AVX2, AVX512F, NEON
+        """
+        self.编译器 = self._检测编译器()
+        self.包含目录: List[str] = []
+        self.库目录: List[str] = []
+        self.库: List[str] = []
+        self.编译选项: List[str] = []
+        self.详细模式 = False
+        self._启用LTO = 启用LTO
+        self._启用向量化 = 启用向量化
+        self._SIMD指令集 = SIMD指令集
+
+        # 设置优化级别
+        self.设置优化级别(优化级别)
+
+        # 如果启用 LTO，添加 LTO 标志
+        if 启用LTO:
+            self.启用LTO()
+
+        # 如果启用向量化，添加向量化标志
+        if 启用向量化:
+            self.启用向量化(SIMD指令集)
+
+    def _检测编译器(self) -> str:
+        """
+        自动检测可用的 C++ 编译器。
+        优先检查 'CXX' 环境变量，然后检查常见的编译器命令。
+        """
+        # 1. 检查环境变量
+        cxx = os.environ.get('CXX')
+        if cxx:
+            return cxx
+        
+        # 2. 检查系统路径中的标准编译器
+        for compiler in ['c++', 'g++', 'clang++']:
+            if shutil.which(compiler):
+                return compiler
+        
+        # 3. 没有找到编译器，抛出明确错误
+        raise RuntimeError(
+            "未找到可用的C++编译器。请安装以下编译器之一：\n"
+            "- Ubuntu/Debian: sudo apt install g++ clang++\n"
+            "- CentOS/RHEL: sudo yum install gcc-c++ clang\n"
+            "- macOS: xcode-select --install\n"
+            "- Windows: 安装 Visual Studio 或 MinGW\n"
+            "或者设置 CXX 环境变量指定编译器路径。"
+        )
+
+    def 设置编译器(self, compiler_path: str):
+        """手动设置编译器路径"""
+        self.编译器 = compiler_path
+
+    def 设置优化级别(self, 优化级别: str):
+        """
+        设置编译优化级别
+
+        Args:
+            优化级别: 优化级别字符串（如 'O0', 'O1', 'O2', 'O3', 'Os', 'Ofast'）
+                      不区分大小写，'os' 和 'Os' 等效
+
+        Raises:
+            ValueError: 如果优化级别不支持
+        """
+        # 不区分大小写，但保持原始形式
+        优化级别_lower = 优化级别.lower()
+
+        # 查找匹配的键（不区分大小写）
+        匹配键 = None
+        for key in self._支持的优化级别:
+            if key.lower() == 优化级别_lower:
+                匹配键 = key
+                break
+
+        if 匹配键 is None:
+            支持的级别 = ', '.join(self._支持的优化级别.keys())
+            raise ValueError(
+                f"不支持的优化级别: {优化级别}\n"
+                f"支持的优化级别: {支持的级别}"
+            )
+
+        self._当前优化级别 = 匹配键
+        # 添加到编译选项（如果还没有）
+        优化选项 = self._支持的优化级别[匹配键]
+        if not any(opt.startswith('-O') or opt.startswith('--optimize') for opt in self.编译选项):
+            self.编译选项.append(优化选项)
+
+    def 获取优化级别(self) -> str:
+        """获取当前优化级别"""
+        return getattr(self, '_当前优化级别', 'O2')
+
+    def 启用LTO(self):
+        """
+        启用链接时优化 (LTO)
+
+        LTO 允许编译器在链接阶段进行跨编译单元的优化，
+        可以显著提升运行时性能（10-30%），但会增加编译时间。
+        """
+        if not self._启用LTO:
+            self._启用LTO = True
+            # 添加 LTO 编译标志
+            if '-flto' not in self.编译选项:
+                self.添加编译选项('-flto')
+
+    def 禁用LTO(self):
+        """禁用链接时优化 (LTO)"""
+        if self._启用LTO:
+            self._启用LTO = False
+            # 移除 LTO 编译标志
+            self.编译选项 = [opt for opt in self.编译选项 if opt != '-flto']
+
+    def 是否启用LTO(self) -> bool:
+        """检查是否启用了 LTO"""
+        return self._启用LTO
+
+    def 设置LTO(self, 启用: bool):
+        """
+        设置是否启用 LTO
+
+        Args:
+            启用: True 启用 LTO，False 禁用 LTO
+        """
+        if 启用:
+            self.启用LTO()
+        else:
+            self.禁用LTO()
+
+    def 启用向量化(self, SIMD指令集: Optional[str] = None):
+        """
+        启用 SIMD 向量化优化
+
+        Args:
+            SIMD指令集: 指定 SIMD 指令集，None 表示自动检测
+                可选值: SSE2, SSE4_2, AVX, AVX2, AVX512F, NEON
+        """
+        if not self._启用向量化:
+            self._启用向量化 = True
+            self._SIMD指令集 = SIMD指令集
+
+            # 延迟导入避免循环依赖
+            from .simd优化 import 获取SIMD编译标志, 启用自动向量化标志
+
+            # 添加 SIMD 编译标志
+            SIMD标志 = 获取SIMD编译标志(SIMD指令集)
+            for 标志 in SIMD标志:
+                if 标志 not in self.编译选项:
+                    self.添加编译选项(标志)
+
+            # 添加自动向量化标志
+            向量化标志 = 启用自动向量化标志()
+            for 标志 in 向量化标志:
+                if 标志 not in self.编译选项:
+                    self.添加编译选项(标志)
+
+    def 禁用向量化(self):
+        """禁用 SIMD 向量化优化"""
+        if self._启用向量化:
+            self._启用向量化 = False
+            self._SIMD指令集 = None
+
+            # 移除 SIMD 相关标志
+            SIMD标志前缀 = ['-m', '-ftree-vectorize', '-ffast-math']
+            self.编译选项 = [
+                opt for opt in self.编译选项
+                if not any(opt.startswith(prefix) for prefix in SIMD标志前缀)
+            ]
+
+    def 是否启用向量化(self) -> bool:
+        """检查是否启用了向量化"""
+        return self._启用向量化
+
+    def 设置向量化(self, 启用: bool, SIMD指令集: Optional[str] = None):
+        """
+        设置是否启用向量化
+
+        Args:
+            启用: True 启用向量化，False 禁用向量化
+            SIMD指令集: 指定 SIMD 指令集，None 表示自动检测
+        """
+        if 启用:
+            self.启用向量化(SIMD指令集)
+        else:
+            self.禁用向量化()
+
+    def 添加头文件目录(self, directory: Union[str, List[str]]):
+        """添加头文件搜索目录 (-I)"""
+        if isinstance(directory, str):
+            self.包含目录.append(directory)
+            return
+        self.包含目录.extend(directory)
+
+    def 添加库目录(self, directory: Union[str, List[str]]):
+        """添加库文件搜索目录 (-L)"""
+        if isinstance(directory, str):
+            self.库目录.append(directory)
+            return
+        self.库目录.extend(directory)
+
+    def 添加库(self, library_name: Union[str, List[str]]):
+        """添加需要链接的库 (-l)"""
+        if isinstance(library_name, str):
+            self.库.append(library_name)
+            return
+        self.库.extend(library_name)
+
+    def 添加编译选项(self, option: Union[str, List[str]]):
+        """添加其他编译选项"""
+        if isinstance(option, str):
+            self.编译选项.append(option)
+            return
+        self.编译选项.extend(option)
+
+    def 编译文件(self, file_path: Union[str, List[str]], output_path: str):
+        """
+        编译源文件到指定输出路径。
+        构建并执行完整的编译器命令。
+        """
+        cmd = [self.编译器]
+        
+        # 添加头文件目录
+        cmd.extend([f'-I{d}' for d in self.包含目录])
+        
+        # 添加库目录
+        cmd.extend([f'-L{d}' for d in self.库目录])
+        
+        # 添加链接库
+        cmd.extend([f'-l{lib}' for lib in self.库])
+        
+        # 添加编译选项
+        cmd.extend(self.编译选项)
+        
+        # 添加源文件
+        if isinstance(file_path, list):
+            cmd.extend(file_path)
+        else:
+            cmd.append(file_path)
+            
+        # 添加输出路径
+        cmd.extend(['-o', output_path])
+        
+        if self.详细模式:
+            print(f"Compiling with command: {' '.join(cmd)}")
+            
+        try:
+            subprocess.check_call(cmd)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Compilation failed with exit code {e.returncode}") from e
+        except FileNotFoundError:
+             raise RuntimeError(f"Compiler '{self.编译器}' not found. Please install a C++ compiler.")
+
+    def 编译共享库(self, file_path: Union[str, List[str]], output_path: str):
+        """
+        编译为共享/动态库 (.so)。
+        自动添加 -fPIC、--shared 和 RPATH 选项。
+        使用初始化时设置的优化级别。
+        """
+        # 临时保存当前选项，避免重复添加
+        原始选项 = self.编译选项.copy()
+
+        # 确保必要选项存在（避免重复）
+        if '-fPIC' not in self.编译选项:
+            self.添加编译选项('-fPIC')
+        if '--shared' not in self.编译选项:
+            self.添加编译选项('--shared')
+
+        # 注意：优化级别已在 __init__ 中通过 设置优化级别() 添加
+
+        try:
+            self.编译文件(file_path, output_path)
+        finally:
+            # 恢复原始选项
+            self.编译选项 = 原始选项