cppgolf 0.1.0__tar.gz → 0.1.2__tar.gz

{cppgolf-0.1.0 → cppgolf-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cppgolf
-Version: 0.1.0
+Version: 0.1.2
 Summary: C++ multi-file merge & code golf / minifier tool
 License: MIT
 Project-URL: Homepage, https://github.com/yourname/cppgolf
@@ -18,8 +18,7 @@ Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Text Processing :: Filters
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: tree-sitter>=0.25
-Requires-Dist: tree-sitter-cpp>=0.23
+Requires-Dist: libclang
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"

{cppgolf-0.1.0 → cppgolf-0.1.2}/cppgolf/__main__.py

@@ -96,8 +96,8 @@ def build_parser() -> argparse.ArgumentParser:
                     help='单语句 if/for/while 去花括号')
     g2.add_argument('--shortcuts', dest='define_shortcuts', action='store_true',
                     help='高频 cout/cin 用 #define 缩写')
-    g2.add_argument('--rename', dest='rename_symbols', action='store_true',
-                    help='将用户变量/成员名压缩为短名（需要 tree-sitter-cpp）')
+    g2.add_argument('-no-rename', dest='no_rename_symbols', action='store_true',
+                    help='不将用户变量/成员名压缩为短名（需要 tree-sitter-cpp）')
 
     p.add_argument('--stats', action='store_true', help='显示压缩率统计')
     return p
@@ -124,7 +124,7 @@ def main():
         keep_inline=args.keep_inline,
         aggressive=args.aggressive,
         define_shortcuts=args.define_shortcuts,
-        rename_symbols=args.rename_symbols,
+        rename_symbols=not(args.no_rename_symbols),
     )
 
     def print_stats(final_size: int):

cppgolf-0.1.2/cppgolf/golf_rename.py

@@ -0,0 +1,410 @@
+"""
+golf_rename.py — Pass 5: 符号名压缩（libclang AST 驱动）
+
+依赖: pip install libclang
+"""
+import re
+import itertools
+import tempfile
+import os
+import sys as _sys
+import struct as _struct
+
+_MIN_RENAME_LEN = 2
+
+# C/C++ 保留关键字，生成短名时不得使用
+_CXX_KEYWORDS = frozenset({
+    # C keywords
+    'auto', 'break', 'case', 'char', 'const', 'continue', 'default',
+    'do', 'double', 'else', 'enum', 'extern', 'float', 'for', 'goto',
+    'if', 'inline', 'int', 'long', 'register', 'restrict', 'return',
+    'short', 'signed', 'sizeof', 'static', 'struct', 'switch', 'typedef',
+    'union', 'unsigned', 'void', 'volatile', 'while',
+    # C++ keywords
+    'alignas', 'alignof', 'and', 'and_eq', 'asm', 'bitand', 'bitor',
+    'bool', 'catch', 'class', 'compl', 'concept', 'consteval', 'constexpr',
+    'constinit', 'co_await', 'co_return', 'co_yield', 'decltype', 'delete',
+    'explicit', 'export', 'false', 'friend', 'mutable', 'namespace',
+    'new', 'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or',
+    'or_eq', 'private', 'protected', 'public', 'requires', 'static_assert',
+    'static_cast', 'dynamic_cast', 'reinterpret_cast', 'const_cast',
+    'template', 'this', 'thread_local', 'throw', 'true', 'try', 'typeid',
+    'typename', 'using', 'virtual', 'wchar_t', 'xor', 'xor_eq',
+    # 常用宏 / 内置名
+    'NULL', 'TRUE', 'FALSE', 'EOF', 'stdin', 'stdout', 'stderr',
+})
+
+
+def _gen_short_names():
+    for length in itertools.count(1):
+        for combo in itertools.product('abcdefghijklmnopqrstuvwxyz', repeat=length):
+            yield ''.join(combo)
+
+
+def _make_platform_args() -> list:
+    """返回当前平台所需的 libclang 预处理宏参数列表。
+
+    - Windows: 注入 _WIN32/WIN32/_WIN64/WIN64，以及 _HAS_STD_BYTE=0（避免
+      MSVC STL std::byte 与 Windows 头文件中全局 byte typedef 冲突）和
+      WIN32_LEAN_AND_MEAN（减少头文件噪音）。
+    - Linux / macOS: 注入对应平台宏。
+    """
+    args: list = []
+    if _sys.platform == 'win32' or os.name == 'nt':
+        args += ['-D_WIN32', '-DWIN32']
+        if _struct.calcsize('P') == 8:
+            args += ['-D_WIN64', '-DWIN64']
+        args += ['-D_HAS_STD_BYTE=0', '-DWIN32_LEAN_AND_MEAN']
+    elif _sys.platform.startswith('linux'):
+        args += ['-D__linux__', '-D__unix__', '-DLINUX']
+    elif _sys.platform == 'darwin':
+        args += ['-D__APPLE__', '-D__unix__', '-D__MACH__']
+    return args
+
+
+def _is_user_file(cursor, tmppath: str) -> bool:
+    """判断 cursor 的定义位置是否属于用户临时文件（即待处理的源码），
+    而非系统/第三方头文件。用于过滤系统结构体字段等不应被重命名的符号。"""
+    loc = cursor.location
+    if not loc.file:
+        return False
+    try:
+        return os.path.samefile(loc.file.name, tmppath)
+    except OSError:
+        return False
+
+
+def _walk_ast(
+    cursor,
+    tmppath: str,
+    src_bytes: bytes,
+    decl_map: dict,
+    replacements: list,
+    decl_kinds: frozenset,
+    ref_kinds: frozenset,
+) -> None:
+    """递归遍历 AST，收集需要重命名的符号声明位（decl_map）和所有引用位（replacements）。
+
+    参数：
+        decl_kinds  — VAR_DECL / FIELD_DECL / PARM_DECL 等声明节点类型集合
+        ref_kinds   — MEMBER_REF_EXPR / DECL_REF_EXPR / MEMBER_REF 等引用节点类型集合
+        decl_map    — USR → (orig_name, first_decl_offset, name_byte_len)，原地追加
+        replacements — (offset, byte_len, usr) 三元组列表，原地追加
+    """
+    if cursor.kind.is_invalid():
+        return
+    if _is_user_file(cursor, tmppath):
+        kind = cursor.kind
+        if kind in decl_kinds:
+            name = cursor.spelling
+            if len(name) >= _MIN_RENAME_LEN:
+                usr = cursor.get_usr()
+                if usr:
+                    off = cursor.location.offset
+                    blen = len(name.encode('utf-8'))
+                    # 跳过 offset 与源码不匹配的（宏展开内参数等）
+                    if src_bytes[off:off + blen] == name.encode('utf-8'):
+                        if usr not in decl_map:
+                            decl_map[usr] = (name, off, blen)
+                        replacements.append((off, blen, usr))
+        elif kind in ref_kinds:
+            ref = cursor.referenced
+            if ref and ref.kind in decl_kinds:
+                usr = ref.get_usr()
+                name = cursor.spelling
+                if usr and len(name) >= _MIN_RENAME_LEN:
+                    off = cursor.location.offset
+                    blen = len(name.encode('utf-8'))
+                    # 跳过 offset 与源码不匹配的（宏展开内引用等）
+                    if src_bytes[off:off + blen] == name.encode('utf-8'):
+                        replacements.append((off, blen, usr))
+    for child in cursor.get_children():
+        _walk_ast(child, tmppath, src_bytes, decl_map, replacements, decl_kinds, ref_kinds)
+
+
+def _scan_tokens(
+    tu,
+    tmppath: str,
+    src_bytes: bytes,
+    decl_map: dict,
+    decl_kinds: frozenset,
+    ref_kinds: frozenset,
+    ci,
+) -> list:
+    """Token 扫描补全 pass：修正 AST walk 因宏展开 offset 错位而漏掉的符号位置。
+
+    libclang 的 AST cursor 对宏参数的 location.offset 指向宏调用起始而非参数本身，
+    导致 offset 校验失败、符号未进入 decl_map / replacements。
+    token.location 是真实文本位置，此 pass 在 rename_map 建好前先收集候选。
+
+    参数：
+        decl_map — 可能被原地追加（补入宏内漏掉的 DECL）
+        ci       — clang.cindex 模块（用于访问 CursorKind.DECL_STMT 等）
+
+    返回：
+        token_candidates 列表，元素为
+        (offset: int, byte_len: int, tok_name: str, usr: str|None, is_member_access: bool)
+        - usr=None 表示本 token 暂未匹配到已知 USR，留给后续策略2/3处理
+        - is_member_access=True 表示该 token 前紧跟 . 或 ->，策略2/3 须跳过
+    """
+    token_candidates: list = []
+    prev_tok_spelling = ''
+    for token in tu.get_tokens(extent=tu.cursor.extent):
+        if token.kind.name != 'IDENTIFIER':
+            prev_tok_spelling = token.spelling   # 跟踪 . 和 -> 等标点符号
+            continue
+        loc = token.location
+        if not loc.file:
+            prev_tok_spelling = token.spelling
+            continue
+        try:
+            if not os.path.samefile(loc.file.name, tmppath):
+                prev_tok_spelling = token.spelling
+                continue
+        except OSError:
+            prev_tok_spelling = token.spelling
+            continue
+        off = loc.offset
+        tok_name = token.spelling
+        # 判断是否是成员访问（前面紧跟 . 或 ->），用于限制名字回退策略的误用范围
+        is_member_access = prev_tok_spelling in ('.', '->')
+        prev_tok_spelling = tok_name
+        if len(tok_name) < _MIN_RENAME_LEN:
+            continue
+        blen = len(tok_name.encode('utf-8'))
+        if src_bytes[off:off + blen] != tok_name.encode('utf-8'):
+            continue
+        cur = token.cursor
+        usr = None
+        # 策略1：cursor 精确匹配（无宏展开偏移问题时走这里）
+        if cur.kind in decl_kinds and cur.spelling == tok_name:
+            usr = cur.get_usr()
+            # AST walk 因 offset 校验失败而漏掉的 DECL，在此补入 decl_map
+            if usr and usr not in decl_map:
+                decl_map[usr] = (tok_name, off, blen)
+        # 策略1.5：cursor 为 DECL_STMT（宏内变量声明常见），向下找 VAR_DECL 子节点
+        elif cur.kind == ci.CursorKind.DECL_STMT:
+            for child in cur.get_children():
+                if child.kind in decl_kinds and child.spelling == tok_name:
+                    usr = child.get_usr()
+                    if usr and usr not in decl_map:
+                        decl_map[usr] = (tok_name, off, blen)
+                    break
+        elif cur.kind in ref_kinds:
+            ref = cur.referenced
+            if ref and ref.kind in decl_kinds and cur.spelling == tok_name:
+                ref_usr = ref.get_usr()
+                if ref_usr:
+                    # 仅当被引用 DECL 位于用户文件时才补入 decl_map，
+                    # 避免把系统结构体字段（如 sockaddr_in6::sin6_family）纳入重命名
+                    if ref_usr not in decl_map and _is_user_file(ref, tmppath):
+                        decl_name = ref.spelling or tok_name
+                        if len(decl_name) >= _MIN_RENAME_LEN:
+                            decl_map[ref_usr] = (decl_name, off, blen)
+                    # usr 只在 decl_map 中存在时才设置，
+                    # 防止系统字段 USR 进入 token_candidates 后被错误匹配
+                    if ref_usr in decl_map:
+                        usr = ref_usr
+        token_candidates.append((off, blen, tok_name, usr, is_member_access))
+    return token_candidates
+
+
+def _build_rename_map(
+    decl_map: dict,
+    replacements: list,
+    code: str,
+) -> tuple:
+    """根据声明表和引用频次生成 USR→短名 映射，并构建名字单义查找表。
+
+    参数：
+        decl_map     — USR → (orig_name, first_decl_offset, name_byte_len)
+        replacements — (offset, byte_len, usr) 列表，用于统计出现频次
+        code         — 原始源码字符串，用于提取已有标识符（避免短名冲突）
+
+    返回：
+        (rename_map, name_to_usr)
+        rename_map  — USR → short_name（高频 USR 优先分配最短名）
+        name_to_usr — orig_name → USR，仅包含该名字在 decl_map 中唯一对应一个
+                      USR 的情况（供 token 扫描策略2的名字单义回退使用）
+    """
+    # 统计每个 USR 的引用频次，高频符号优先分配最短名
+    freq: dict = {}
+    for _, _, usr in replacements:
+        freq[usr] = freq.get(usr, 0) + 1
+
+    sorted_usrs = sorted(decl_map.keys(), key=lambda u: -freq.get(u, 0))
+
+    # 生成短名，跳过已存在的标识符和 C++ 关键字
+    all_existing = set(re.findall(r'\b[A-Za-z_]\w*\b', code))
+    occupied = all_existing | _CXX_KEYWORDS
+    rename_map: dict = {}
+    gen = _gen_short_names()
+    for usr in sorted_usrs:
+        orig = decl_map[usr][0]
+        short = next(gen)
+        while short in occupied or short == orig:
+            short = next(gen)
+        rename_map[usr] = short
+        occupied.add(short)
+
+    # 构建旧名 → USR 的单义查找表（仅唯一映射才加入，防止多义时误匹配）
+    name_counts: dict = {}
+    for u, (oname, _, _) in decl_map.items():
+        if u in rename_map:
+            name_counts[oname] = name_counts.get(oname, 0) + 1
+    name_to_usr: dict = {}
+    for u, (oname, _, _) in decl_map.items():
+        if u in rename_map and name_counts.get(oname, 0) == 1:
+            name_to_usr[oname] = u
+
+    return rename_map, name_to_usr
+
+
+def _merge_token_candidates(
+    token_candidates: list,
+    replacements: list,
+    rename_map: dict,
+    name_to_usr: dict,
+) -> None:
+    """将 token 候选列表合并进 replacements，应用策略2/3补全 AST walk 漏掉的位置。
+
+    策略说明（is_member_access=True 时策略2/3均跳过）：
+        策略1/1.5  cursor 精确匹配，token_candidates 中 usr 已设置，直接使用。
+        策略2      名字单义回退：tok_name 在 name_to_usr 中唯一对应一个 USR。
+                   用于 AST cursor 指向错误（宏参数常见）但名字无歧义的情况。
+        策略3      最近 DECL_REF 推断：找同名且已知 USR 的 token 中距离最近的。
+                   用于策略1/2均失败、但代码局部性强的情况。
+
+    参数：
+        token_candidates — _scan_tokens 返回的候选列表（只读）
+        replacements     — 原地追加新的 (offset, byte_len, usr) 三元组
+        rename_map       — USR → short_name，用于过滤无效 USR
+        name_to_usr      — orig_name → USR（仅单义映射），供策略2使用
+    """
+    # 建立名字 → [(offset, usr)] 的索引，供策略3（最近 DECL_REF 推断）使用
+    ref_by_name: dict = {}
+    for off, _blen, tok_name, usr, _ma in token_candidates:
+        if usr is not None:
+            ref_by_name.setdefault(tok_name, []).append((off, usr))
+
+    ast_seen = {off for off, _, _ in replacements}
+    for off, blen, tok_name, usr, is_member_access in token_candidates:
+        if off in ast_seen:
+            continue  # AST walk 已覆盖，跳过
+        if usr is None and not is_member_access:
+            # 策略2：名字单义回退（非成员访问）
+            usr = name_to_usr.get(tok_name)
+        if usr is None and not is_member_access:
+            # 策略3：最近 DECL_REF 推断（非成员访问）
+            candidates_for_name = ref_by_name.get(tok_name, [])
+            if candidates_for_name:
+                nearest_usr = min(candidates_for_name, key=lambda x: abs(x[0] - off))[1]
+                usr = nearest_usr
+        if usr and usr in rename_map:
+            replacements.append((off, blen, usr))
+            ast_seen.add(off)
+
+
+def _apply_replacements(
+    src_bytes: bytes,
+    replacements: list,
+    rename_map: dict,
+) -> str:
+    """将所有重命名替换应用到源码字节串，返回替换后的字符串。
+
+    处理步骤：
+        1. 过滤掉 USR 不在 rename_map 中的记录（系统符号等）。
+        2. 按 offset 降序排列并去重，确保从后向前替换不影响前面的 offset。
+        3. 逐条把旧名字节替换为新短名字节。
+    """
+    valid = [
+        (off, blen, usr)
+        for off, blen, usr in replacements
+        if usr in rename_map
+    ]
+    seen: set = set()
+    deduped: list = []
+    for off, blen, usr in sorted(valid, key=lambda x: -x[0]):
+        if off not in seen:
+            seen.add(off)
+            deduped.append((off, blen, usr))
+
+    result = bytearray(src_bytes)
+    for off, blen, usr in deduped:
+        result[off:off + blen] = rename_map[usr].encode('utf-8')
+    return result.decode('utf-8')
+
+
+def golf_rename_symbols(code: str) -> str:
+    """使用 libclang 对 C++ 代码做符号名压缩。
+
+    重命名范围：局部变量、函数参数、结构体/类字段（仅用户代码中定义的）。
+    不重命名：函数名、类型名、宏名、标准库 / 系统头文件中的符号。
+    """
+    try:
+        import clang.cindex as ci
+    except ImportError:
+        raise RuntimeError("需要 libclang: pip install libclang")
+
+    src_bytes = code.encode('utf-8')
+
+    # 必须用二进制写，避免 Windows 上 \n→\r\n 导致 offset 错位
+    with tempfile.NamedTemporaryFile(suffix='.cpp', mode='wb', delete=False) as f:
+        f.write(src_bytes)
+        tmppath = f.name
+
+    try:
+        index = ci.Index.create()
+
+        tu = index.parse(
+            tmppath,
+            args=['-std=c++23', '-w', '-fno-spell-checking'] + _make_platform_args(),
+            options=(
+                ci.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD |
+                ci.TranslationUnit.PARSE_INCOMPLETE
+            ),
+        )
+
+        # 声明节点类型：这些节点是需要被重命名的符号定义位
+        _DECL_KINDS = frozenset({
+            ci.CursorKind.VAR_DECL,
+            ci.CursorKind.FIELD_DECL,
+            ci.CursorKind.PARM_DECL,
+        })
+        # 引用节点类型：这些节点是已声明符号的使用位
+        _REF_KINDS = frozenset({
+            ci.CursorKind.MEMBER_REF_EXPR,  # obj.field / obj->field
+            ci.CursorKind.MEMBER_REF,       # 构造函数初始化列表 : field(...)
+            ci.CursorKind.DECL_REF_EXPR,    # 局部变量、参数引用
+        })
+
+        # USR → (orig_name, first_decl_offset, name_byte_len)
+        decl_map: dict = {}
+        # (offset, byte_len, usr) 三元组，记录所有声明位和引用位
+        replacements: list = []
+
+        # AST 遍历：收集所有用户文件中的声明和引用
+        _walk_ast(tu.cursor, tmppath, src_bytes, decl_map, replacements, _DECL_KINDS, _REF_KINDS)
+
+        # Token 扫描：补全 AST walk 因宏展开 offset 错位而漏掉的符号位置
+        token_candidates = _scan_tokens(
+            tu, tmppath, src_bytes, decl_map, _DECL_KINDS, _REF_KINDS, ci
+        )
+
+        if not decl_map:
+            return code
+
+        # 生成 USR→短名 映射，以及名字单义查找表（供策略2使用）
+        rename_map, name_to_usr = _build_rename_map(decl_map, replacements, code)
+
+        # 合并 token 候选：策略1已设 usr，策略2/3补全宏参数等漏掉的位置
+        _merge_token_candidates(token_candidates, replacements, rename_map, name_to_usr)
+
+        # 应用所有重命名替换（从后向前，保持 offset 正确）
+        return _apply_replacements(src_bytes, replacements, rename_map)
+
+    finally:
+        try:
+            os.unlink(tmppath)
+        except OSError:
+            pass

{cppgolf-0.1.0 → cppgolf-0.1.2}/cppgolf/merge.py

@@ -34,15 +34,30 @@ def merge_files(filepath: Path, include_dirs: list,
     code = strip_include_guard(code)
     parts = []
 
+    # 跟踪预处理条件块嵌套深度：depth > 0 表示当前在 #if/#ifdef/#ifndef 内部
+    # 处于条件块内的 #include <...> 必须保留在原位，不能提升到文件顶部
+    cond_depth = 0
+
     for line in code.splitlines(keepends=True):
         s = line.strip()
 
+        # 更新条件块深度
+        if re.match(r'#\s*if(?:def|ndef)?\b', s):
+            cond_depth += 1
+        elif re.match(r'#\s*endif\b', s):
+            cond_depth = max(0, cond_depth - 1)
+
         # 系统头文件 #include <...>
         m_sys = re.match(r'#\s*include\s*<([^>]+)>', s)
         if m_sys:
-            entry = f'#include <{m_sys.group(1)}>\n'
-            if entry not in sys_includes:
-                sys_includes.append(entry)
+            if cond_depth > 0:
+                # 在条件块内：保留在原位，维持条件上下文
+                parts.append(line)
+            else:
+                # 无条件引用：提升到文件顶部统一去重管理
+                entry = f'#include <{m_sys.group(1)}>\n'
+                if entry not in sys_includes:
+                    sys_includes.append(entry)
             continue
 
         # 本地头文件 #include "..."
@@ -55,9 +70,13 @@ def merge_files(filepath: Path, include_dirs: list,
                 if c.exists():
                     found = c; break
             if found:
-                parts.append(f'\n// ── inlined: {inc} ──\n')
-                parts.append(merge_files(found, include_dirs, visited, sys_includes))
-                parts.append(f'\n// ── end: {inc} ──\n')
+                if cond_depth > 0:
+                    # 在条件块内：不内联，保留原始 include 行
+                    parts.append(line)
+                else:
+                    parts.append(f'\n// ── inlined: {inc} ──\n')
+                    parts.append(merge_files(found, include_dirs, visited, sys_includes))
+                    parts.append(f'\n// ── end: {inc} ──\n')
             else:
                 print(f'[警告] 找不到本地头文件：{inc}', file=sys.stderr)
                 parts.append(line)

{cppgolf-0.1.0 → cppgolf-0.1.2}/cppgolf/transforms.py

@@ -20,29 +20,40 @@ def golf_std_namespace(code: str) -> str:
 
 
 def golf_typedefs(code: str) -> str:
-    """对高频长类型名添加 #define 缩写（出现 ≥2 次时触发）。"""
+    """对高频长类型名添加 typedef 缩写（出现 ≥2 次时触发）。"""
     replacements = [
-        (r'\blong long\b',          'll',   '#define ll long long'),
-        (r'\bunsigned long long\b', 'ull',  '#define ull unsigned long long'),
-        (r'\blong double\b',        'ld',   '#define ld long double'),
-        (r'\bvector<int>\b',        'vi',   '#define vi vector<int>'),
-        (r'\bvector<ll>\b',         'vll',  '#define vll vector<ll>'),
-        (r'\bpair<int,int>\b',      'pii',  '#define pii pair<int,int>'),
-        (r'\bpair<ll,ll>\b',        'pll',  '#define pll pair<ll,ll>'),
+        (r'\blong long\b',          'll',   'typedef long long ll;'),
+        (r'\bunsigned long long\b', 'ull',  'typedef unsigned long long ull;'),
+        (r'\blong double\b',        'ld',   'typedef long double ld;'),
+        (r'\bvector<int>\b',        'vi',   'typedef vector<int> vi;'),
+        (r'\bvector<ll>\b',         'vll',  'typedef vector<ll> vll;'),
+        (r'\bpair<int,int>\b',      'pii',  'typedef pair<int,int> pii;'),
+        (r'\bpair<ll,ll>\b',        'pll',  'typedef pair<ll,ll> pll;'),
     ]
     defines_to_add = []
     for pattern, short, defline in replacements:
-        macro = defline.split()[1]
-        if re.search(r'\b' + re.escape(macro) + r'\b', code):
-            continue
-        if len(re.findall(pattern, code)) >= 2:
+        # 提取缩写名（typedef ... short;）
+        macro = defline.rstrip(';').split()[-1]
+        # 匹配已有的 typedef 或 #define 形式
+        existing_re = re.compile(
+            r'^[ \t]*(?:'
+            r'typedef\b[^\n]+\b' + re.escape(macro) + r'\s*;'
+            r'|#[ \t]*define[ \t]+' + re.escape(macro) + r'\b[^\n]*'
+            r')[ \t]*\n?',
+            re.MULTILINE,
+        )
+        existing = existing_re.search(code)
+        if existing:
+            # 已有定义：从原位删掉，稍后统一插到顶部
+            code = code[:existing.start()] + code[existing.end():]
+            defines_to_add.append(defline)
+        elif len(re.findall(pattern, code)) >= 2:
             defines_to_add.append(defline)
             code = re.sub(pattern, short, code)
     if defines_to_add:
-        last = max(
-            (m.end() for m in re.finditer(r'^#(?:include|define)\b.*$', code, re.MULTILINE)),
-            default=0,
-        )
+        # 插入点：文件顶部 include 块末尾
+        include_ends = [m.end() for m in re.finditer(r'^[ \t]*#[ \t]*include\b.*$', code, re.MULTILINE)]
+        last = include_ends[-1] if include_ends else 0
         code = code[:last] + '\n' + '\n'.join(defines_to_add) + '\n' + code[last:]
     return code
 

{cppgolf-0.1.0 → cppgolf-0.1.2}/cppgolf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cppgolf
-Version: 0.1.0
+Version: 0.1.2
 Summary: C++ multi-file merge & code golf / minifier tool
 License: MIT
 Project-URL: Homepage, https://github.com/yourname/cppgolf
@@ -18,8 +18,7 @@ Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Text Processing :: Filters
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: tree-sitter>=0.25
-Requires-Dist: tree-sitter-cpp>=0.23
+Requires-Dist: libclang
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: twine; extra == "dev"

cppgolf-0.1.2/cppgolf.egg-info/requires.txt

@@ -0,0 +1,6 @@
+libclang
+
+[dev]
+build
+twine
+pytest

{cppgolf-0.1.0 → cppgolf-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cppgolf"
-version = "0.1.0"
+version = "0.1.2"
 description = "C++ multi-file merge & code golf / minifier tool"
 readme = "README.md"
 license = { text = "MIT" }
@@ -24,8 +24,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "tree-sitter>=0.25",
-    "tree-sitter-cpp>=0.23",
+    "libclang",
 ]
 
 [project.optional-dependencies]

cppgolf-0.1.0/cppgolf/golf_rename.py

@@ -1,452 +0,0 @@
-"""
-golf_rename.py — Pass 5: 符号名压缩（tree-sitter AST 驱动）
-"""
-import re
-import sys
-import itertools
-
-_DECLARATOR_CONTAINERS = frozenset({
-    'init_declarator', 'pointer_declarator', 'reference_declarator',
-    'array_declarator', 'abstract_pointer_declarator',
-    'abstract_reference_declarator', 'abstract_array_declarator',
-})
-_MIN_RENAME_LEN = 2
-
-
-def _gen_short_names():
-    for length in itertools.count(1):
-        for combo in itertools.product('abcdefghijklmnopqrstuvwxyz', repeat=length):
-            yield ''.join(combo)
-
-
-def _extract_declarator_id(node, want_field: bool):
-    target_type = 'field_identifier' if want_field else 'identifier'
-    if node.type == target_type:
-        return node
-    if node.type in _DECLARATOR_CONTAINERS:
-        for ch in node.children:
-            if ch.type in ('*', '**', '&', '&&', '=', '[', ']',
-                           'const', 'volatile', 'restrict',
-                           '__cdecl', '__stdcall', '__fastcall', '__thiscall',
-                           'abstract_pointer_declarator',
-                           'abstract_reference_declarator'):
-                continue
-            result = _extract_declarator_id(ch, want_field)
-            if result:
-                return result
-    return None
-
-
-class _RenameCtx:
-    """封装一次重命名所需的全部状态与子方法。"""
-
-    def __init__(self, src_bytes, tree):
-        self.src = src_bytes
-        self.tree = tree
-        # 类型上下文
-        self.user_struct_names: set = set()
-        self.struct_field_types: dict = {}
-        self.var_type_map: dict = {}
-        self.typedef_map: dict = {}
-
-    # ── 工具 ────────────────────────────────────────────────────────────
-    def name_of(self, node) -> str:
-        return self.src[node.start_byte:node.end_byte].decode('utf-8')
-
-    def _get_primary_type_name(self, node) -> str | None:
-        for ch in node.children:
-            if ch.type in ('type_identifier', 'primitive_type'):
-                return self.name_of(ch)
-            if ch.type == 'qualified_identifier':
-                for sub in reversed(ch.children):
-                    if sub.type in ('identifier', 'type_identifier'):
-                        return self.name_of(sub)
-        return None
-
-    def _is_qid_name(self, node) -> bool:
-        par = node.parent
-        if not par or par.type != 'qualified_identifier':
-            return False
-        for ch in reversed(par.children):
-            if ch.type != '::':
-                return ch == node
-        return False
-
-    def _get_qid_scope_class(self, qid_node) -> str | None:
-        for ch in qid_node.children:
-            if ch.type == '::':
-                break
-            if ch.type in ('identifier', 'type_identifier', 'namespace_identifier'):
-                return self.name_of(ch)
-            elif ch.type == 'qualified_identifier':
-                for sub in reversed(ch.children):
-                    if sub.type in ('identifier', 'type_identifier', 'namespace_identifier'):
-                        return self.name_of(sub)
-                break
-        return None
-
-    # ── 步骤 0：构建类型上下文 ───────────────────────────────────────────
-    def build_type_context(self):
-        self._walk_types(self.tree.root_node)
-        for alias, real in self.typedef_map.items():
-            if real in self.user_struct_names:
-                self.user_struct_names.add(alias)
-                if real in self.struct_field_types and alias not in self.struct_field_types:
-                    self.struct_field_types[alias] = self.struct_field_types[real]
-
-    def _walk_types(self, node):
-        nt = node.type
-        if nt == 'type_definition':
-            inner = None
-            for ch in node.children:
-                if ch.type in ('struct_specifier', 'class_specifier', 'union_specifier'):
-                    for sub in ch.children:
-                        if sub.type == 'type_identifier':
-                            inner = self.name_of(sub); break
-                    break
-            if inner:
-                for ch in node.children:
-                    if ch.type == 'type_identifier' and self.name_of(ch) != inner:
-                        self.typedef_map[self.name_of(ch)] = inner
-                    elif ch.type in _DECLARATOR_CONTAINERS:
-                        id_node = _extract_declarator_id(ch, False)
-                        if id_node:
-                            self.typedef_map[self.name_of(id_node)] = inner
-        if nt in ('struct_specifier', 'class_specifier', 'union_specifier'):
-            struct_name = None
-            for ch in node.children:
-                if ch.type == 'type_identifier':
-                    struct_name = self.name_of(ch); break
-            if struct_name and any(c.type == 'field_declaration_list' for c in node.children):
-                self.user_struct_names.add(struct_name)
-                fmap = self.struct_field_types.setdefault(struct_name, {})
-                for ch in node.children:
-                    if ch.type == 'field_declaration_list':
-                        for fd in ch.children:
-                            if fd.type != 'field_declaration':
-                                continue
-                            ftype = self._get_primary_type_name(fd)
-                            for fc in fd.children:
-                                if fc.type == 'field_identifier':
-                                    fmap[self.name_of(fc)] = ftype
-                                elif fc.type in _DECLARATOR_CONTAINERS or fc.type == 'init_declarator':
-                                    id_node = _extract_declarator_id(fc, True)
-                                    if id_node:
-                                        fmap[self.name_of(id_node)] = ftype
-                        break
-        if nt in ('declaration', 'parameter_declaration'):
-            vtype = self._get_primary_type_name(node)
-            if vtype:
-                for ch in node.children:
-                    if ch.type == 'identifier':
-                        self.var_type_map.setdefault(self.name_of(ch), vtype)
-                    elif ch.type in _DECLARATOR_CONTAINERS or ch.type == 'init_declarator':
-                        id_node = _extract_declarator_id(ch, False)
-                        if id_node:
-                            self.var_type_map.setdefault(self.name_of(id_node), vtype)
-        for ch in node.children:
-            self._walk_types(ch)
-
-    # ── cast 类型提取 ────────────────────────────────────────────────────
-    def _extract_cast_target_type(self, node) -> str | None:
-        if node.type == 'call_expression':
-            fn = node.children[0] if node.children else None
-            if fn and fn.type == 'template_function':
-                fn_name = None
-                for ch in fn.children:
-                    if ch.type == 'identifier':
-                        fn_name = self.name_of(ch); break
-                if fn_name in ('reinterpret_cast', 'static_cast', 'dynamic_cast', 'const_cast'):
-                    for ch in fn.children:
-                        if ch.type == 'template_argument_list':
-                            for sub in ch.children:
-                                if sub.type == 'type_descriptor':
-                                    return self._get_primary_type_name(sub)
-        if node.type == 'cast_expression':
-            for ch in node.children:
-                if ch.type == 'type_descriptor':
-                    return self._get_primary_type_name(ch)
-        if node.type in ('reinterpret_cast_expression', 'static_cast_expression',
-                         'dynamic_cast_expression', 'const_cast_expression'):
-            for ch in node.children:
-                if ch.type == 'type_descriptor':
-                    return self._get_primary_type_name(ch)
-        return None
-
-    def _extract_init_cast_type(self, decl_node, var_name) -> str | None:
-        for ch in decl_node.children:
-            if ch.type == 'init_declarator':
-                id_nd = _extract_declarator_id(ch, False)
-                if not id_nd or self.name_of(id_nd) != var_name:
-                    continue
-                for sub in ch.children:
-                    t = self._extract_cast_target_type(sub)
-                    if t:
-                        return t
-        return None
-
-    # ── 作用域感知的变量类型查找 ─────────────────────────────────────────
-    def _lookup_var_type_in_scope(self, identifier_node) -> str | None:
-        var_name = self.name_of(identifier_node)
-        node = identifier_node.parent
-        while node is not None:
-            if node.type == 'parameter_list':
-                for param in node.children:
-                    if param.type == 'parameter_declaration':
-                        vtype = self._get_primary_type_name(param)
-                        if vtype:
-                            for ch in param.children:
-                                if ch.type == 'identifier' and self.name_of(ch) == var_name:
-                                    return vtype
-                                elif ch.type in _DECLARATOR_CONTAINERS:
-                                    id_nd = _extract_declarator_id(ch, False)
-                                    if id_nd and self.name_of(id_nd) == var_name:
-                                        return vtype
-            if node.type in ('compound_statement', 'translation_unit',
-                             'namespace_definition', 'function_definition'):
-                for child in node.children:
-                    if child.type == 'declaration':
-                        vtype = self._get_primary_type_name(child)
-                        matched = False
-                        for ch in child.children:
-                            if ch.type == 'identifier' and self.name_of(ch) == var_name:
-                                matched = True; break
-                            elif ch.type in _DECLARATOR_CONTAINERS or ch.type == 'init_declarator':
-                                id_nd = _extract_declarator_id(ch, False)
-                                if id_nd and self.name_of(id_nd) == var_name:
-                                    matched = True; break
-                        if matched:
-                            if vtype:
-                                return vtype
-                            return self._extract_init_cast_type(child, var_name)
-            node = node.parent
-        return self.var_type_map.get(var_name)
-
-    # ── 字段访问对象类型推断 ─────────────────────────────────────────────
-    def _resolve_field_object_type(self, field_expr_node) -> str | None:
-        if not field_expr_node.children:
-            return None
-        value_node = field_expr_node.children[0]
-        vt = value_node.type
-        td = self.typedef_map
-        if vt == 'identifier':
-            t = self._lookup_var_type_in_scope(value_node)
-            return td.get(t, t)
-        elif vt == 'field_expression':
-            parent_type = self._resolve_field_object_type(value_node)
-            if parent_type and parent_type in self.struct_field_types:
-                for ch in value_node.children:
-                    if ch.type == 'field_identifier':
-                        ft = self.struct_field_types[parent_type].get(self.name_of(ch))
-                        return td.get(ft, ft) if ft else None
-            return None
-        elif vt == 'pointer_expression':
-            for ch in value_node.children:
-                if ch.type == 'identifier':
-                    t = self._lookup_var_type_in_scope(ch)
-                    return td.get(t, t)
-        elif vt == 'subscript_expression':
-            arr = value_node.children[0] if value_node.children else None
-            if arr is None:
-                return None
-            if arr.type == 'identifier':
-                t = self._lookup_var_type_in_scope(arr)
-                return td.get(t, t) if t else None
-            elif arr.type == 'field_expression':
-                return self._resolve_field_object_type(arr)
-        return None
-
-    # ── 步骤 1：收集声明位节点 ────────────────────────────────────────────
-    def collect_decl_nodes(self):
-        local_decl: list = []
-        member_decl: list = []
-
-        def walk(node):
-            nt = node.type
-            if nt == 'declaration':
-                for ch in node.children:
-                    if ch.type == 'identifier':
-                        local_decl.append(ch)
-                    elif ch.type in _DECLARATOR_CONTAINERS or ch.type == 'init_declarator':
-                        id_node = _extract_declarator_id(ch, False)
-                        if id_node: local_decl.append(id_node)
-                    elif ch.type == 'function_declarator':
-                        decl_type = self._get_primary_type_name(node)
-                        if decl_type and decl_type in self.user_struct_names:
-                            for sub in ch.children:
-                                if sub.type == 'identifier':
-                                    local_decl.append(sub); break
-            elif nt == 'parameter_declaration':
-                for ch in node.children:
-                    if ch.type == 'identifier':
-                        local_decl.append(ch)
-                    elif ch.type in _DECLARATOR_CONTAINERS:
-                        id_node = _extract_declarator_id(ch, False)
-                        if id_node: local_decl.append(id_node)
-            elif nt == 'for_range_loop':
-                found_type = False
-                for ch in node.children:
-                    if ch.type in (':', 'compound_statement'): break
-                    if ch.is_named and not found_type:
-                        found_type = True; continue
-                    if ch.type == 'identifier':
-                        local_decl.append(ch); break
-                    elif ch.type in _DECLARATOR_CONTAINERS:
-                        id_node = _extract_declarator_id(ch, False)
-                        if id_node: local_decl.append(id_node)
-                        break
-            elif nt == 'field_declaration':
-                for ch in node.children:
-                    if ch.type == 'field_identifier':
-                        member_decl.append(ch)
-                    elif ch.type in _DECLARATOR_CONTAINERS or ch.type == 'init_declarator':
-                        id_node = _extract_declarator_id(ch, True)
-                        if id_node: member_decl.append(id_node)
-            if nt == 'function_declarator':
-                for ch in node.children:
-                    if ch.type != 'identifier': walk(ch)
-            else:
-                for ch in node.children: walk(ch)
-
-        walk(self.tree.root_node)
-        return local_decl, member_decl
-
-    # ── 步骤 3：统计频率 ──────────────────────────────────────────────────
-    def count_freq(self, local_names, member_names) -> dict:
-        freq: dict = {}
-        def walk(node):
-            if node.type == 'identifier':
-                n = self.name_of(node)
-                if n in local_names:
-                    freq[n] = freq.get(n, 0) + 1
-                elif n in member_names and self._is_qid_name(node):
-                    scope_cls = self._get_qid_scope_class(node.parent)
-                    real_cls = self.typedef_map.get(scope_cls, scope_cls) if scope_cls else None
-                    if real_cls and real_cls in self.user_struct_names:
-                        freq[n] = freq.get(n, 0) + 1
-            elif node.type == 'field_identifier':
-                n = self.name_of(node)
-                if n in member_names: freq[n] = freq.get(n, 0) + 1
-            elif node.type == 'type_identifier':
-                n = self.name_of(node)
-                if n in local_names:
-                    par = node.parent
-                    if (par and par.type == 'parameter_declaration'
-                            and par.parent and par.parent.type == 'parameter_list'
-                            and par.parent.parent and par.parent.parent.type == 'function_declarator'
-                            and par.parent.parent.parent
-                            and par.parent.parent.parent.type == 'declaration'):
-                        freq[n] = freq.get(n, 0) + 1
-            for ch in node.children: walk(ch)
-        walk(self.tree.root_node)
-        return freq
-
-    # ── 步骤 5：收集替换位置 ──────────────────────────────────────────────
-    def build_replacements(self, rename_map, local_names, member_names):
-        replacements: list = []
-        class_stack: list = []
-
-        def walk(node):
-            entered = False
-            nt = node.type
-            if nt in ('struct_specifier', 'class_specifier', 'union_specifier'):
-                for ch in node.children:
-                    if ch.type == 'type_identifier':
-                        class_stack.append(self.name_of(ch)); entered = True; break
-
-            if nt == 'identifier':
-                n = self.name_of(node)
-                if n in rename_map and n in local_names:
-                    replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-                elif n in rename_map and n in member_names and class_stack:
-                    replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-                elif n in rename_map and n in member_names and self._is_qid_name(node):
-                    scope_cls = self._get_qid_scope_class(node.parent)
-                    real_cls = self.typedef_map.get(scope_cls, scope_cls) if scope_cls else None
-                    if real_cls and real_cls in self.user_struct_names:
-                        replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-            elif nt == 'type_identifier':
-                n = self.name_of(node)
-                if n in rename_map and n in local_names:
-                    par = node.parent
-                    if (par and par.type == 'parameter_declaration'
-                            and par.parent and par.parent.type == 'parameter_list'
-                            and par.parent.parent and par.parent.parent.type == 'function_declarator'
-                            and par.parent.parent.parent
-                            and par.parent.parent.parent.type == 'declaration'):
-                        decl_type = self._get_primary_type_name(par.parent.parent.parent)
-                        if decl_type and decl_type in self.user_struct_names:
-                            replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-            elif nt == 'field_identifier':
-                n = self.name_of(node)
-                if n in rename_map and n in member_names:
-                    parent = node.parent
-                    if parent and parent.type == 'field_expression':
-                        obj_type = self._resolve_field_object_type(parent)
-                        if obj_type and obj_type in self.user_struct_names:
-                            replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-                    else:
-                        replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-
-            for ch in node.children: walk(ch)
-            if entered: class_stack.pop()
-
-        walk(self.tree.root_node)
-        return replacements
-
-    # ── 步骤 6：应用替换 ──────────────────────────────────────────────────
-    def apply(self, replacements) -> str:
-        replacements.sort(key=lambda x: x[0], reverse=True)
-        buf = bytearray(self.src)
-        for start, end, new in replacements:
-            buf[start:end] = new
-        return buf.decode('utf-8')
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# 公开入口
-# ─────────────────────────────────────────────────────────────────────────────
-def golf_rename_symbols(code: str) -> str:
-    try:
-        from tree_sitter import Language, Parser
-        import tree_sitter_cpp as tscpp
-        _lang = Language(tscpp.language())
-    except ImportError:
-        print('[警告] 未找到 tree-sitter，跳过符号重命名。'
-              '  运行: pip install tree-sitter tree-sitter-cpp', file=sys.stderr)
-        return code
-
-    src_bytes = code.encode('utf-8')
-    parser = Parser(_lang)
-    tree = parser.parse(src_bytes)
-
-    ctx = _RenameCtx(src_bytes, tree)
-    ctx.build_type_context()
-
-    local_decl, member_decl = ctx.collect_decl_nodes()
-    name_of = ctx.name_of
-
-    local_names  = {name_of(n) for n in local_decl  if len(name_of(n)) >= _MIN_RENAME_LEN}
-    member_names = {name_of(n) for n in member_decl if len(name_of(n)) >= _MIN_RENAME_LEN}
-    if not local_names and not member_names:
-        return code
-
-    all_targets = local_names | member_names
-    freq = ctx.count_freq(local_names, member_names)
-
-    # 步骤 4：生成重命名映射
-    all_existing = set(re.findall(r'\b[A-Za-z_]\w*\b', code))
-    occupied = set(all_existing)
-    rename_map: dict = {}
-    gen = _gen_short_names()
-    for original in sorted(all_targets, key=lambda x: -freq.get(x, 0)):
-        short = next(gen)
-        while short in occupied or short == original:
-            short = next(gen)
-        rename_map[original] = short
-        occupied.add(short)
-
-    replacements = ctx.build_replacements(rename_map, local_names, member_names)
-    if not replacements:
-        return code
-    return ctx.apply(replacements)

cppgolf-0.1.0/cppgolf.egg-info/requires.txt

@@ -1,7 +0,0 @@
-tree-sitter>=0.25
-tree-sitter-cpp>=0.23
-
-[dev]
-build
-twine
-pytest