| """
|
| Compile a Python script into an executable that embeds CPython.
|
| Requires CPython to be built as a shared library ('libpythonX.Y').
|
|
|
| Basic usage:
|
|
|
| python -m Cython.Build.BuildExecutable [ARGS] somefile.py
|
| """
|
|
|
| from __future__ import absolute_import
|
|
|
| DEBUG = True
|
|
|
| import sys
|
| import os
|
| if sys.version_info < (3, 9):
|
| from distutils import sysconfig as _sysconfig
|
|
|
| class sysconfig(object):
|
|
|
| @staticmethod
|
| def get_path(name):
|
| assert name == 'include'
|
| return _sysconfig.get_python_inc()
|
|
|
| get_config_var = staticmethod(_sysconfig.get_config_var)
|
| else:
|
|
|
| import sysconfig
|
|
|
|
|
| def get_config_var(name, default=''):
|
| return sysconfig.get_config_var(name) or default
|
|
|
| INCDIR = sysconfig.get_path('include')
|
| LIBDIR1 = get_config_var('LIBDIR')
|
| LIBDIR2 = get_config_var('LIBPL')
|
| PYLIB = get_config_var('LIBRARY')
|
| PYLIB_DYN = get_config_var('LDLIBRARY')
|
| if PYLIB_DYN == PYLIB:
|
|
|
| PYLIB_DYN = ''
|
| else:
|
| PYLIB_DYN = os.path.splitext(PYLIB_DYN[3:])[0]
|
|
|
| CC = get_config_var('CC', os.environ.get('CC', ''))
|
| CFLAGS = get_config_var('CFLAGS') + ' ' + os.environ.get('CFLAGS', '')
|
| LINKCC = get_config_var('LINKCC', os.environ.get('LINKCC', CC))
|
| LINKFORSHARED = get_config_var('LINKFORSHARED')
|
| LIBS = get_config_var('LIBS')
|
| SYSLIBS = get_config_var('SYSLIBS')
|
| EXE_EXT = sysconfig.get_config_var('EXE')
|
|
|
|
|
| def _debug(msg, *args):
|
| if DEBUG:
|
| if args:
|
| msg = msg % args
|
| sys.stderr.write(msg + '\n')
|
|
|
|
|
| def dump_config():
|
| _debug('INCDIR: %s', INCDIR)
|
| _debug('LIBDIR1: %s', LIBDIR1)
|
| _debug('LIBDIR2: %s', LIBDIR2)
|
| _debug('PYLIB: %s', PYLIB)
|
| _debug('PYLIB_DYN: %s', PYLIB_DYN)
|
| _debug('CC: %s', CC)
|
| _debug('CFLAGS: %s', CFLAGS)
|
| _debug('LINKCC: %s', LINKCC)
|
| _debug('LINKFORSHARED: %s', LINKFORSHARED)
|
| _debug('LIBS: %s', LIBS)
|
| _debug('SYSLIBS: %s', SYSLIBS)
|
| _debug('EXE_EXT: %s', EXE_EXT)
|
|
|
|
|
| def _parse_args(args):
|
| cy_args = []
|
| last_arg = None
|
| for i, arg in enumerate(args):
|
| if arg.startswith('-'):
|
| cy_args.append(arg)
|
| elif last_arg in ('-X', '--directive'):
|
| cy_args.append(arg)
|
| else:
|
| input_file = arg
|
| args = args[i+1:]
|
| break
|
| last_arg = arg
|
| else:
|
| raise ValueError('no input file provided')
|
|
|
| return input_file, cy_args, args
|
|
|
|
|
| def runcmd(cmd, shell=True):
|
| if shell:
|
| cmd = ' '.join(cmd)
|
| _debug(cmd)
|
| else:
|
| _debug(' '.join(cmd))
|
|
|
| import subprocess
|
| returncode = subprocess.call(cmd, shell=shell)
|
|
|
| if returncode:
|
| sys.exit(returncode)
|
|
|
|
|
| def clink(basename):
|
| runcmd([LINKCC, '-o', basename + EXE_EXT, basename+'.o', '-L'+LIBDIR1, '-L'+LIBDIR2]
|
| + [PYLIB_DYN and ('-l'+PYLIB_DYN) or os.path.join(LIBDIR1, PYLIB)]
|
| + LIBS.split() + SYSLIBS.split() + LINKFORSHARED.split())
|
|
|
|
|
| def ccompile(basename):
|
| runcmd([CC, '-c', '-o', basename+'.o', basename+'.c', '-I' + INCDIR] + CFLAGS.split())
|
|
|
|
|
| def cycompile(input_file, options=()):
|
| from ..Compiler import Version, CmdLine, Main
|
| options, sources = CmdLine.parse_command_line(list(options or ()) + ['--embed', input_file])
|
| _debug('Using Cython %s to compile %s', Version.version, input_file)
|
| result = Main.compile(sources, options)
|
| if result.num_errors > 0:
|
| sys.exit(1)
|
|
|
|
|
| def exec_file(program_name, args=()):
|
| runcmd([os.path.abspath(program_name)] + list(args), shell=False)
|
|
|
|
|
| def build(input_file, compiler_args=(), force=False):
|
| """
|
| Build an executable program from a Cython module.
|
|
|
| Returns the name of the executable file.
|
| """
|
| basename = os.path.splitext(input_file)[0]
|
| exe_file = basename + EXE_EXT
|
| if not force and os.path.abspath(exe_file) == os.path.abspath(input_file):
|
| raise ValueError("Input and output file names are the same, refusing to overwrite")
|
| if (not force and os.path.exists(exe_file) and os.path.exists(input_file)
|
| and os.path.getmtime(input_file) <= os.path.getmtime(exe_file)):
|
| _debug("File is up to date, not regenerating %s", exe_file)
|
| return exe_file
|
| cycompile(input_file, compiler_args)
|
| ccompile(basename)
|
| clink(basename)
|
| return exe_file
|
|
|
|
|
| def build_and_run(args):
|
| """
|
| Build an executable program from a Cython module and run it.
|
|
|
| Arguments after the module name will be passed verbatimly to the program.
|
| """
|
| program_name, args = _build(args)
|
| exec_file(program_name, args)
|
|
|
|
|
| def _build(args):
|
| input_file, cy_args, args = _parse_args(args)
|
| program_name = build(input_file, cy_args)
|
| return program_name, args
|
|
|
|
|
| if __name__ == '__main__':
|
| _build(sys.argv[1:])
|
|
|
