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

l0n0lc//345/237/272/347/241/200/346/267/267/345/205/245.py

@@ -0,0 +1,147 @@
+"""
+基础混入类模块 - 提供可重用的功能混入
+用于统一错误处理、类型处理等通用功能
+"""
+
+import ast
+from typing import Any, Union
+from .通用工具 import (
+    统一抛出错误, 解析自定义类型, 统一异常处理,
+    构建参数字符串, 处理函数参数, 生成函数调用,
+    验证AST节点类型, 获取节点行号
+)
+from .异常 import 错误处理器
+
+
+class 错误处理混入:
+    """错误处理混入类 - 提供统一的错误处理功能"""
+
+    def 抛出错误(self, message: str, node: Union[ast.stmt, ast.expr, ast.arg, ast.arguments]):
+        """
+        抛出带行号的编译错误
+
+        Args:
+            message: 错误消息
+            node: AST节点，用于获取行号
+        """
+        # 获取源代码
+        源代码 = getattr(self, '源代码', None)
+        # 使用统一的错误处理器
+        错误处理器.抛出错误(message, node, 源代码)
+    
+    def 处理异常(self, e: Exception, node: Union[ast.stmt, ast.expr, ast.arg, ast.arguments], context_msg: str = ""):
+        """
+        统一异常处理
+        
+        Args:
+            e: 异常对象
+            node: AST节点
+            context_msg: 上下文消息
+        """
+        统一异常处理(e, self, node, context_msg)
+
+
+class 类型处理混入:
+    """类型处理混入类 - 提供统一的类型处理功能"""
+    
+    def 解析类型(self, py_type) -> str:
+        """
+        解析Python类型为C++类型
+        
+        Args:
+            py_type: Python类型对象
+            
+        Returns:
+            str: C++类型名称
+        """
+        return 解析自定义类型(py_type, self)
+
+
+class 参数处理混入:
+    """参数处理混入类 - 提供统一的参数处理功能"""
+    
+    def 构建参数字符串(self, args: list) -> str:
+        """
+        构建参数字符串
+        
+        Args:
+            args: 参数列表
+            
+        Returns:
+            str: 逗号分隔的参数字符串
+        """
+        获取值函数 = getattr(self, '获取值', None)
+        if 获取值函数 is None:
+            获取值函数 = getattr(getattr(self, 'transpiler', None), '获取值', None)
+        
+        if 获取值函数 is None:
+            raise AttributeError("无法找到'获取值'函数，请确保在类或transpiler中定义了此方法")
+            
+        return 构建参数字符串(args, 获取值函数)
+    
+    def 处理函数参数(self, node_args) -> list:
+        """
+        处理函数参数
+        
+        Args:
+            node_args: AST参数节点
+            
+        Returns:
+            list: 处理后的参数列表
+        """
+        获取值函数 = getattr(self, '获取值', None)
+        if 获取值函数 is None:
+            获取值函数 = getattr(getattr(self, 'transpiler', None), '获取值', None)
+            
+        if 获取值函数 is None:
+            raise AttributeError("无法找到'获取值'函数，请确保在类或transpiler中定义了此方法")
+            
+        return 处理函数参数(node_args, 获取值函数)
+    
+    def 生成函数调用(self, func_name: str, args_str: str):
+        """
+        生成函数调用
+        
+        Args:
+            func_name: 函数名
+            args_str: 参数字符串
+            
+        Returns:
+            C函数调用对象
+        """
+        return 生成函数调用(func_name, args_str)
+
+
+class AST验证混入:
+    """AST验证混入类 - 提供AST节点验证功能"""
+    
+    def 验证节点类型(self, node, expected_type, error_msg: str):
+        """
+        验证AST节点类型
+        
+        Args:
+            node: AST节点
+            expected_type: 期望的类型
+            error_msg: 错误消息
+        """
+        验证AST节点类型(node, expected_type, self, error_msg)
+    
+    def 获取行号(self, node) -> str:
+        """
+        获取节点行号
+        
+        Args:
+            node: AST节点
+            
+        Returns:
+            str: 行号字符串
+        """
+        return 获取节点行号(node)
+
+
+class 通用访问者混入(错误处理混入, 类型处理混入, 参数处理混入, AST验证混入):
+    """
+    通用访问者混入类 - 组合所有常用功能
+    适用于大多数AST访问者类
+    """
+    pass

l0n0lc//345/256/271/345/231/250/346/236/204/345/273/272/345/231/250.py

@@ -0,0 +1,214 @@
+"""
+容器构建器模块 - 统一处理容器初始化逻辑
+消除从列表、字典、集合构建初始化列表的重复代码
+"""
+
+from typing import List, Dict, Set, Any, Union
+from .类型转换 import 类型转换器
+from .异常 import 类型不一致错误
+
+# 安全限制配置
+MAX_CONTAINER_SIZE = 10**6  # 最大容器大小
+MAX_STRING_LENGTH = 10**4   # 最大字符串长度
+MAX_NESTING_DEPTH = 100     # 最大嵌套深度
+
+
+class 容器构建器:
+    """统一的容器构建器类"""
+    
+    @staticmethod
+    def 构建初始化列表(container: Union[List[Any], Dict[Any, Any], Set[Any]], container_type: str):
+        """
+        统一的容器初始化列表构建逻辑
+        
+        Args:
+            container: 容器对象（list、dict、set）
+            container_type: 容器类型（"list"、"dict"、"set"）
+            
+        Returns:
+            对应的初始化列表对象
+        """
+        # 验证输入参数
+        if container is None:
+            raise ValueError(f"{container_type} container cannot be None")
+            
+        # 检查容器大小限制
+        container_size = len(container)
+        if container_size > MAX_CONTAINER_SIZE:
+            raise ValueError(
+                f"{container_type} size {container_size} exceeds maximum limit {MAX_CONTAINER_SIZE}"
+            )
+        
+        # 递归检查嵌套深度
+        容器构建器._检查嵌套深度(container, current_depth=0)
+        
+        if container_type == "list":
+            return 容器构建器._从列表构建初始化列表(list(container))
+        elif container_type == "dict":
+            return 容器构建器._从字典构建初始化列表(dict(container))
+        elif container_type == "set":
+            return 容器构建器._从集合构建初始化列表(set(container))
+        else:
+            raise ValueError(f"Unsupported container type: {container_type}")
+    
+    @staticmethod
+    def _从列表构建初始化列表(value: List[Any]):
+        """
+        将 Python List 转换为 C++ 初始化列表字符串
+        """
+        from .cpp类型 import 列表初始化列表
+
+        if not value:
+            return 列表初始化列表("{}", "auto", 0)
+
+        data_types = []
+        init_items = []
+        for v in value:
+            dtype = type(v)
+            data_types.append(dtype)
+            init_items.append(str(v))
+
+        # 构建初始化列表字符串
+        init_list_str = "{" + ",".join(init_items) + "}"
+
+        # 一致性检查
+        容器构建器._检查类型一致性(data_types, "List elements")
+
+        type_name = 容器构建器._推断元素类型(value, data_types[0])
+
+        from .cpp类型 import 列表初始化列表
+        return 列表初始化列表(init_list_str, type_name, len(value))
+    
+    @staticmethod
+    def _从字典构建初始化列表(value: Dict[Any, Any]):
+        """
+        将 Python Dict 转换为 C++ 初始化列表字符串
+        """
+        from .cpp类型 import 字典初始化列表
+
+        if not value:
+            return 字典初始化列表("{}", "auto", "auto")
+
+        code_items = []
+        key_types = []
+        value_types = []
+
+        # 需要捕获第一个 key/value 实例来解析类型
+        first_key = None
+        first_value = None
+
+        for i, (k, v) in enumerate(value.items()):
+            if i == 0:
+                first_key = k
+                first_value = v
+            key_type = type(k)
+            value_type = type(v)
+            key_types.append(key_type)
+            value_types.append(value_type)
+            code_items.append(f"{{ {k}, {v} }}")
+
+        # 一致性检查
+        容器构建器._检查类型一致性(key_types, "Dict keys")
+        容器构建器._检查类型一致性(value_types, "Dict values")
+
+        # 推断 key 和 value 的 C++ 类型
+        key_type_name = 容器构建器._推断元素类型([first_key], type(first_key))
+        value_type_name = 容器构建器._推断元素类型([first_value], type(first_value))
+
+        init_list_str = "{" + ",".join(code_items) + "}"
+
+        from .cpp类型 import 字典初始化列表
+        return 字典初始化列表(init_list_str, key_type_name, value_type_name)
+    
+    @staticmethod
+    def _从集合构建初始化列表(value: Set[Any]):
+        """
+        将 Python Set 转换为 C++ 初始化列表字符串
+        """
+        from .cpp类型 import 集合初始化列表
+
+        if not value:
+            return 集合初始化列表("{}", "auto")
+
+        init_items = []
+        data_types = []
+        for v in value:
+            data_types.append(type(v))
+            init_items.append(str(v))
+
+        # 一致性检查
+        容器构建器._检查类型一致性(data_types, "Set elements")
+
+        type_name = 容器构建器._推断元素类型(value, data_types[0])
+
+        init_list_str = "{" + ",".join(init_items) + "}"
+
+        from .cpp类型 import 集合初始化列表
+        return 集合初始化列表(init_list_str, type_name)
+    
+    @staticmethod
+    def _检查类型一致性(data_types: List[type], error_context: str):
+        """
+        检查类型一致性
+        
+        Args:
+            data_types: 类型列表
+            error_context: 错误上下文信息
+        """
+        if not data_types:
+            return
+            
+        first_type = data_types[0]
+        if not all(t == first_type for t in data_types):
+            raise 类型不一致错误(
+                f"{error_context} must have same type, got {set(data_types)}"
+            )
+    
+    @staticmethod
+    def _检查嵌套深度(container: Any, current_depth: int = 0) -> None:
+        """
+        递归检查容器嵌套深度，防止过深嵌套导致栈溢出
+        
+        Args:
+            container: 要检查的容器对象
+            current_depth: 当前嵌套深度
+            
+        Raises:
+            ValueError: 当嵌套深度超过限制时
+        """
+        if current_depth > MAX_NESTING_DEPTH:
+            raise ValueError(f"容器嵌套深度 {current_depth} 超过限制 {MAX_NESTING_DEPTH}")
+        
+        # 如果是字符串，检查长度限制
+        if isinstance(container, str):
+            if len(container) > MAX_STRING_LENGTH:
+                raise ValueError(f"字符串长度 {len(container)} 超过限制 {MAX_STRING_LENGTH}")
+            return
+        
+        # 如果是容器类型，递归检查嵌套
+        if isinstance(container, (list, tuple, set)):
+            for item in container:
+                容器构建器._检查嵌套深度(item, current_depth + 1)
+        elif isinstance(container, dict):
+            for key, value in container.items():
+                容器构建器._检查嵌套深度(key, current_depth + 1)
+                容器构建器._检查嵌套深度(value, current_depth + 1)
+    
+    @staticmethod
+    def _推断元素类型(container: Union[List[Any], Set[Any]], first_type: type) -> str:
+        """
+        推断元素的C++类型
+        
+        Args:
+            container: 容器对象
+            first_type: 第一个元素的类型
+            
+        Returns:
+            str: C++类型名称
+        """
+        if not container:
+            return "auto"
+            
+        # 根据第一个元素值推断 C++ 类型
+        first_val = next(iter(container)) if isinstance(container, set) else container[0]
+        return 类型转换器.Python类型转C类型(first_type, first_val)

l0n0lc//345/267/245/345/205/267.py

@@ -0,0 +1,285 @@
+import re
+import os
+import ctypes
+import inspect
+import threading
+from typing import List, Optional, Any, Dict, Set, Callable, Union
+
+
+def 十进制转进制(value: int, base: int, digits="0123456789ABCDEF") -> str:
+    """将十进制整数转换为任意进制字符串"""
+    if value == 0:
+        return "0"
+    result = ""
+    is_negative = value < 0
+    value = abs(value)
+    while value > 0:
+        value, remainder = divmod(value, base)
+        result = digits[remainder] + result
+    return ("-" if is_negative else "") + result
+
+
+class Cpp函数映射:
+    """
+    存储 Python 函数到 C++ 函数的映射关系。
+    包含目标函数名（或代码生成器）、头文件依赖和库文件依赖。
+    """
+
+    def __init__(
+            self, 目标函数: Union[str, Callable],
+            包含目录: Optional[List[str]] = None,
+            库: Optional[List[str]] = None,
+            库目录: Optional[List[str]] = None) -> None:
+        self.目标函数 = 目标函数
+        self.包含目录 = 包含目录 or []
+        self.库 = 库 or []
+        self.库目录 = 库目录 or []
+
+    def __str__(self) -> str:
+        if callable(self.目标函数):
+            return f"<function {self.目标函数.__name__}>"
+        return str(self.目标函数)
+
+
+class Cpp类型映射:
+    """
+    存储 Python 类型到 C++ 类型的映射关系。
+    包含目标类型名、ctypes 类型以及相关的编译依赖。
+    """
+
+    def __init__(
+            self, 目标类型: str,
+            包含目录: Optional[List[str]] = None,
+            库: Optional[List[str]] = None,
+            库目录: Optional[List[str]] = None,
+            ctypes类型=None) -> None:
+        self.目标类型 = 目标类型
+        self.包含目录 = 包含目录 or []
+        self.库 = 库 or []
+        self.库目录 = 库目录 or []
+        self.ctypes类型 = ctypes类型
+
+    def __str__(self) -> str:
+        return self.目标类型
+
+
+class 全局上下文:
+    """
+    全局上下文，存储所有的函数/类型映射配置、内置函数列表以及全局编译设置。
+
+    线程安全说明：
+    - JIT 编译过程通常是单线程的，全局上下文主要用于管理和清理状态
+    - 清理() 方法是线程安全的，可用于测试环境
+    - 直接访问静态变量不是线程安全的，多线程环境需要外部同步
+    """
+
+    直接调用函数集: Set = set()  # 直接在 Python 端执行的函数集合 (如 range)
+    函数映射表: Dict[Any, Cpp函数映射] = {}  # 函数映射表
+    类型映射表: Dict[Any, Cpp类型映射] = {}  # 类型映射表
+    反向类型映射表: Dict[Any, Any] = {}  # 类型映射表
+    包含集合: Set = set()
+    链接库集合: Set = set()
+    最大变量ID = 0
+    Python内置映射 = {}
+    使用Unicode = True
+    工作目录 = './l0n0lcoutput'  # 编译输出目录
+    编译栈: Set = set()  # 全局编译栈，用于防止循环编译
+
+    @staticmethod
+    def 缓存直接调用():
+        全局上下文.直接调用函数集.add(range)
+
+    @staticmethod
+    def 添加内置映射(v):
+        全局上下文.Python内置映射[v.__name__] = v
+
+    @staticmethod
+    def 初始化内置():
+        """初始化常用的 Python 内置函数映射"""
+        # 初始化常用的 Python 内置函数映射
+        for v in [int, float, bytes, str, bool, range, complex, set, tuple, list, dict,
+                  print, input, abs, round, pow, divmod, sum, min, max,
+                  isinstance, len, open, Exception, BaseException]:
+            全局上下文.添加内置映射(v)
+
+    @staticmethod
+    def 清理():
+        """
+        清理全局状态，重置所有集合和映射。
+
+        线程安全：使用锁保护，可在多线程环境中调用。
+
+        用于测试或需要重置全局状态的场景。
+        注意：这会清除所有已注册的映射和配置（不包括内置映射）。
+        """
+        with 全局上下文._lock:
+            全局上下文.直接调用函数集.clear()
+            全局上下文.函数映射表.clear()
+            全局上下文.类型映射表.clear()
+            全局上下文.反向类型映射表.clear()
+            全局上下文.包含集合.clear()
+            全局上下文.链接库集合.clear()
+            全局上下文.编译栈.clear()
+            全局上下文.最大变量ID = 0
+            # 注意：不清空 Python内置映射 和工作目录，这些是配置
+
+    # 类变量（仅用于清理方法）
+    _lock = threading.RLock()  # 使用可重入锁
+
+
+全局上下文.初始化内置()
+
+
+def 可直接调用(fn):
+    """
+    装饰器：注册一个 Python 函数为"直接调用"模式。
+    转译器遇到此函数时不会尝试转换为 C++ 调用，而是回调 Python 解释器执行。
+    """
+    全局上下文.直接调用函数集.add(fn)
+    return fn
+
+
+def 映射函数(
+        mapped_function,
+        包含目录: Optional[List[str]] = None,
+        库: Optional[List[str]] = None,
+        库目录: Optional[List[str]] = None):
+    """
+    装饰器：将 Python 函数映射到 C++ 代码片段或函数。
+
+    :param mapped_function: 被映射的原 Python 函数
+    :param 包含目录: 需要包含的头文件
+    """
+    def decorator(target):
+        全局上下文.函数映射表[mapped_function] = Cpp函数映射(target, 包含目录, 库, 库目录)
+        return target
+    return decorator
+
+
+def 映射类型(mapped_type,
+         包含目录: Optional[List[str]] = None,
+         库: Optional[List[str]] = None,
+         库目录: Optional[List[str]] = None,
+         ctypes类型=None):
+    """
+    装饰器：将 Python 类型映射到 C++ 类型。
+    """
+    def decorator(target):
+        类型映射 = Cpp类型映射(mapped_type, 包含目录, 库, 库目录, ctypes类型)
+        全局上下文.类型映射表[target] = 类型映射
+        全局上下文.反向类型映射表[mapped_type] = target
+        return target
+    return decorator
+
+
+def 含非ASCII字符(s: str) -> bool:
+    """检查字符串是否包含非 ASCII 字符（如中文）"""
+    return bool(re.search(r'[^A-Za-z0-9_]', s))
+
+
+def 生成变量ID(original_name: Optional[str] = None) -> str:
+    """
+    生成合法的 C++ 变量/函数标识符。
+    如果 original_name 是 ASCII 且 use_unicode=True 则直接使用，
+    否则生成唯一的临时 ID。
+    """
+    if original_name is not None and (全局上下文.使用Unicode or not 含非ASCII字符(original_name)):
+        return original_name
+    ret = f'_{全局上下文.最大变量ID}'
+    全局上下文.最大变量ID += 1
+    return ret
+
+def 转C字符串(v) -> str:
+    """将 Python 值转换为 C++ 字符串表示"""
+    if isinstance(v, (str, bytes)):
+        return f'u8"{v}"'
+    return str(v)
+
+
+
+
+# ==================== 优化后的映射函数实现 ====================
+
+def 映射函数到(
+    cpp: str,
+    headers: Optional[List[str]] = None,
+    libraries: Optional[List[str]] = None,
+    library_dirs: Optional[List[str]] = None,
+    validate: bool = True,
+    **kwargs
+):
+    """
+    优化的函数映射装饰器
+
+    Args:
+        cpp: C++代码模板，使用{参数名}作为占位符
+        headers: 需要包含的头文件列表
+        libraries: 需要链接的库列表
+        library_dirs: 库搜索目录列表
+        validate: 是否验证参数匹配
+        **kwargs: 额外的模板变量，如模板参数T等
+
+    Example:
+        @映射到(
+            cpp='strlen({text})',
+            headers=['<cstring>']
+        )
+        def strlen(text: bytes) -> int:
+            \"\"\"计算字符串长度\"\"\"
+            pass
+    """
+    def decorator(func):
+        # 获取函数签名
+        sig = inspect.signature(func)
+        param_names = list(sig.parameters.keys())
+
+        # 参数验证
+        if validate:
+            # 从模板中提取参数引用
+            template_refs = set(re.findall(r'\{(\w+)\}', cpp))
+
+            # 分离函数参数和额外参数
+            func_params = set(param_names)
+            extra_params = set(kwargs.keys())
+
+            # 检查模板中引用的参数
+            missing = template_refs - func_params - extra_params
+            if missing:
+                raise ValueError(
+                    f"模板引用了未定义的参数: {missing}. "
+                    f"可用参数: 函数参数={func_params}, 额外参数={extra_params}"
+                )
+
+        # 创建代码生成函数
+        def code_generator(*args, **call_kwargs):
+            # 合并函数参数和额外参数
+            all_kwargs = {}
+            all_kwargs.update(kwargs)  # 额外参数如T='int'
+
+            # 添加调用时的函数参数
+            for i, arg in enumerate(args):
+                if i < len(param_names):
+                    all_kwargs[param_names[i]] = arg
+
+            # 添加关键字参数
+            all_kwargs.update(call_kwargs)
+
+            # 替换模板
+            result = cpp
+            for name, value in all_kwargs.items():
+                result = result.replace(f'{{{name}}}', str(value))
+
+            return result
+
+        # 注册到全局上下文
+        全局上下文.函数映射表[func] = Cpp函数映射(
+            code_generator,
+            headers or [],
+            libraries or [],
+            library_dirs or []
+        )
+
+        return func
+
+    return decorator
+