|
|
""" |
|
|
Build a c-extension module on-the-fly in tests. |
|
|
See build_and_import_extensions for usage hints |
|
|
|
|
|
""" |
|
|
|
|
|
import os |
|
|
import pathlib |
|
|
import subprocess |
|
|
import sys |
|
|
import sysconfig |
|
|
import textwrap |
|
|
|
|
|
__all__ = ['build_and_import_extension', 'compile_extension_module'] |
|
|
|
|
|
|
|
|
def build_and_import_extension( |
|
|
modname, functions, *, prologue="", build_dir=None, |
|
|
include_dirs=None, more_init=""): |
|
|
""" |
|
|
Build and imports a c-extension module `modname` from a list of function |
|
|
fragments `functions`. |
|
|
|
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
functions : list of fragments |
|
|
Each fragment is a sequence of func_name, calling convention, snippet. |
|
|
prologue : string |
|
|
Code to precede the rest, usually extra ``#include`` or ``#define`` |
|
|
macros. |
|
|
build_dir : pathlib.Path |
|
|
Where to build the module, usually a temporary directory |
|
|
include_dirs : list |
|
|
Extra directories to find include files when compiling |
|
|
more_init : string |
|
|
Code to appear in the module PyMODINIT_FUNC |
|
|
|
|
|
Returns |
|
|
------- |
|
|
out: module |
|
|
The module will have been loaded and is ready for use |
|
|
|
|
|
Examples |
|
|
-------- |
|
|
>>> functions = [("test_bytes", "METH_O", \"\"\" |
|
|
if ( !PyBytesCheck(args)) { |
|
|
Py_RETURN_FALSE; |
|
|
} |
|
|
Py_RETURN_TRUE; |
|
|
\"\"\")] |
|
|
>>> mod = build_and_import_extension("testme", functions) |
|
|
>>> assert not mod.test_bytes('abc') |
|
|
>>> assert mod.test_bytes(b'abc') |
|
|
""" |
|
|
if include_dirs is None: |
|
|
include_dirs = [] |
|
|
body = prologue + _make_methods(functions, modname) |
|
|
init = """ |
|
|
PyObject *mod = PyModule_Create(&moduledef); |
|
|
#ifdef Py_GIL_DISABLED |
|
|
PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED); |
|
|
#endif |
|
|
""" |
|
|
if not build_dir: |
|
|
build_dir = pathlib.Path('.') |
|
|
if more_init: |
|
|
init += """#define INITERROR return NULL |
|
|
""" |
|
|
init += more_init |
|
|
init += "\nreturn mod;" |
|
|
source_string = _make_source(modname, init, body) |
|
|
mod_so = compile_extension_module( |
|
|
modname, build_dir, include_dirs, source_string) |
|
|
import importlib.util |
|
|
spec = importlib.util.spec_from_file_location(modname, mod_so) |
|
|
foo = importlib.util.module_from_spec(spec) |
|
|
spec.loader.exec_module(foo) |
|
|
return foo |
|
|
|
|
|
|
|
|
def compile_extension_module( |
|
|
name, builddir, include_dirs, |
|
|
source_string, libraries=None, library_dirs=None): |
|
|
""" |
|
|
Build an extension module and return the filename of the resulting |
|
|
native code file. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
name : string |
|
|
name of the module, possibly including dots if it is a module inside a |
|
|
package. |
|
|
builddir : pathlib.Path |
|
|
Where to build the module, usually a temporary directory |
|
|
include_dirs : list |
|
|
Extra directories to find include files when compiling |
|
|
libraries : list |
|
|
Libraries to link into the extension module |
|
|
library_dirs: list |
|
|
Where to find the libraries, ``-L`` passed to the linker |
|
|
""" |
|
|
modname = name.split('.')[-1] |
|
|
dirname = builddir / name |
|
|
dirname.mkdir(exist_ok=True) |
|
|
cfile = _convert_str_to_file(source_string, dirname) |
|
|
include_dirs = include_dirs or [] |
|
|
libraries = libraries or [] |
|
|
library_dirs = library_dirs or [] |
|
|
|
|
|
return _c_compile( |
|
|
cfile, outputfilename=dirname / modname, |
|
|
include_dirs=include_dirs, libraries=libraries, |
|
|
library_dirs=library_dirs, |
|
|
) |
|
|
|
|
|
|
|
|
def _convert_str_to_file(source, dirname): |
|
|
"""Helper function to create a file ``source.c`` in `dirname` that contains |
|
|
the string in `source`. Returns the file name |
|
|
""" |
|
|
filename = dirname / 'source.c' |
|
|
with filename.open('w') as f: |
|
|
f.write(str(source)) |
|
|
return filename |
|
|
|
|
|
|
|
|
def _make_methods(functions, modname): |
|
|
""" Turns the name, signature, code in functions into complete functions |
|
|
and lists them in a methods_table. Then turns the methods_table into a |
|
|
``PyMethodDef`` structure and returns the resulting code fragment ready |
|
|
for compilation |
|
|
""" |
|
|
methods_table = [] |
|
|
codes = [] |
|
|
for funcname, flags, code in functions: |
|
|
cfuncname = f"{modname}_{funcname}" |
|
|
if 'METH_KEYWORDS' in flags: |
|
|
signature = '(PyObject *self, PyObject *args, PyObject *kwargs)' |
|
|
else: |
|
|
signature = '(PyObject *self, PyObject *args)' |
|
|
methods_table.append( |
|
|
"{\"%s\", (PyCFunction)%s, %s}," % (funcname, cfuncname, flags)) |
|
|
func_code = f""" |
|
|
static PyObject* {cfuncname}{signature} |
|
|
{{ |
|
|
{code} |
|
|
}} |
|
|
""" |
|
|
codes.append(func_code) |
|
|
|
|
|
body = "\n".join(codes) + """ |
|
|
static PyMethodDef methods[] = { |
|
|
%(methods)s |
|
|
{ NULL } |
|
|
}; |
|
|
static struct PyModuleDef moduledef = { |
|
|
PyModuleDef_HEAD_INIT, |
|
|
"%(modname)s", /* m_name */ |
|
|
NULL, /* m_doc */ |
|
|
-1, /* m_size */ |
|
|
methods, /* m_methods */ |
|
|
}; |
|
|
""" % {'methods': '\n'.join(methods_table), 'modname': modname} |
|
|
return body |
|
|
|
|
|
|
|
|
def _make_source(name, init, body): |
|
|
""" Combines the code fragments into source code ready to be compiled |
|
|
""" |
|
|
code = """ |
|
|
#include <Python.h> |
|
|
|
|
|
%(body)s |
|
|
|
|
|
PyMODINIT_FUNC |
|
|
PyInit_%(name)s(void) { |
|
|
%(init)s |
|
|
} |
|
|
""" % { |
|
|
'name': name, 'init': init, 'body': body, |
|
|
} |
|
|
return code |
|
|
|
|
|
|
|
|
def _c_compile(cfile, outputfilename, include_dirs, libraries, |
|
|
library_dirs): |
|
|
link_extra = [] |
|
|
if sys.platform == 'win32': |
|
|
compile_extra = ["/we4013"] |
|
|
link_extra.append('/DEBUG') |
|
|
elif sys.platform.startswith('linux'): |
|
|
compile_extra = [ |
|
|
"-O0", "-g", "-Werror=implicit-function-declaration", "-fPIC"] |
|
|
else: |
|
|
compile_extra = [] |
|
|
|
|
|
return build( |
|
|
cfile, outputfilename, |
|
|
compile_extra, link_extra, |
|
|
include_dirs, libraries, library_dirs) |
|
|
|
|
|
|
|
|
def build(cfile, outputfilename, compile_extra, link_extra, |
|
|
include_dirs, libraries, library_dirs): |
|
|
"use meson to build" |
|
|
|
|
|
build_dir = cfile.parent / "build" |
|
|
os.makedirs(build_dir, exist_ok=True) |
|
|
with open(cfile.parent / "meson.build", "wt") as fid: |
|
|
link_dirs = ['-L' + d for d in library_dirs] |
|
|
fid.write(textwrap.dedent(f"""\ |
|
|
project('foo', 'c') |
|
|
py = import('python').find_installation(pure: false) |
|
|
py.extension_module( |
|
|
'{outputfilename.parts[-1]}', |
|
|
'{cfile.parts[-1]}', |
|
|
c_args: {compile_extra}, |
|
|
link_args: {link_dirs}, |
|
|
include_directories: {include_dirs}, |
|
|
) |
|
|
""")) |
|
|
native_file_name = cfile.parent / ".mesonpy-native-file.ini" |
|
|
with open(native_file_name, "wt") as fid: |
|
|
fid.write(textwrap.dedent(f"""\ |
|
|
[binaries] |
|
|
python = '{sys.executable}' |
|
|
""")) |
|
|
if sys.platform == "win32": |
|
|
subprocess.check_call(["meson", "setup", |
|
|
"--buildtype=release", |
|
|
"--vsenv", ".."], |
|
|
cwd=build_dir, |
|
|
) |
|
|
else: |
|
|
subprocess.check_call(["meson", "setup", "--vsenv", |
|
|
"..", f'--native-file={os.fspath(native_file_name)}'], |
|
|
cwd=build_dir |
|
|
) |
|
|
|
|
|
so_name = outputfilename.parts[-1] + get_so_suffix() |
|
|
subprocess.check_call(["meson", "compile"], cwd=build_dir) |
|
|
os.rename(str(build_dir / so_name), cfile.parent / so_name) |
|
|
return cfile.parent / so_name |
|
|
|
|
|
|
|
|
def get_so_suffix(): |
|
|
ret = sysconfig.get_config_var('EXT_SUFFIX') |
|
|
assert ret |
|
|
return ret |
|
|
|
