pycc-compiler 1.4.6__tar.gz

pycc_compiler-1.4.6/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: pycc-compiler
+Version: 1.4.6
+Summary: Compile Python to ELF executable
+Home-page: https://github.com/yourname/pycc
+Author: pycc contributors
+Author-email: 
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Android
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cython>=3.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pycc - Python to ELF Compiler
+
+A tool to compile Python/Pyrex files to standalone executables or shared libraries.
+
+## Features
+
+- Compile `.py` and `.pyx` files to ELF executables
+- Generate shared libraries (`.so`) for Python imports
+- Support `-c` to generate C files, `-cpp` for C++ files
+- Interactive mode for rapid prototyping
+- Optimize with `-O0` to `-O3`
+- Static compilation with clang
+
+## Installation
+
+```bash
+pip install pycc-compiler

pycc_compiler-1.4.6/README.md

@@ -0,0 +1,17 @@
+# pycc - Python to ELF Compiler
+
+A tool to compile Python/Pyrex files to standalone executables or shared libraries.
+
+## Features
+
+- Compile `.py` and `.pyx` files to ELF executables
+- Generate shared libraries (`.so`) for Python imports
+- Support `-c` to generate C files, `-cpp` for C++ files
+- Interactive mode for rapid prototyping
+- Optimize with `-O0` to `-O3`
+- Static compilation with clang
+
+## Installation
+
+```bash
+pip install pycc-compiler

pycc_compiler-1.4.6/pycc/__init__.py

@@ -0,0 +1,14 @@
+#!/data/data/com.termux/files/usr/bin/python
+"""
+pycc - Python to ELF Compiler
+Compile Python/Pyrex files to standalone executables or shared libraries.
+"""
+
+__version__ = "1.4.6"
+__author__ = "pycc contributors"
+__description__ = "Compile Python to ELF executable"
+
+from .pycc import main
+
+if __name__ == "__main__":
+    main()

pycc_compiler-1.4.6/pycc/pycc.py

@@ -0,0 +1,878 @@
+#!/data/data/com.termux/files/usr/bin/python
+
+import os
+import sys
+import shutil
+import subprocess
+import re
+import readline
+import time
+
+VERSION = "1.4.6"
+DESCRIPTION = "compile python to ELF"
+
+# 颜色代码
+RED = '\033[91m'
+GREEN = '\033[92m'
+YELLOW = '\033[93m'
+BLUE = '\033[94m'
+CYAN = '\033[96m'
+NC = '\033[0m'
+
+VERBOSE = False
+QUIET = False
+
+def print_error(msg):
+    print(f"pycc: {RED}error:{NC} {msg}", file=sys.stderr)
+
+def print_warning(msg):
+    if not QUIET:
+        print(f"pycc: {YELLOW}warning:{NC} {msg}", file=sys.stderr)
+
+def print_success(msg):
+    if VERBOSE and not QUIET:
+        print(f"pycc: {GREEN}success:{NC} {msg}", file=sys.stderr)
+
+def print_info(msg):
+    if VERBOSE and not QUIET:
+        print(f"pycc: {msg}", file=sys.stderr)
+
+def print_debug(msg):
+    if VERBOSE:
+        print(msg, file=sys.stderr)
+
+def print_cmd(cmd):
+    if VERBOSE:
+        print(' '.join(cmd), file=sys.stderr)
+
+def spinning_cursor():
+    while True:
+        for cursor in '|/-\\':
+            yield cursor
+
+def show_progress(message, duration=0.5):
+    spinner = spinning_cursor()
+    end_time = time.time() + duration
+    while time.time() < end_time:
+        sys.stderr.write(f'\r{message} {next(spinner)} ')
+        sys.stderr.flush()
+        time.sleep(0.1)
+    sys.stderr.write('\r' + ' ' * (len(message) + 2) + '\r')
+    sys.stderr.flush()
+
+def get_python_version():
+    env_version = os.environ.get('PYCC_PY_VERSION')
+    if env_version:
+        print_debug(f"Using PYCC_PY_VERSION={env_version}")
+        return env_version
+    
+    try:
+        result = subprocess.run(
+            ['python3', '-c', 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")'],
+            capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            version = result.stdout.strip()
+            print_debug(f"Detected Python version: {version}")
+            return version
+    except:
+        pass
+    
+    print_debug("Using default Python version: 3.13")
+    return "3.13"
+
+def get_clang_version():
+    try:
+        result = subprocess.run(['clang', '--version'], capture_output=True, text=True)
+        if result.returncode == 0:
+            lines = result.stdout.strip().split('\n')
+            if lines:
+                return lines[0]
+    except:
+        pass
+    return "clang"
+
+def get_python_include():
+    py_version = get_python_version()
+    include_path = f"/data/data/com.termux/files/usr/include/python{py_version}"
+    
+    if os.path.exists(include_path):
+        print_debug(f"Using Python include: {include_path}")
+        return include_path
+    
+    try:
+        result = subprocess.run(['python3-config', '--includes'], capture_output=True, text=True)
+        if result.returncode == 0:
+            match = re.search(r'-I([^\s]+)', result.stdout)
+            if match:
+                path = match.group(1)
+                print_debug(f"Got include from python3-config: {path}")
+                return path
+    except:
+        pass
+    
+    print_debug(f"Using default include: {include_path}")
+    return include_path
+
+def get_python_lib():
+    py_version = get_python_version()
+    lib_path = f"/data/data/com.termux/files/usr/lib"
+    lib_name = f"python{py_version}"
+    
+    print_debug(f"Python lib path: {lib_path}, lib name: {lib_name}")
+    return lib_path, lib_name
+
+def check_dynamic_code(content):
+    patterns = [r'compile\s*\(', r'exec\s*\(', r'eval\s*\(']
+    for pattern in patterns:
+        if re.search(pattern, content):
+            return True
+    return False
+
+def run_with_python(input_file, args):
+    cmd = ['python', input_file] + args
+    print_debug(f"Running Python: {' '.join(cmd)}")
+    os.system(' '.join(cmd))
+
+def get_compiler(input_file):
+    if input_file.endswith(('.c')):
+        return 'clang'
+    elif input_file.endswith(('.cpp', '.cc', '.cxx')):
+        return 'clang++'
+    else:
+        return None
+
+def is_valid_module_name(name):
+    return re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', name) is not None
+
+def fix_module_name(input_file):
+    base_name = os.path.splitext(os.path.basename(input_file))[0]
+    
+    if is_valid_module_name(base_name):
+        print_debug(f"Valid module name: {base_name}")
+        return input_file, None
+    
+    new_base_name = f"pycc_v{VERSION}_{base_name}"
+    new_base_name = re.sub(r'[^a-zA-Z0-9_]', '_', new_base_name)
+    if not re.match(r'^[a-zA-Z_]', new_base_name):
+        new_base_name = '_' + new_base_name
+    
+    new_file = os.path.join(os.path.dirname(input_file), f"{new_base_name}.py")
+    
+    print_warning(f"Invalid module name '{base_name}', renamed to '{new_base_name}'")
+    print_debug(f"Renamed: {input_file} -> {new_file}")
+    
+    shutil.copy2(input_file, new_file)
+    
+    return new_file, new_base_name
+
+def run_clang_mode(args):
+    if len(args) < 2:
+        print_error("--clang mode missing arguments")
+        sys.exit(1)
+    
+    clang_args = args[1:]
+    compiler = 'clang'
+    output_file = None
+    
+    for i, arg in enumerate(clang_args):
+        if arg in ['-o', '--output'] and i + 1 < len(clang_args):
+            output_file = clang_args[i + 1]
+            break
+    
+    for arg in clang_args:
+        if not arg.startswith('-') and os.path.exists(arg):
+            ext_compiler = get_compiler(arg)
+            if ext_compiler:
+                compiler = ext_compiler
+            break
+    
+    if not output_file:
+        for arg in clang_args:
+            if not arg.startswith('-') and os.path.exists(arg):
+                base_name = os.path.splitext(os.path.basename(arg))[0]
+                output_file = f"./{base_name}.out"
+                clang_args = clang_args[:] + ['-o', output_file]
+                break
+    
+    cmd = [compiler] + clang_args
+    print_cmd(cmd)
+    result = subprocess.run(cmd)
+    sys.exit(result.returncode)
+
+def add_compile_marker(output_file):
+    marker = f"Compiled by pycc {VERSION}"
+    try:
+        with open(output_file, 'ab') as f:
+            f.write(f"\n{marker}\0".encode())
+        print_debug(f"Added compile marker: {marker}")
+    except Exception as e:
+        print_debug(f"Failed to add marker: {e}")
+
+def compile_to_so(input_file, output, opt_level, other_flags, site_install, py_version, py_include, py_lib_path, py_lib_name):
+    file_ext = os.path.splitext(input_file)[1].lower()
+    is_c = file_ext in ['.c', '.cpp', '.cc', '.cxx']
+    
+    if is_c:
+        if output:
+            so_output = output
+        else:
+            base_name = os.path.splitext(os.path.basename(input_file))[0]
+            so_output = f"{base_name}.so"
+        
+        if file_ext == '.c':
+            compiler = 'clang'
+        else:
+            compiler = 'clang++'
+        
+        compile_cmd = [
+            compiler, '-shared', '-fPIC', f'-O{opt_level}', '-o', so_output, input_file,
+            f'-I{py_include}', f'-L{py_lib_path}', f'-l{py_lib_name}',
+            '-lpthread', '-lm', '-lutil', '-ldl'
+        ] + other_flags
+        
+        print_cmd(compile_cmd)
+        result = subprocess.run(compile_cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            print_error("Compilation error:")
+            print(result.stderr, file=sys.stderr)
+            sys.exit(1)
+        
+        os.chmod(so_output, 0o755)
+        add_compile_marker(so_output)
+        
+        if site_install:
+            site_dir = f"{py_lib_path}/python{py_version}/site-packages"
+            target = os.path.join(site_dir, os.path.basename(so_output))
+            shutil.copy2(so_output, target)
+            os.chmod(target, 0o755)
+            add_compile_marker(target)
+            if VERBOSE and not QUIET:
+                print_success(f"Installed to: {target}")
+                print_info(f"Python {py_version}")
+        else:
+            if VERBOSE and not QUIET:
+                print_info(f"Shared library: {so_output}")
+        return
+    
+    work_dir = os.path.expanduser('~/tmp/pycc_build')
+    os.makedirs(work_dir, exist_ok=True)
+    
+    try:
+        base_name = os.path.splitext(os.path.basename(input_file))[0]
+        
+        if output:
+            module_name = os.path.splitext(os.path.basename(output))[0]
+        else:
+            module_name = base_name
+        
+        if not is_valid_module_name(module_name):
+            print_error(f"Invalid module name '{module_name}'")
+            sys.exit(1)
+        
+        module_pyx = os.path.join(work_dir, f"{module_name}.pyx")
+        shutil.copy2(input_file, module_pyx)
+        print_debug(f"Copied: {input_file} -> {module_pyx}")
+        
+        out_file = os.path.join(work_dir, f"{module_name}.c")
+        cython_cmd = ['cython', '--embed', '-3', module_pyx, '-o', out_file]
+        
+        print_debug(f"Cython output: {out_file}")
+        print_cmd(cython_cmd)
+        
+        result = subprocess.run(cython_cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            print_error("Cython error:")
+            print(result.stderr, file=sys.stderr)
+            sys.exit(1)
+        
+        print_debug("Cython successful")
+        
+        so_output = output if output else f"{module_name}.so"
+        compile_cmd = [
+            'clang', '-shared', '-fPIC', f'-O{opt_level}', '-o', so_output, out_file,
+            f'-I{py_include}', f'-L{py_lib_path}', f'-l{py_lib_name}',
+            '-lpthread', '-lm', '-lutil', '-ldl'
+        ] + other_flags
+        
+        print_cmd(compile_cmd)
+        result = subprocess.run(compile_cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            print_error("Compilation error:")
+            print(result.stderr, file=sys.stderr)
+            sys.exit(1)
+        
+        os.chmod(so_output, 0o755)
+        add_compile_marker(so_output)
+        
+        if site_install:
+            site_dir = f"{py_lib_path}/python{py_version}/site-packages"
+            target = os.path.join(site_dir, os.path.basename(so_output))
+            shutil.copy2(so_output, target)
+            os.chmod(target, 0o755)
+            add_compile_marker(target)
+            if VERBOSE and not QUIET:
+                print_success(f"Installed to: {target}")
+                print_info(f"Python {py_version}")
+        else:
+            if VERBOSE and not QUIET:
+                print_info(f"Shared library: {so_output}")
+    
+    finally:
+        if os.path.exists(work_dir):
+            shutil.rmtree(work_dir)
+            print_debug(f"Cleaned: {work_dir}")
+
+# 交互模式的代码存储
+interactive_code = []
+
+def is_print_statement(line):
+    """判断是否是 print 语句"""
+    stripped = line.strip()
+    return re.match(r'^print\s*\(', stripped) is not None
+
+def is_shell_command(line):
+    """判断是否是 shell 命令（以 shell: 开头）"""
+    stripped = line.strip()
+    return stripped.startswith('shell:')
+
+def is_os_system_output(line):
+    """判断是否是 os.system('echo ...') 或 os.system('printf ...') 等输出命令"""
+    stripped = line.strip()
+    # 匹配 os.system('echo ...') 或 os.system("printf ...")
+    pattern = r'^os\.system\s*\(\s*[\'"]?(echo|printf)\s*'
+    return re.search(pattern, stripped) is not None
+
+def interactive_mode():
+    global interactive_code
+    
+    clang_ver = get_clang_version()
+    py_ver = get_python_version()
+    
+    print(f"{GREEN}pycc version {VERSION}{NC} [{clang_ver}]")
+    print(f"Python {py_ver}")
+    print(f'Enter Python commands, type {CYAN}RUN{NC} to compile and execute, {CYAN}exit{NC} to quit')
+    print(f'  {CYAN}shell:{NC} command - execute shell command (not saved)')
+    print(f'  Print statements and os.system("echo/printf") are executed but NOT saved')
+    
+    history_file = os.path.expanduser('~/.pycc_history')
+    try:
+        readline.read_history_file(history_file)
+    except:
+        pass
+    
+    # 临时文件路径
+    temp_py = os.path.expanduser('~/tmp/__pycc_interaction__.py')
+    temp_bin = os.path.expanduser('~/tmp/__pycc_interaction__.out')
+    os.makedirs(os.path.dirname(temp_py), exist_ok=True)
+    
+    try:
+        while True:
+            try:
+                line = input(f"{BLUE}P>>{NC} ").strip()
+                if not line:
+                    continue
+                
+                if line.lower() == 'exit':
+                    break
+                
+                if line.upper() == 'RUN':
+                    if interactive_code:
+                        with open(temp_py, 'w') as f:
+                            f.write('\n'.join(interactive_code))
+                        
+                        show_progress("Compiling", 0.8)
+                        
+                        pycc_cmd = sys.argv[0]
+                        if not os.path.exists(pycc_cmd):
+                            pycc_cmd = shutil.which('pycc')
+                            if not pycc_cmd:
+                                pycc_cmd = sys.executable + ' ' + __file__
+                        
+                        cmd = [pycc_cmd, temp_py, '-o', temp_bin, '-q']
+                        result = subprocess.run(cmd, capture_output=True, text=True)
+                        
+                        if result.returncode != 0:
+                            print(f"{RED}Compilation failed:{NC}")
+                            if result.stderr:
+                                for err_line in result.stderr.split('\n'):
+                                    if err_line.strip():
+                                        clean_line = re.sub(r'\x1b\[[0-9;]*m', '', err_line)
+                                        if clean_line.strip():
+                                            print(f"  {clean_line}")
+                            continue
+                        
+                        os.system('clear')
+                        print(f"{CYAN}Running...{NC}\n")
+                        subprocess.run([temp_bin])
+                        print(f"\n{CYAN}--- Done ---{NC}")
+                    else:
+                        print(f"{YELLOW}No code to execute{NC}")
+                    continue
+                
+                # shell: 命令 - 执行 shell 命令，不保存
+                if is_shell_command(line):
+                    shell_cmd = line[6:].strip()  # 去掉 "shell:"
+                    if shell_cmd:
+                        print(f"{CYAN}$ {shell_cmd}{NC}")
+                        os.system(shell_cmd)
+                    continue
+                
+                # os.system('echo...') 或 os.system('printf...') - 执行但不保存
+                if is_os_system_output(line):
+                    # 执行但不保存
+                    temp_os_py = os.path.expanduser('~/tmp/__pycc_os__.py')
+                    with open(temp_os_py, 'w') as f:
+                        # 先写入所有保存的代码（确保变量存在）
+                        f.write('\n'.join(interactive_code))
+                        f.write('\n')
+                        f.write(line)
+                    
+                    subprocess.run(['python3', temp_os_py])
+                    os.unlink(temp_os_py)
+                    continue
+                
+                # print 语句 - 执行但不保存
+                if is_print_statement(line):
+                    temp_print_py = os.path.expanduser('~/tmp/__pycc_print__.py')
+                    with open(temp_print_py, 'w') as f:
+                        f.write('\n'.join(interactive_code))
+                        f.write('\n')
+                        f.write(line)
+                    
+                    subprocess.run(['python3', temp_print_py])
+                    os.unlink(temp_print_py)
+                    continue
+                
+                # 其他代码：保存
+                interactive_code.append(line)
+                try:
+                    readline.write_history_file(history_file)
+                except:
+                    pass
+                    
+            except KeyboardInterrupt:
+                print(f"\n{YELLOW}Use 'exit' to quit{NC}")
+            except EOFError:
+                break
+    finally:
+        if os.path.exists(temp_py):
+            os.unlink(temp_py)
+        if os.path.exists(temp_bin):
+            os.unlink(temp_bin)
+    
+    if interactive_code:
+        print(f"{YELLOW}Unsaved code left (use RUN to execute){NC}")
+    try:
+        readline.write_history_file(history_file)
+    except:
+        pass
+
+def main():
+    global VERBOSE, QUIET
+    
+    if len(sys.argv) > 1 and sys.argv[1] in ['-i', '--interactive']:
+        interactive_mode()
+        return
+    
+    if len(sys.argv) > 1 and sys.argv[1] in ['-c', '-cpp'] and any(x in sys.argv[2:] for x in ['--clang', '-clg']):
+        pycc_source = sys.argv[1]
+        output_file = None
+        clang_args = []
+        i = 1
+        while i < len(sys.argv):
+            arg = sys.argv[i]
+            if arg in ['-c', '-cpp']:
+                pycc_source = arg
+                i += 1
+            elif arg in ['--clang', '-clg']:
+                clang_args = sys.argv[i+1:]
+                break
+            elif arg in ['-o', '--output'] and i+1 < len(sys.argv):
+                output_file = sys.argv[i+1]
+                i += 2
+            else:
+                i += 1
+        
+        source_file = None
+        for arg in clang_args:
+            if not arg.startswith('-') and os.path.exists(arg):
+                source_file = arg
+                break
+        
+        if not source_file:
+            print_error("Missing input file for clang mode")
+            sys.exit(1)
+        
+        work_dir = os.path.expanduser('~/tmp/pycc_build')
+        os.makedirs(work_dir, exist_ok=True)
+        
+        try:
+            base_name = os.path.splitext(os.path.basename(source_file))[0]
+            pyx_file = os.path.join(work_dir, f"{base_name}.pyx")
+            shutil.copy2(source_file, pyx_file)
+            
+            if pycc_source == '-c':
+                out_file = os.path.join(work_dir, f"{base_name}.c")
+                cython_cmd = ['cython', '--embed', '-3', pyx_file, '-o', out_file]
+            else:
+                out_file = os.path.join(work_dir, f"{base_name}.cpp")
+                cython_cmd = ['cython', '--embed', '-3', '--cplus', pyx_file, '-o', out_file]
+            
+            print_debug(f"Generating {out_file}")
+            result = subprocess.run(cython_cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                print_error("Cython error:")
+                print(result.stderr, file=sys.stderr)
+                sys.exit(1)
+            
+            final_output = output_file if output_file else f"{base_name}.{ 'c' if pycc_source == '-c' else 'cpp' }"
+            shutil.copy2(out_file, final_output)
+            print_info(f"Generated: {final_output}")
+            
+            if clang_args:
+                clang_cmd = ['clang' if final_output.endswith('.c') else 'clang++'] + clang_args
+                if not output_file:
+                    base_out = os.path.splitext(os.path.basename(source_file))[0]
+                    clang_cmd.extend(['-o', f"{base_out}.out"])
+                print_cmd(clang_cmd)
+                result = subprocess.run(clang_cmd)
+                sys.exit(result.returncode)
+        finally:
+            if os.path.exists(work_dir):
+                shutil.rmtree(work_dir)
+        return
+    
+    if len(sys.argv) > 1 and sys.argv[1] in ['--clang', '-clg']:
+        run_clang_mode(sys.argv[1:])
+        return
+    
+    if '--version' in sys.argv:
+        print(f"pycc {VERSION}")
+        print(DESCRIPTION)
+        return
+    
+    if '--help' in sys.argv or '-h' in sys.argv:
+        print(f"pycc {VERSION} - {DESCRIPTION}")
+        print("\nUsage: pycc [options] <input.py/.pyx/.c/.cpp> [args...]")
+        print("       pycc --clang [clang options...]")
+        print("       pycc -i --interactive")
+        print("\nOptions:")
+        print("  -O0, -O1, -O2, -O3   Optimization level (default -O0)")
+        print("  -o, --output         Output file name")
+        print("  -run                 Compile and run (no output file kept)")
+        print("  -c                   Generate C file (.c)")
+        print("  -cpp                 Generate C++ file (.cpp)")
+        print("  -so                  Generate shared library (.so)")
+        print("  --site, -s           Install to site-packages (with -so)")
+        print("  -i, --interactive    Interactive mode")
+        print("  -v                   Verbose mode (show commands)")
+        print("  -q                   Quiet mode (suppress warnings)")
+        print("  -###                 Show compile commands without executing")
+        print("  --version            Show version information")
+        print("  --help, -h           Show this help message")
+        print("\nEnvironment:")
+        print("  PYCC_PY_VERSION      Specify Python version (auto-detected)")
+        print("\nClang passthrough mode:")
+        print("  --clang, -clg        Forward all args to clang/clang++")
+        return
+    
+    if len(sys.argv) < 2:
+        print_error("Missing input file")
+        sys.exit(1)
+    
+    input_file = None
+    other_args = []
+    script_args = []
+    
+    args_iter = iter(sys.argv[1:])
+    for arg in args_iter:
+        if not arg.startswith('-') and input_file is None:
+            input_file = arg
+        elif arg.startswith('-'):
+            if arg == '-v':
+                VERBOSE = True
+            elif arg == '-q':
+                QUIET = True
+            else:
+                other_args.append(arg)
+                if arg in ['-o', '--output']:
+                    try:
+                        next_arg = next(args_iter)
+                        other_args.append(next_arg)
+                    except StopIteration:
+                        pass
+        else:
+            if input_file is not None:
+                script_args.append(arg)
+            else:
+                other_args.append(arg)
+    
+    print_debug(f"Input file: {input_file}")
+    print_debug(f"Other args: {other_args}")
+    print_debug(f"Script args: {script_args}")
+    
+    if not input_file:
+        print_error("Missing input file")
+        sys.exit(1)
+    
+    if not os.path.exists(input_file):
+        print_error(f"File not found: {input_file}")
+        sys.exit(1)
+    
+    file_ext = os.path.splitext(input_file)[1].lower()
+    is_python = file_ext == '.py'
+    is_pyx = file_ext == '.pyx'
+    is_c = file_ext in ['.c', '.cpp', '.cc', '.cxx']
+    
+    output_c = '-c' in other_args
+    output_cpp = '-cpp' in other_args
+    output_so = '-so' in other_args
+    
+    run = '-run' in other_args
+    dry_run = '-###' in other_args
+    
+    if dry_run and (output_c or output_cpp or output_so):
+        print_error("-### cannot be used with -c/-cpp/-so")
+        sys.exit(1)
+    
+    site_install = '--site' in other_args or '-s' in other_args
+    
+    if sum([output_c, output_cpp, output_so]) > 1:
+        print_error("Only one of -c, -cpp, -so can be selected")
+        sys.exit(1)
+    
+    if is_c and not (output_c or output_cpp or output_so):
+        if output_c or output_cpp:
+            pass
+        else:
+            clang_args = [sys.argv[0], '--clang'] + sys.argv[1:]
+            has_output = False
+            for arg in sys.argv[1:]:
+                if arg in ['-o', '--output']:
+                    has_output = True
+                    break
+            
+            if not has_output:
+                base_name = os.path.splitext(os.path.basename(input_file))[0]
+                new_args = []
+                for arg in sys.argv[1:]:
+                    if arg == input_file and not has_output:
+                        new_args.extend(['-o', f"{base_name}.out", arg])
+                        has_output = True
+                    else:
+                        new_args.append(arg)
+                clang_args = [sys.argv[0], '--clang'] + new_args
+            
+            run_clang_mode(clang_args)
+            return
+    
+    if is_c and output_so:
+        opt_level = "0"
+        for opt in ['-O3', '-O2', '-O1', '-O0']:
+            if opt in other_args:
+                opt_level = opt[2]
+                other_args = [arg for arg in other_args if arg != opt]
+                break
+        
+        for flag in ['-so', '--site', '-s']:
+            if flag in other_args:
+                other_args = [arg for arg in other_args if arg != flag]
+        
+        other_flags = [arg for arg in other_args if arg.startswith('-') and arg not in ['-o', '--output']]
+        
+        output = None
+        for i, arg in enumerate(other_args):
+            if arg in ['-o', '--output'] and i + 1 < len(other_args):
+                output = other_args[i + 1]
+                break
+        
+        py_version = get_python_version()
+        py_include = get_python_include()
+        py_lib_path, py_lib_name = get_python_lib()
+        
+        compile_to_so(input_file, output, opt_level, other_flags, site_install,
+                      py_version, py_include, py_lib_path, py_lib_name)
+        return
+    
+    if not (is_python or is_pyx):
+        print_error(f"Unsupported file type: {input_file} (supported: .py, .pyx, .c, .cpp)")
+        sys.exit(1)
+    
+    opt_level = "0"
+    for opt in ['-O3', '-O2', '-O1', '-O0']:
+        if opt in other_args:
+            opt_level = opt[2]
+            other_args = [arg for arg in other_args if arg != opt]
+            break
+    
+    print_debug(f"Optimization level: -O{opt_level}")
+    
+    if run:
+        other_args = [arg for arg in other_args if arg != '-run']
+        print_debug("Mode: -run")
+    
+    if dry_run:
+        other_args = [arg for arg in other_args if arg != '-###']
+        print_debug("Mode: -###")
+    
+    for flag in ['-c', '-cpp', '-so', '--site', '-s']:
+        if flag in other_args:
+            other_args = [arg for arg in other_args if arg != flag]
+    
+    other_flags = [arg for arg in other_args if arg.startswith('-') and arg not in ['-o', '--output']]
+    
+    output = None
+    for i, arg in enumerate(other_args):
+        if arg in ['-o', '--output'] and i + 1 < len(other_args):
+            output = other_args[i + 1]
+            break
+    
+    print_debug(f"Output file: {output}")
+    
+    if output_so:
+        py_version = get_python_version()
+        py_include = get_python_include()
+        py_lib_path, py_lib_name = get_python_lib()
+        
+        compile_to_so(input_file, output, opt_level, other_flags, site_install,
+                      py_version, py_include, py_lib_path, py_lib_name)
+        return
+    
+    if output_c or output_cpp:
+        if is_python:
+            original_input = input_file
+            input_file, new_base_name = fix_module_name(input_file)
+            should_cleanup = new_base_name is not None
+        else:
+            original_input = input_file
+            should_cleanup = False
+        
+        work_dir = os.path.expanduser('~/tmp/pycc_build')
+        os.makedirs(work_dir, exist_ok=True)
+        
+        try:
+            base_name = os.path.splitext(os.path.basename(input_file))[0]
+            pyx_file = os.path.join(work_dir, f"{base_name}.pyx")
+            shutil.copy2(input_file, pyx_file)
+            print_debug(f"Copied: {input_file} -> {pyx_file}")
+            
+            if output_c:
+                out_file = os.path.join(work_dir, f"{base_name}.c")
+                cython_cmd = ['cython', '--embed', '-3', pyx_file, '-o', out_file]
+            else:
+                out_file = os.path.join(work_dir, f"{base_name}.cpp")
+                cython_cmd = ['cython', '--embed', '-3', '--cplus', pyx_file, '-o', out_file]
+            
+            print_cmd(cython_cmd)
+            
+            if dry_run:
+                print(' '.join(cython_cmd))
+                print(f"# Generate: {output if output else out_file}")
+                return
+            
+            result = subprocess.run(cython_cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                print_error("Cython error:")
+                print(result.stderr, file=sys.stderr)
+                sys.exit(1)
+            
+            final_output = output if output else out_file
+            shutil.copy2(out_file, final_output)
+            if VERBOSE and not QUIET:
+                print_info(f"Generated: {final_output}")
+        
+        finally:
+            if os.path.exists(work_dir) and not dry_run:
+                shutil.rmtree(work_dir)
+            if should_cleanup and os.path.exists(input_file):
+                os.remove(input_file)
+        return
+    
+    if is_python:
+        original_input = input_file
+        input_file, new_base_name = fix_module_name(input_file)
+        should_cleanup = new_base_name is not None
+    else:
+        original_input = input_file
+        should_cleanup = False
+    
+    py_version = get_python_version()
+    py_include = get_python_include()
+    py_lib_path, py_lib_name = get_python_lib()
+    
+    work_dir = os.path.expanduser('~/tmp/pycc_build')
+    os.makedirs(work_dir, exist_ok=True)
+    
+    try:
+        base_name = os.path.splitext(os.path.basename(input_file))[0]
+        pyx_file = os.path.join(work_dir, f"{base_name}.pyx")
+        shutil.copy2(input_file, pyx_file)
+        print_debug(f"Copied: {input_file} -> {pyx_file}")
+        
+        out_file = os.path.join(work_dir, f"{base_name}.c")
+        cython_cmd = ['cython', '--embed', '-3', pyx_file, '-o', out_file]
+        
+        print_debug(f"Cython output: {out_file}")
+        print_cmd(cython_cmd)
+        
+        if dry_run:
+            print(' '.join(cython_cmd))
+            compile_cmd = [
+                'clang', f'-O{opt_level}', '-o', output if output else f"./{base_name}.out", out_file,
+                f'-I{py_include}', f'-L{py_lib_path}', f'-l{py_lib_name}',
+                '-lpthread', '-lm', '-lutil', '-ldl'
+            ] + other_flags
+            print(' '.join(compile_cmd))
+            return
+        
+        result = subprocess.run(cython_cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            print_error("Cython error:")
+            print(result.stderr, file=sys.stderr)
+            sys.exit(1)
+        
+        print_debug("Cython successful")
+        
+        if run:
+            temp_output = os.path.join(work_dir, f"{base_name}.out")
+            final_output = temp_output
+        else:
+            if output:
+                final_output = output
+            else:
+                final_output = f"./{base_name}.out"
+        
+        compile_cmd = [
+            'clang', f'-O{opt_level}', '-o', final_output, out_file,
+            f'-I{py_include}', f'-L{py_lib_path}', f'-l{py_lib_name}',
+            '-lpthread', '-lm', '-lutil', '-ldl'
+        ] + other_flags
+        
+        print_cmd(compile_cmd)
+        result = subprocess.run(compile_cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            print_error("Compilation error:")
+            print(result.stderr, file=sys.stderr)
+            sys.exit(1)
+        
+        os.chmod(final_output, 0o755)
+        print_debug(f"Permissions set: {final_output}")
+        
+        add_compile_marker(final_output)
+        
+        if run:
+            cmd = [final_output] + script_args
+            print_debug(f"Running: {' '.join(cmd)}")
+            os.system(' '.join(cmd))
+    
+    finally:
+        if os.path.exists(work_dir) and not dry_run:
+            shutil.rmtree(work_dir)
+            print_debug(f"Cleaned: {work_dir}")
+        if should_cleanup and os.path.exists(input_file):
+            os.remove(input_file)
+            print_debug(f"Cleaned: {input_file}")
+
+if __name__ == '__main__':
+    main()

pycc_compiler-1.4.6/pycc_compiler.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: pycc-compiler
+Version: 1.4.6
+Summary: Compile Python to ELF executable
+Home-page: https://github.com/yourname/pycc
+Author: pycc contributors
+Author-email: 
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Android
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cython>=3.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pycc - Python to ELF Compiler
+
+A tool to compile Python/Pyrex files to standalone executables or shared libraries.
+
+## Features
+
+- Compile `.py` and `.pyx` files to ELF executables
+- Generate shared libraries (`.so`) for Python imports
+- Support `-c` to generate C files, `-cpp` for C++ files
+- Interactive mode for rapid prototyping
+- Optimize with `-O0` to `-O3`
+- Static compilation with clang
+
+## Installation
+
+```bash
+pip install pycc-compiler

pycc_compiler-1.4.6/pycc_compiler.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+setup.py
+pycc/__init__.py
+pycc/pycc.py
+pycc_compiler.egg-info/PKG-INFO
+pycc_compiler.egg-info/SOURCES.txt
+pycc_compiler.egg-info/dependency_links.txt
+pycc_compiler.egg-info/entry_points.txt
+pycc_compiler.egg-info/requires.txt
+pycc_compiler.egg-info/top_level.txt

pycc_compiler-1.4.6/pycc_compiler.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pycc_compiler-1.4.6/pycc_compiler.egg-info/entry_points.txt

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

pycc_compiler-1.4.6/pycc_compiler.egg-info/requires.txt

@@ -0,0 +1 @@
+cython>=3.0.0

pycc_compiler-1.4.6/pycc_compiler.egg-info/top_level.txt

@@ -0,0 +1 @@
+pycc

pycc_compiler-1.4.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pycc_compiler-1.4.6/setup.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+from setuptools import setup, find_packages
+import os
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("pycc/__init__.py", "r", encoding="utf-8") as f:
+    for line in f:
+        if line.startswith("__version__"):
+            version = line.split("=")[1].strip().strip('"')
+            break
+    else:
+        version = "1.4.6"
+
+setup(
+    name="pycc-compiler",
+    version=version,
+    author="pycc contributors",
+    author_email="",
+    description="Compile Python to ELF executable",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourname/pycc",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.13",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: Android",
+        "Operating System :: POSIX :: Linux",
+        "Environment :: Console",
+    ],
+    python_requires=">=3.8",
+    entry_points={
+        "console_scripts": [
+            "pycc=pycc.pycc:main",
+        ],
+    },
+    install_requires=[
+        "cython>=3.0.0",
+    ],
+)