cppgolf 0.1.0__py3-none-any.whl

cppgolf/__init__.py

@@ -0,0 +1,46 @@
+"""
+cppgolf — C++ multi-file merge & code golf tool
+
+公开 API：
+    process(input_file, include_dirs, **options) -> str
+    golf_rename_symbols(code) -> str
+    strip_comments(code) -> str
+    merge_files(filepath, include_dirs, visited, sys_includes) -> str
+    compress_whitespace(code) -> str
+    golf_std_namespace / golf_typedefs / golf_endl_to_newline /
+    golf_remove_main_return / golf_remove_inline /
+    golf_braces_single_stmt / golf_define_shortcuts
+"""
+
+from .strip_comments import strip_comments
+from .merge import merge_files, strip_include_guard
+from .whitespace import compress_whitespace
+from .transforms import (
+    golf_std_namespace,
+    golf_typedefs,
+    golf_remove_main_return,
+    golf_endl_to_newline,
+    golf_remove_inline,
+    golf_braces_single_stmt,
+    golf_define_shortcuts,
+)
+from .golf_rename import golf_rename_symbols
+from .__main__ import process
+
+__all__ = [
+    "process",
+    "strip_comments",
+    "merge_files",
+    "strip_include_guard",
+    "compress_whitespace",
+    "golf_std_namespace",
+    "golf_typedefs",
+    "golf_remove_main_return",
+    "golf_endl_to_newline",
+    "golf_remove_inline",
+    "golf_braces_single_stmt",
+    "golf_define_shortcuts",
+    "golf_rename_symbols",
+]
+
+__version__ = "0.1.0"

cppgolf/__main__.py

@@ -0,0 +1,148 @@
+"""cppgolf.__main__ — CLI 入口，支持 python -m cppgolf 和 cppgolf 命令"""
+import sys
+import argparse
+from pathlib import Path
+
+from .strip_comments import strip_comments
+from .merge import merge_files
+from .whitespace import compress_whitespace
+from .transforms import (
+    golf_std_namespace, golf_typedefs, golf_remove_main_return,
+    golf_endl_to_newline, golf_remove_inline,
+    golf_braces_single_stmt, golf_define_shortcuts,
+)
+from .golf_rename import golf_rename_symbols
+
+
+def process(
+    input_file: Path,
+    include_dirs: list,
+    *,
+    no_merge: bool = False,
+    no_strip_comments: bool = False,
+    no_compress_ws: bool = False,
+    no_std_ns: bool = False,
+    no_typedefs: bool = False,
+    keep_main_return: bool = False,
+    keep_endl: bool = False,
+    keep_inline: bool = False,
+    aggressive: bool = False,
+    define_shortcuts: bool = False,
+    rename_symbols: bool = False,
+) -> str:
+    sys_includes: list = []
+    visited: set = set()
+
+    if not no_merge:
+        merged = merge_files(input_file, list(include_dirs), visited, sys_includes)
+        code = ''.join(sys_includes) + merged
+    else:
+        code = input_file.read_text(encoding='utf-8-sig', errors='replace')
+
+    if not no_strip_comments:
+        code = strip_comments(code)
+
+    if not keep_endl:
+        code = golf_endl_to_newline(code)
+    if not no_std_ns:
+        code = golf_std_namespace(code)
+    if not no_typedefs:
+        code = golf_typedefs(code)
+    if not keep_main_return:
+        code = golf_remove_main_return(code)
+    if not keep_inline:
+        code = golf_remove_inline(code)
+    if aggressive:
+        code = golf_braces_single_stmt(code)
+    if define_shortcuts:
+        code = golf_define_shortcuts(code)
+    if rename_symbols:
+        code = golf_rename_symbols(code)
+
+    if not no_compress_ws:
+        code = compress_whitespace(code)
+
+    return code.strip() + '\n'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog='cppgolf',
+        description='C++ 多文件合并 + 代码高尔夫工具',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""示例：
+  cppgolf solution.cpp
+  cppgolf solution.cpp -o golf.cpp
+  cppgolf solution.cpp -I include/ --rename --stats
+""",
+    )
+    p.add_argument('input', type=Path, help='入口 C++ 文件')
+    p.add_argument('-o', '--output', type=Path, default=None, help='输出文件（默认 stdout）')
+    p.add_argument('-I', '--include', dest='include_dirs', action='append',
+                   type=Path, default=[], metavar='DIR', help='追加 include 目录（可多次）')
+
+    g = p.add_argument_group('功能开关（默认全部开启）')
+    g.add_argument('--no-merge',          action='store_true', help='跳过多文件合并')
+    g.add_argument('--no-strip-comments', action='store_true', help='保留注释')
+    g.add_argument('--no-compress-ws',    action='store_true', help='保留空白格式')
+    g.add_argument('--no-std-ns',         action='store_true', help='不添加 using namespace std')
+    g.add_argument('--no-typedefs',       action='store_true', help='不添加 ll/ld 等类型宏')
+    g.add_argument('--keep-main-return',  action='store_true', help='保留 main 末尾 return 0')
+    g.add_argument('--keep-endl',         action='store_true', help='保留 endl')
+    g.add_argument('--keep-inline',       action='store_true', help='保留 inline 关键字')
+
+    g2 = p.add_argument_group('激进优化（有风险，默认关闭）')
+    g2.add_argument('--aggressive', action='store_true',
+                    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）')
+
+    p.add_argument('--stats', action='store_true', help='显示压缩率统计')
+    return p
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not args.input.exists():
+        print(f'错误：文件不存在 —— {args.input}', file=sys.stderr)
+        sys.exit(1)
+
+    original_size = args.input.stat().st_size
+    result = process(
+        args.input, args.include_dirs,
+        no_merge=args.no_merge,
+        no_strip_comments=args.no_strip_comments,
+        no_compress_ws=args.no_compress_ws,
+        no_std_ns=args.no_std_ns,
+        no_typedefs=args.no_typedefs,
+        keep_main_return=args.keep_main_return,
+        keep_endl=args.keep_endl,
+        keep_inline=args.keep_inline,
+        aggressive=args.aggressive,
+        define_shortcuts=args.define_shortcuts,
+        rename_symbols=args.rename_symbols,
+    )
+
+    def print_stats(final_size: int):
+        ratio = (1 - final_size / original_size) * 100 if original_size else 0
+        print(f'[统计] 原始：{original_size} B  →  高尔夫后：{final_size} B  （压缩 {ratio:.1f}%）',
+              file=sys.stderr)
+
+    if args.output:
+        args.output.write_text(result, encoding='utf-8')
+        if args.stats:
+            print_stats(args.output.stat().st_size)
+        else:
+            print(f'已写入：{args.output}', file=sys.stderr)
+    else:
+        if args.stats:
+            print_stats(len(result.encode('utf-8')))
+        sys.stdout.write(result)
+
+
+if __name__ == '__main__':
+    main()

cppgolf/golf_rename.py

@@ -0,0 +1,452 @@
+"""
+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/merge.py

@@ -0,0 +1,68 @@
+"""merge.py — 递归内联本地 #include，去除 include guard / pragma once"""
+import re
+import sys
+from pathlib import Path
+
+_GUARD_TOP    = re.compile(
+    r'^\s*#\s*ifndef\s+(\w+)\s*\n\s*#\s*define\s+\1\b[^\n]*\n', re.MULTILINE)
+_GUARD_BOTTOM = re.compile(r'\n\s*#\s*endif\s*(?://[^\n]*)?\s*$')
+_PRAGMA_ONCE  = re.compile(r'^\s*#\s*pragma\s+once\s*$', re.MULTILINE)
+
+
+def strip_include_guard(code: str) -> str:
+    code = _PRAGMA_ONCE.sub('', code, count=1)
+    m = _GUARD_TOP.search(code)
+    if m:
+        code = code[m.end():]
+        code = _GUARD_BOTTOM.sub('', code, count=1)
+    return code
+
+
+def merge_files(filepath: Path, include_dirs: list,
+                visited: set, sys_includes: list) -> str:
+    real_path = filepath.resolve()
+    if real_path in visited:
+        return ''
+    visited.add(real_path)
+
+    try:
+        code = real_path.read_text(encoding='utf-8-sig', errors='replace')
+    except FileNotFoundError:
+        print(f'[警告] 找不到文件：{real_path}', file=sys.stderr)
+        return ''
+
+    code = strip_include_guard(code)
+    parts = []
+
+    for line in code.splitlines(keepends=True):
+        s = line.strip()
+
+        # 系统头文件 #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)
+            continue
+
+        # 本地头文件 #include "..."
+        m_loc = re.match(r'#\s*include\s*"([^"]+)"', s)
+        if m_loc:
+            inc = m_loc.group(1)
+            found = None
+            for d in [real_path.parent] + list(include_dirs):
+                c = (d / inc).resolve()
+                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')
+            else:
+                print(f'[警告] 找不到本地头文件：{inc}', file=sys.stderr)
+                parts.append(line)
+            continue
+
+        parts.append(line)
+
+    return ''.join(parts)

cppgolf/strip_comments.py

@@ -0,0 +1,62 @@
+"""strip_comments.py — 移除 C/C++ 注释（状态机，感知字符串/字符字面量）"""
+import re
+
+
+def strip_comments(code: str) -> str:
+    """移除所有 C/C++ 注释，保留字符串/字符字面量内容不变。"""
+    result = []
+    i = 0
+    n = len(code)
+
+    while i < n:
+        # 原始字符串 R"delimiter(...)delimiter"
+        raw_m = re.match(r'R"([^()\\ \t\n]*)\(', code[i:])
+        if raw_m:
+            delim = raw_m.group(1)
+            end_marker = ')' + delim + '"'
+            end_idx = code.find(end_marker, i + raw_m.end())
+            if end_idx == -1:
+                result.append(code[i:]); break
+            end_idx += len(end_marker)
+            result.append(code[i:end_idx]); i = end_idx; continue
+
+        # 字符串字面量
+        if code[i] == '"':
+            j = i + 1
+            while j < n:
+                if code[j] == '\\': j += 2
+                elif code[j] == '"': j += 1; break
+                else: j += 1
+            result.append(code[i:j]); i = j; continue
+
+        # 字符字面量
+        if code[i] == "'":
+            j = i + 1
+            while j < n:
+                if code[j] == '\\': j += 2
+                elif code[j] == "'": j += 1; break
+                else: j += 1
+            result.append(code[i:j]); i = j; continue
+
+        # 行注释  // ...
+        if code[i:i+2] == '//':
+            j = i + 2
+            while j < n:
+                if code[j] == '\\' and j+1 < n and code[j+1] == '\n': j += 2
+                elif code[j] == '\n': break
+                else: j += 1
+            result.append(' '); i = j; continue
+
+        # 块注释  /* ... */
+        if code[i:i+2] == '/*':
+            j = i + 2
+            while j < n - 1:
+                if code[j:j+2] == '*/': j += 2; break
+                j += 1
+            nl = code[i:j].count('\n')
+            result.append('\n' * nl if nl else ' ')
+            i = j; continue
+
+        result.append(code[i]); i += 1
+
+    return ''.join(result)

cppgolf/transforms.py

@@ -0,0 +1,99 @@
+"""transforms.py — 语义级高尔夫变换（std::、typedef、endl、inline、braces、shortcuts）"""
+import re
+
+
+def golf_std_namespace(code: str) -> str:
+    """若代码有 std:: 则添加 using namespace std; 并删除所有 std:: 前缀。"""
+    has_using = bool(re.search(r'\busing\s+namespace\s+std\s*;', code))
+    if not re.search(r'\bstd::', code):
+        return code
+    if not has_using:
+        lines = code.split('\n')
+        insert_at = len(lines)
+        for idx, line in enumerate(lines):
+            s = line.strip()
+            if s and not s.startswith('#'):
+                insert_at = idx; break
+        lines.insert(insert_at, 'using namespace std;')
+        code = '\n'.join(lines)
+    return re.sub(r'\bstd::', '', code)
+
+
+def golf_typedefs(code: str) -> str:
+    """对高频长类型名添加 #define 缩写（出现 ≥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>'),
+    ]
+    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:
+            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,
+        )
+        code = code[:last] + '\n' + '\n'.join(defines_to_add) + '\n' + code[last:]
+    return code
+
+
+def golf_remove_main_return(code: str) -> str:
+    """移除 main 末尾的 return 0;（C++ 标准允许省略）。"""
+    return re.sub(
+        r'(int\s+main\s*\([^)]*\)\s*\{.*?)(\s*return\s+0\s*;\s*)(\})',
+        lambda m: m.group(1) + '\n' + m.group(3),
+        code, flags=re.DOTALL,
+    )
+
+
+def golf_endl_to_newline(code: str) -> str:
+    r"""将 endl 替换为 '\n'（避免 flush，且更短）。"""
+    nl_str = r'"\n"'
+    code = re.sub(r'<<\s*endl\b', lambda _: '<< ' + nl_str, code)
+    code = re.sub(r'\bendl\b(?=\s*[;,)])', lambda _: nl_str, code)
+    return code
+
+
+def golf_remove_inline(code: str) -> str:
+    """移除 inline，保留 inline static（C++17 内联静态成员变量）。"""
+    return re.sub(r'\binline\s+(?!static\b)', '', code)
+
+
+def golf_braces_single_stmt(code: str) -> str:
+    """（激进）移除单条语句 if/for/while 的花括号。"""
+    return re.compile(
+        r'\b(if|for|while)\s*(\([^)]*\))\s*\{\s*([^{};]*;)\s*\}',
+        re.DOTALL,
+    ).sub(r'\1\2\3', code)
+
+
+def golf_define_shortcuts(code: str) -> str:
+    """高频（≥5次）cout/cin 生成 #define 缩写。"""
+    shortcuts = [
+        (r'\bcout\b', 'co', '#define co cout'),
+        (r'\bcin\b',  'ci', '#define ci cin'),
+    ]
+    defines_to_add = []
+    for pattern, short, defline in shortcuts:
+        if re.search(re.escape(defline), code):
+            continue
+        if len(re.findall(pattern, code)) >= 5:
+            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,
+        )
+        code = code[:last] + '\n' + '\n'.join(defines_to_add) + '\n' + code[last:]
+    return code

cppgolf/whitespace.py

@@ -0,0 +1,127 @@
+"""whitespace.py — token 级空白压缩（字符串/预处理行感知）"""
+import re
+
+_IDENT_END   = re.compile(r'[A-Za-z0-9_]$')
+_IDENT_START = re.compile(r'^[A-Za-z0-9_]')
+
+# 完整预处理行（含续行 \）
+_PP_LINE_RE = re.compile(r'[ \t]*#[^\n]*(?:\\\n[^\n]*)*')
+
+# token 正则
+_TOKENIZE_RE = re.compile(
+    r'(\x01[^\x01]+\x01)'                      # \x01PP...\x01
+    r'|(\x02[^\x02]+\x02)'                      # \x02S...\x02
+    r'|(0[xX][0-9A-Fa-f]+[uUlL]*'              # 十六进制
+    r'|0[bB][01]+[uUlL]*'                       # 二进制
+    r'|\d[\d.]*(?:[eE][+-]?\d+)?[uUlLfF]*'     # 整数/浮点
+    r'|\.[\d]+(?:[eE][+-]?\d+)?[fF]?)'         # .开头浮点
+    r'|([A-Za-z_]\w*)'                          # 标识符
+    r'|(>>=|<<=|->|\.\.\.|::'                   # 多字符运算符
+    r'|[+\-*/%&|^]=|==|!=|<=|>=|<<|>>|\+\+|\-\-|&&|\|\|'
+    r'|[~!%^&*()\-+=\[\]{}|;:,.<>?/])'
+    r'|(\n[ \t]*)'                              # 换行
+    r'|([ \t]+)',                               # 水平空白
+)
+
+
+def _needs_space(a: str, b: str) -> bool:
+    if not a or not b:
+        return False
+    if _IDENT_END.search(a) and _IDENT_START.match(b):
+        return True
+    if a[-1] in '+-' and b[0] == a[-1]:
+        return True
+    return False
+
+
+def _tokenize(code: str) -> list:
+    tokens = []
+    for pp_ph, str_ph, num, ident, op, nl, sp in _TOKENIZE_RE.findall(code):
+        if   pp_ph:  tokens.append(('lit', pp_ph))
+        elif str_ph: tokens.append(('lit', str_ph))
+        elif num:    tokens.append(('num', num))
+        elif ident:  tokens.append(('id',  ident))
+        elif op:     tokens.append(('op',  op))
+        elif nl:     tokens.append(('nl',  '\n'))
+        elif sp:     tokens.append(('sp',  ' '))
+    return tokens
+
+
+def _extract_strings(src: str) -> tuple[str, list]:
+    """提取字符串/字符字面量，替换为 \\x02S{n}\\x02 占位符。"""
+    str_lits: list = []
+    result = []
+    i = 0
+    n = len(src)
+    while i < n:
+        raw_m = re.match(r'R"([^()\\ \t\n]*)\(', src[i:])
+        if raw_m:
+            delim = raw_m.group(1)
+            end_marker = ')' + delim + '"'
+            end_idx = src.find(end_marker, i + raw_m.end())
+            if end_idx == -1:
+                result.append(src[i:]); break
+            end_idx += len(end_marker)
+            idx = len(str_lits); str_lits.append(src[i:end_idx])
+            result.append(f'\x02S{idx}\x02'); i = end_idx; continue
+        if src[i] == '"':
+            j = i + 1
+            while j < n:
+                if src[j] == '\\': j += 2
+                elif src[j] == '"': j += 1; break
+                else: j += 1
+            idx = len(str_lits); str_lits.append(src[i:j])
+            result.append(f'\x02S{idx}\x02'); i = j; continue
+        if src[i] == "'":
+            j = i + 1
+            while j < n:
+                if src[j] == '\\': j += 2
+                elif src[j] == "'": j += 1; break
+                else: j += 1
+            idx = len(str_lits); str_lits.append(src[i:j])
+            result.append(f'\x02S{idx}\x02'); i = j; continue
+        result.append(src[i]); i += 1
+    return ''.join(result), str_lits
+
+
+def compress_whitespace(code: str) -> str:
+    """
+    1. 提取字符串字面量 → \\x02S{n}\\x02
+    2. 提取预处理行    → \\x01PP{n}\\x01
+    3. token 级空白最小化
+    4. 还原 PP 行 / 字符串字面量
+    """
+    code_no_str, str_lits = _extract_strings(code)
+
+    pp_lines: list = []
+
+    def replace_pp(m):
+        idx = len(pp_lines)
+        pp_lines.append(m.group(0).strip())
+        return f'\x01PP{idx}\x01'
+
+    code_no_pp = _PP_LINE_RE.sub(replace_pp, code_no_str)
+
+    tokens = _tokenize(code_no_pp)
+    out: list = []
+    prev_val = ''
+    pending_space = False
+    for kind, val in tokens:
+        if kind in ('nl', 'sp'):
+            pending_space = True
+        else:
+            if pending_space and _needs_space(prev_val, val):
+                out.append(' ')
+            pending_space = False
+            out.append(val)
+            prev_val = val
+
+    code_min = ''.join(out)
+    code_min = re.sub(r'\x01PP(\d+)\x01',
+                      lambda m: '\n' + pp_lines[int(m.group(1))] + '\n',
+                      code_min)
+    code_min = re.sub(r'\x02S(\d+)\x02',
+                      lambda m: str_lits[int(m.group(1))],
+                      code_min)
+    code_min = re.sub(r'\n{2,}', '\n', code_min)
+    return code_min.strip()

cppgolf-0.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: cppgolf
+Version: 0.1.0
+Summary: C++ multi-file merge & code golf / minifier tool
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/cppgolf
+Project-URL: Issues, https://github.com/yourname/cppgolf/issues
+Keywords: cpp,c++,golf,minify,code-golf,competitive-programming
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+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
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# CPPGolf
+
+C++ 多文件合并 + 代码高尔夫（压缩）工具，专为竞技编程场景设计。
+
+## 安装
+
+```bash
+pip install cppgolf
+```
+
+## CLI 用法
+
+```bash
+cppgolf solution.cpp                       # 输出到 stdout
+cppgolf solution.cpp -o golf.cpp           # 输出到文件
+cppgolf solution.cpp -I include/ -o out.cpp
+cppgolf solution.cpp --rename              # 符号压缩
+```
+
+### 选项
+
+| 选项 | 说明 |
+|------|------|
+| `-o FILE` | 输出文件（默认 stdout） |
+| `-I DIR` | 追加 include 搜索目录（可多次） |
+| `--no-merge` | 跳过 `#include "..."` 内联 |
+| `--no-strip-comments` | 保留注释 |
+| `--no-compress-ws` | 保留空白格式 |
+| `--no-std-ns` | 不添加 `using namespace std` |
+| `--no-typedefs` | 不添加 `ll`/`ld` 等类型宏 |
+| `--keep-main-return` | 保留 `return 0;` |
+| `--keep-endl` | 保留 `endl` |
+| `--keep-inline` | 保留 `inline` 关键字 |
+| `--aggressive` | 去除单语句 if/for/while 花括号 |
+| `--shortcuts` | 高频 cout/cin → `#define` 缩写 |
+| `--rename` | 变量/成员名压缩为 a/b/aa/… |
+| `--stats` | 显示压缩率统计 |
+
+## Python API
+
+```python
+from cppgolf import process
+from pathlib import Path
+
+result = process(
+    Path("solution.cpp"),
+    include_dirs=[],          # 额外的 #include 搜索目录
+    rename_symbols=True,
+)
+print(result)
+```
+
+也可单独使用各 pass：
+
+```python
+from cppgolf import strip_comments, compress_whitespace, golf_rename_symbols
+
+code = open("a.cpp").read()
+code = strip_comments(code)
+code = golf_rename_symbols(code)
+code = compress_whitespace(code)
+```
+
+## 功能说明
+
+- **合并**：递归内联 `#include "..."` 本地头文件，去除 include guard / `#pragma once`，系统头去重
+- **去注释**：状态机感知字符串，支持 `//`、`/* */`、原始字符串 `R"(...)"` 
+- **语义压缩**：`std::` 消除、`long long→ll` 宏、`endl→"\n"`、去 `return 0;`、去 `inline`
+- **空白压缩**：token 级最小化，代码压为单行，预处理行保留换行
+- **符号重命名**：tree-sitter AST 驱动，仅重命名用户自定义变量/参数/成员名，不碰函数名/类型名/命名空间

cppgolf-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+cppgolf/__init__.py,sha256=AvGeURSWj92-Q1rpU0zMP-Hhwy-ZxQLLY8LZ9UxUNAc,1306
+cppgolf/__main__.py,sha256=193sWXGl7F46qmoZf0dNXh634tTf-FIoEq040_1HSj4,5627
+cppgolf/golf_rename.py,sha256=5vYDadhqmTkJdXd9tCZD4krurKkDOCNMDGaiTa450DQ,22938
+cppgolf/merge.py,sha256=0f5NkDpJAzNrk4gOgByCxfZGLEWkPa4n2zIrbeyIYGE,2304
+cppgolf/strip_comments.py,sha256=u5t3FzGQ00IU8z-qzvyHtz7ujmT2wILIX8Zwkt0msik,2051
+cppgolf/transforms.py,sha256=YMxpY41iPgD8iqlsYiTx_t_hQTlTU3PFM4tUby9p1OI,3910
+cppgolf/whitespace.py,sha256=x13TZ9oqpgH566QwHuan7ArIL2-2l7usJJmpZJn99Eg,4567
+cppgolf-0.1.0.dist-info/METADATA,sha256=qxy7DvOOjvI-IXPjBn_cG4vEwD9pmhBHESfwIJaqcfk,3341
+cppgolf-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+cppgolf-0.1.0.dist-info/entry_points.txt,sha256=LLvAb8oAIYhpuSI96XviIXHzH3_FVpv4_ptaMFtsnhE,50
+cppgolf-0.1.0.dist-info/top_level.txt,sha256=nE1Myu2JceWMeVSMq3WSiGzhTeHlKPHfwyiDcmd9gGk,8
+cppgolf-0.1.0.dist-info/RECORD,,

cppgolf-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cppgolf-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cppgolf = cppgolf.__main__:main

cppgolf-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cppgolf