c2py23 0.3.0__py3-none-any.whl

c2py23/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import print_function
+
+__version__ = "0.3.0"

c2py23/c2py_loader.py

@@ -0,0 +1,126 @@
+"""c2py_loader - Load a c2py23-native .so by explicit filename.
+
+Convention: <module>.c2py23-<os>_<arch>.so
+
+Example files:
+    _mymodule.c2py23-linux_x86_64.so
+    _mymodule.c2py23-linux_ppc64le.so
+    _mymodule.c2py23-linux_aarch64.so
+    _mymodule.c2py23-win_amd64.pyd
+    _mymodule.c2py23-darwin_arm64.so
+
+No monkeypatching of EXTENSION_SUFFIXES.  No sys.path hacking.
+Loads the .so by full path via ExtensionFileLoader (Python 3.x) or
+imp.load_dynamic (Python 2.7).
+
+Usage in your package's __init__.py:
+
+    from c2py23.c2py_loader import load_native
+    import os as _os
+    _mod = load_native(_os.path.dirname(_os.path.abspath(__file__)),
+                       '_mymodule')
+    # Re-export public names (skip dunders, keep single-underscore API)
+    for _k, _v in _mod.__dict__.items():
+        if _k.startswith('__') and _k.endswith('__'):
+            continue
+        globals()[_k] = _v
+
+Users who do not want a c2py23 runtime dependency can copy the
+function body into their own __init__.py.  The code is intentionally
+small and self-contained.
+"""
+from __future__ import print_function
+
+import os
+import sys
+import platform as _platform
+
+
+def _platform_key():
+    """Return 'linux_x86_64', 'win_amd64', 'linux_ppc64le', etc."""
+    _os = sys.platform
+    if _os == 'linux2':
+        _os = 'linux'
+    elif _os == 'win32':
+        _os = 'win'
+    _arch = _platform.machine()
+    if _arch == 'AMD64':
+        if _os == 'win':
+            _arch = 'amd64'
+        else:
+            _arch = 'x86_64'
+    return '%s_%s' % (_os, _arch)
+
+
+def load_native(package_dir, module_name='_native', tag='c2py23'):
+    """Load <module_name>.<tag>-<platform_key>.so from package_dir.
+
+    Args:
+    package_dir: Absolute path to the package directory containing
+                 the .so files.
+    module_name: Base module name (default '_native').
+                 Must match the c2py23 YAML 'module:' field.
+                 Use a unique name per package (e.g. '_mymodule')
+                 to avoid collisions in sys.modules.
+        tag:         Tag string inserted in the filename (default 'c2py23').
+
+    Returns:
+        The loaded module object.  The caller should re-export public
+        names from it.
+
+    Example:
+        _mod = load_native(os.path.dirname(__file__), '_mymodule')
+    """
+    _key = _platform_key()
+    if os.name == 'nt':
+        _ext = '.pyd'
+    else:
+        _ext = '.so'
+    _filename = '%s.%s-%s%s' % (module_name, tag, _key, _ext)
+    _path = os.path.join(package_dir, _filename)
+
+    _trace = os.environ.get('C2PY_TRACE')
+    if _trace:
+        print('[c2py_loader] platform=%s file=%s' % (_key, _filename),
+              file=sys.stderr)
+
+    if not os.path.isfile(_path):
+        _alternatives = [
+            f for f in os.listdir(package_dir)
+            if f.startswith(module_name + '.')
+        ]
+        _hint = ', '.join(sorted(_alternatives)) if _alternatives else 'none'
+        raise ImportError(
+            "c2py23: native module not found for platform '%s'\n"
+            "  Expected: %s\n"
+            "  Available: %s\n"
+            "  Build with: gcc -shared -fPIC ... -o %s" %
+            (_key, _filename, _hint, _path))
+
+    if _trace:
+        print('[c2py_loader] loading %s -> %s' % (module_name, _path),
+              file=sys.stderr)
+
+    if sys.version_info[0] >= 3:
+        import importlib.machinery
+        import importlib.util
+        loader = importlib.machinery.ExtensionFileLoader(
+            module_name, _path)
+        spec = importlib.util.spec_from_file_location(
+            module_name, _path, loader=loader)
+        mod = importlib.util.module_from_spec(spec)
+        # Warn if overwriting an existing module in sys.modules.
+        # Using distinct module names per package (e.g. '_mymodule'
+        # instead of '_native') avoids collisions.
+        if module_name in sys.modules:
+            import warnings as _w
+            _w.warn(
+                "c2py_loader: overwriting existing module '%s' "
+                "in sys.modules. Use a unique module name."
+                % module_name)
+        sys.modules[module_name] = mod
+        loader.exec_module(mod)
+        return mod
+    else:
+        import imp
+        return imp.load_dynamic(module_name, _path)

c2py23/cli.py

@@ -0,0 +1,277 @@
+"""CLI entry point for c2py23.
+
+Usage:
+    c2py23 build foo.c2py [-o foo.so] [--asan] [--generate-only] [--compile-only [--source s.c ...] [--include d/ ...]]
+    c2py23 generate foo.c2py [-o wrapper.c]
+"""
+from __future__ import print_function
+
+import sys
+import os
+import subprocess
+import argparse
+
+from c2py23.parser import load_c2py
+from c2py23.generator import generate
+
+
+def _generate_wrapper(c2py_path, output_path=None):
+    """Parse a .c2py file and generate the wrapper C file.
+
+    Returns (wrapper_path, module_def).
+    """
+    if not os.path.exists(c2py_path):
+        print("ERROR: file not found: {}".format(c2py_path), file=sys.stderr)
+        sys.exit(1)
+
+    print("Parsing {}...".format(c2py_path))
+    module_def = load_c2py(c2py_path)
+    mod_name = module_def.name
+
+    if output_path:
+        wrapper_path = output_path
+    else:
+        wrapper_c = mod_name + '_wrapper.c'
+        wrapper_path = os.path.join(os.path.dirname(c2py_path) or '.', wrapper_c)
+
+    from c2py23.generator import generate as _gen
+    c_code = _gen(module_def)
+    try:
+        with open(wrapper_path, 'w') as f:
+            f.write(c_code)
+    except IOError as e:
+        sys.exit("Error writing {}: {}".format(wrapper_path, e))
+
+    return wrapper_path, module_def
+
+
+def _collect_user_sources(base_dir, module_def):
+    """Collect user C source files, resolving relative paths against base_dir.
+
+    Returns list of absolute paths.
+    """
+    source_files = []
+    for src in module_def.sources:
+        # Normalise: join(base_dir, src) handles both absolute and relative
+        src_path = os.path.normpath(os.path.join(base_dir, src))
+        if not os.path.exists(src_path):
+            print("ERROR: source file not found: {}".format(src_path), file=sys.stderr)
+            sys.exit(1)
+        source_files.append(src_path)
+    return source_files
+
+
+def _collect_include_dirs(base_dir, module_def, extra_dirs=None):
+    """Collect include directories from module_def sources plus extra dirs.
+
+    Returns list of unique include directory paths.
+    """
+    include_dirs = [base_dir]
+    src_dirs = set()
+    for src in module_def.sources:
+        d = os.path.dirname(os.path.join(base_dir, src))
+        if d not in include_dirs:
+            src_dirs.add(d)
+    for d in sorted(src_dirs):
+        include_dirs.append(d)
+    if extra_dirs:
+        for d in extra_dirs:
+            if d not in include_dirs:
+                include_dirs.append(d)
+    return include_dirs
+
+
+def _compile_wrapper(wrapper_path, source_files, include_dirs, output_so, asan=False):
+    """Compile a wrapper .c file (plus runtime and user sources) to a .so/.pyd."""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    runtime_dir = os.path.join(script_dir, 'runtime')
+    runtime_c = os.path.join(runtime_dir, 'c2py_runtime.c')
+
+    all_sources = [runtime_c, wrapper_path] + list(source_files)
+    for src_path in all_sources:
+        if not os.path.exists(src_path):
+            print("ERROR: source file not found: {}".format(src_path), file=sys.stderr)
+            sys.exit(1)
+
+    all_includes = [runtime_dir] + list(include_dirs)
+
+    is_win = sys.platform == 'win32'
+
+    if is_win:
+        cc = os.environ.get('CC', '')
+        if not cc:
+            cc = _find_msvc() or 'gcc'
+        if cc == 'cl' or cc.endswith('cl.exe') or cc.endswith('cl'):
+            is_msvc = True
+        else:
+            is_msvc = False
+    else:
+        cc = os.environ.get('CC', 'gcc')
+        is_msvc = False
+
+    if is_msvc:
+        _default_cflags = '/W4'
+    else:
+        _default_cflags = '-Wall -Werror -Wpointer-arith'
+    cflags = [f for f in os.environ.get('CFLAGS', _default_cflags).split() if f]
+    ldflags = [f for f in os.environ.get('LDFLAGS', '').split() if f]
+
+    if asan:
+        if is_msvc:
+            cflags.append('/fsanitize=address')
+        else:
+            cflags.append('-fsanitize=address')
+            cflags.append('-g')
+            cflags.append('-O1')
+            ldflags.append('-fsanitize=address')
+        print("  [ASan enabled]")
+
+    if is_win:
+        default_libs = '-lkernel32' if not is_msvc else ''
+        libs = os.environ.get('LIBS', default_libs).split()
+        libs = [l for l in libs if l]
+    else:
+        libs = os.environ.get('LIBS', '-ldl -lm').split()
+
+    if is_msvc:
+        include_flags = []
+        for d in all_includes:
+            include_flags.extend(['/I', d])
+        cmd = [cc, '/nologo', '/LD'] + cflags + include_flags + all_sources
+        cmd += libs + ['/Fe' + output_so]
+    elif is_win:
+        include_flags = []
+        for d in all_includes:
+            include_flags.extend(['-I', d])
+        cmd = [cc, '-shared'] + include_flags + cflags + all_sources
+        cmd += ldflags + libs + ['-o', output_so]
+    else:
+        include_flags = []
+        for d in all_includes:
+            include_flags.extend(['-I', d])
+        cmd = ([cc, '-shared', '-fPIC'] + include_flags + cflags +
+               all_sources + ldflags + libs + ['-o', output_so])
+
+    print("Compiling {}...".format(output_so))
+    print("  " + ' '.join(cmd))
+    ret = subprocess.call(cmd)
+    if ret != 0:
+        print("ERROR: compilation failed", file=sys.stderr)
+        sys.exit(1)
+
+    print("Success: {}".format(output_so))
+
+
+def _find_msvc():
+    """Find MSVC cl.exe in PATH or standard VS install locations.
+    Returns path string or None."""
+    import platform as _plat
+    for candidate in ['cl', 'cl.exe']:
+        for path in os.environ.get('PATH', '').split(os.pathsep):
+            full = os.path.join(path, candidate)
+            if os.path.isfile(full):
+                return candidate
+    return None
+
+
+def _determine_so_path(output_arg, default_name, base_dir):
+    """Determine the .so/.pyd output path."""
+    if output_arg:
+        return output_arg
+    ext = '.pyd' if sys.platform == 'win32' else '.so'
+    return os.path.join(base_dir, default_name + ext)
+
+
+def cmd_build(args):
+    """Parse a .c2py file and generate + compile a .so module."""
+    c2py_path = args.file
+
+    # --generate-only: stop after writing wrapper .c
+    if getattr(args, 'generate_only', False):
+        wrapper_path, _ = _generate_wrapper(c2py_path, args.output)
+        print("Wrapper written to: {}".format(wrapper_path))
+        return
+
+    # --compile-only: skip parse+generate, compile existing wrapper.c
+    if getattr(args, 'compile_only', False):
+        wrapper_path = c2py_path
+        if not os.path.exists(wrapper_path):
+            print("ERROR: wrapper file not found: {}".format(wrapper_path), file=sys.stderr)
+            sys.exit(1)
+
+        source_files = args.source or []
+        source_files = [os.path.abspath(s) for s in source_files]
+
+        include_dirs = args.include or []
+        include_dirs = [os.path.abspath(d) for d in include_dirs]
+
+        base = os.path.splitext(os.path.basename(wrapper_path))[0]
+        so_base = base.replace('_wrapper', '')
+        output_so = _determine_so_path(args.output, so_base,
+                                        os.path.dirname(wrapper_path) or '.')
+        _compile_wrapper(wrapper_path, source_files, include_dirs, output_so,
+                          asan=getattr(args, 'asan', False))
+        return
+
+    # Normal build: parse + generate + compile
+    base_dir = os.path.dirname(os.path.abspath(c2py_path))
+
+    wrapper_path, module_def = _generate_wrapper(c2py_path)
+
+    source_files = _collect_user_sources(base_dir, module_def)
+    include_dirs = _collect_include_dirs(base_dir, module_def)
+
+    output_so = _determine_so_path(args.output, module_def.name, base_dir)
+
+    _compile_wrapper(wrapper_path, source_files, include_dirs, output_so,
+                      asan=getattr(args, 'asan', False))
+
+
+def cmd_generate(args):
+    """Generate C wrapper from a .c2py file without compiling."""
+    wrapper_path, _ = _generate_wrapper(args.file, args.output)
+    print("Wrapper written to: %s" % wrapper_path)
+
+def _add_build_parser(sub):
+    build_p = sub.add_parser('build', help='Build a .so from a .c2py file')
+    build_p.add_argument('file', help='Path to .c2py interface file')
+    build_p.add_argument('-o', '--output', help='Output .so path (or wrapper .c path with --generate-only)')
+
+    build_p.add_argument('--asan', action='store_true',
+                          help='Compile with -fsanitize=address '
+                               '(detects buffer overflows, leaks, use-after-free)')
+    build_p.add_argument('--generate-only', action='store_true',
+                          help='Generate wrapper .c only, do not compile')
+    build_p.add_argument('--compile-only', action='store_true',
+                          help='Compile an existing wrapper .c file (skip parse+generate)')
+    build_p.add_argument('-s', '--source', action='append',
+                          help='User C source files (repeatable, for --compile-only)')
+    build_p.add_argument('-I', '--include', action='append',
+                          help='Include directories (repeatable, for --compile-only)')
+    build_p.set_defaults(func=cmd_build)
+
+
+def _add_generate_parser(sub):
+    gen_p = sub.add_parser('generate', help='Generate wrapper .c from .c2py (no compilation)')
+    gen_p.add_argument('file', help='Path to .c2py interface file')
+    gen_p.add_argument('-o', '--output', help='Output wrapper .c path')
+    gen_p.set_defaults(func=cmd_generate)
+
+
+def main():
+    parser = argparse.ArgumentParser(prog='c2py23',
+                                      description='Wrap C99 code to Python via the buffer protocol')
+    sub = parser.add_subparsers(dest='command', help='Commands')
+
+    _add_build_parser(sub)
+    _add_generate_parser(sub)
+
+    args = parser.parse_args()
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+    args.func(args)
+
+
+if __name__ == '__main__':
+    main()