def detectBinaryDLLs(binary_filename, package_name):
""" Detect the DLLs used by a binary.
Using "ldd" (Linux), "depends.exe" (Windows), or "otool" (MacOS) the list
of used DLLs is retrieved.
"""
if Utils.getOS() in ("Linux", "NetBSD"):
# TODO: FreeBSD may work the same way, not tested.
return _detectBinaryPathDLLsLinuxBSD(
binary_filename = binary_filename
)
elif Utils.getOS() == "Windows":
return _detectBinaryPathDLLsWindows(
binary_filename = binary_filename,
package_name = package_name
)
elif Utils.getOS() == "Darwin":
return _detectBinaryPathDLLsMacOS(
binary_filename = binary_filename
)
else:
# Support your platform above.
assert False, Utils.getOS()
def detectBinaryDLLs(is_main_executable, source_dir, original_filename,
binary_filename, package_name):
""" Detect the DLLs used by a binary.
Using "ldd" (Linux), "depends.exe" (Windows), or "otool" (MacOS) the list
of used DLLs is retrieved.
"""
if Utils.getOS() in ("Linux", "NetBSD", "FreeBSD"):
return _detectBinaryPathDLLsLinuxBSD(dll_filename=original_filename)
elif Utils.getOS() == "Windows":
with TimerReport("Running depends.exe for %s took %%.2f seconds" %
binary_filename):
return _detectBinaryPathDLLsWindows(
is_main_executable=is_main_executable,
source_dir=source_dir,
original_dir=os.path.dirname(original_filename),
binary_filename=binary_filename,
package_name=package_name)
elif Utils.getOS() == "Darwin":
return _detectBinaryPathDLLsMacOS(
original_dir=os.path.dirname(original_filename),
binary_filename=original_filename)
else:
# Support your platform above.
assert False, Utils.getOS()
def detectBinaryDLLs(original_dir, binary_filename, package_name):
""" Detect the DLLs used by a binary.
Using "ldd" (Linux), "depends.exe" (Windows), or "otool" (MacOS) the list
of used DLLs is retrieved.
"""
if Utils.getOS() in ("Linux", "NetBSD", "FreeBSD"):
return _detectBinaryPathDLLsLinuxBSD(
binary_filename = binary_filename
)
elif Utils.getOS() == "Windows":
return _detectBinaryPathDLLsWindows(
original_dir = original_dir,
binary_filename = binary_filename,
package_name = package_name
)
elif Utils.getOS() == "Darwin":
return _detectBinaryPathDLLsMacOS(
binary_filename = binary_filename
)
else:
# Support your platform above.
assert False, Utils.getOS()
def scanStandardLibraryPath(stdlib_dir):
# There is a lot of black-listing here, done in branches, so there
# is many of them, but that's acceptable, pylint: disable=R0912
for root, dirs, filenames in os.walk(stdlib_dir):
import_path = root[len(stdlib_dir):].strip("/\\")
import_path = import_path.replace('\\', '.').replace('/', '.')
if import_path == "":
if "site-packages" in dirs:
dirs.remove("site-packages")
if "dist-packages" in dirs:
dirs.remove("dist-packages")
if "test" in dirs:
dirs.remove("test")
if "idlelib" in dirs:
dirs.remove("idlelib")
if "turtledemo" in dirs:
dirs.remove("turtledemo")
if import_path in ("tkinter", "importlib", "ctypes"):
if "test" in dirs:
dirs.remove("test")
if import_path == "lib2to3":
if "tests" in dirs:
dirs.remove("tests")
if Utils.python_version >= 340 and Utils.getOS() == "Windows":
if import_path == "multiprocessing":
filenames.remove("popen_fork.py")
filenames.remove("popen_forkserver.py")
filenames.remove("popen_spawn_posix.py")
if Utils.getOS() == "NetBSD":
if import_path == "xml.sax":
filenames.remove("expatreader.py")
for filename in filenames:
if filename.endswith(".py") and filename not in ignore_modules:
module_name = filename[:-3]
if import_path == "":
yield module_name
else:
yield import_path + '.' + module_name
if Utils.python_version >= 300:
if "__pycache__" in dirs:
dirs.remove("__pycache__")
for dirname in dirs:
if import_path == "":
yield dirname
else:
yield import_path + '.' + dirname
def scanStandardLibraryPath(stdlib_dir):
# There is a lot of black-listing here, done in branches, so there
# is many of them, but that's acceptable, pylint: disable=R0912
for root, dirs, filenames in os.walk(stdlib_dir):
import_path = root[len(stdlib_dir):].strip("/\\")
import_path = import_path.replace('\\', '.').replace('/','.')
if import_path == "":
if "site-packages" in dirs:
dirs.remove("site-packages")
if "dist-packages" in dirs:
dirs.remove("dist-packages")
if "test" in dirs:
dirs.remove("test")
if "idlelib" in dirs:
dirs.remove("idlelib")
if "turtledemo" in dirs:
dirs.remove("turtledemo")
if import_path in ("tkinter", "importlib", "ctypes"):
if "test" in dirs:
dirs.remove("test")
if import_path == "lib2to3":
if "tests" in dirs:
dirs.remove("tests")
if Utils.python_version >= 340 and Utils.getOS() == "Windows":
if import_path == "multiprocessing":
filenames.remove("popen_fork.py")
filenames.remove("popen_forkserver.py")
filenames.remove("popen_spawn_posix.py")
if Utils.getOS() == "NetBSD":
if import_path == "xml.sax":
filenames.remove("expatreader.py")
for filename in filenames:
if filename.endswith(".py") and filename not in ignore_modules:
module_name = filename[:-3]
if import_path == "":
yield module_name
else:
yield import_path + '.' + module_name
if Utils.python_version >= 300:
if "__pycache__" in dirs:
dirs.remove("__pycache__")
for dirname in dirs:
if import_path == "":
yield dirname
else:
yield import_path + '.' + dirname
def detectBinaryDLLs(
is_main_executable,
source_dir,
original_filename,
binary_filename,
package_name,
use_cache,
update_cache,
):
""" Detect the DLLs used by a binary.
Using "ldd" (Linux), "pefile" or "depends.exe" (Windows), or
"otool" (macOS) the list of used DLLs is retrieved.
"""
if (
Utils.getOS() in ("Linux", "NetBSD", "FreeBSD", "OpenBSD")
or Utils.isPosixWindows()
):
return _detectBinaryPathDLLsPosix(dll_filename=original_filename)
elif Utils.isWin32Windows() and Options.getWindowsDependencyTool() == "pefile":
with TimerReport(
"Finding dependencies for %s took %%.2f seconds" % binary_filename
):
return detectBinaryPathDLLsWindowsPE(
is_main_executable=is_main_executable,
source_dir=source_dir,
original_dir=os.path.dirname(original_filename),
binary_filename=binary_filename,
package_name=package_name,
use_cache=use_cache,
update_cache=update_cache,
)
elif Utils.isWin32Windows():
with TimerReport(
"Running depends.exe for %s took %%.2f seconds" % binary_filename
):
return detectBinaryPathDLLsWindowsDependencyWalker(
is_main_executable=is_main_executable,
source_dir=source_dir,
original_dir=os.path.dirname(original_filename),
binary_filename=binary_filename,
package_name=package_name,
use_cache=use_cache,
update_cache=update_cache,
)
elif Utils.getOS() == "Darwin":
return _detectBinaryPathDLLsMacOS(
original_dir=os.path.dirname(original_filename),
binary_filename=original_filename,
keep_unresolved=False,
)
else:
# Support your platform above.
assert False, Utils.getOS()
def _setupSconsEnvironment():
""" Setup the scons execution environment.
For the scons inline copy on Windows needs to find the library, using
the "SCONS_LIB_DIR" environment variable "NUITKA_SCONS". And for the
target Python we provide "NUITKA_PYTHON_DLL_PATH" to see where the
Python DLL lives, in case it needs to be copied, and then the
"NUITKA_PYTHON_EXE_PATH" to find the Python binary itself.
"""
if Utils.getOS() == "Windows":
# On Windows this Scons variable must be set by us.
os.environ["SCONS_LIB_DIR"] = os.path.join(
_getSconsInlinePath(),
"lib",
"scons-2.3.2"
)
# On Windows, we use the Python.DLL path for some things. We pass it
# via environment variable
os.environ["NUITKA_PYTHON_DLL_PATH"] = getTargetPythonDLLPath()
os.environ["NUITKA_PYTHON_EXE_PATH"] = sys.executable
# Remove environment variables that can only harm if we have to switch
# major Python versions, these cannot help Python2 to execute scons, this
# is a bit of noise, but helpful.
if python_version >= 300:
if "PYTHONPATH" in os.environ:
old_pythonpath = os.environ["PYTHONPATH"]
del os.environ["PYTHONPATH"]
else:
old_pythonpath = None
if "PYTHONHOME" in os.environ:
old_pythonhome = os.environ["PYTHONHOME"]
del os.environ["PYTHONHOME"]
else:
old_pythonhome = None
yield
if python_version >= 300:
if old_pythonpath is not None:
os.environ["PYTHONPATH"] = old_pythonpath
if old_pythonhome is not None:
os.environ["PYTHONHOME"] = old_pythonhome
if Utils.getOS() == "Windows":
del os.environ["NUITKA_PYTHON_DLL_PATH"]
del os.environ["NUITKA_PYTHON_EXE_PATH"]
def _detectBinaryDLLs(
is_main_executable,
source_dir,
original_filename,
binary_filename,
package_name,
use_cache,
update_cache,
):
"""Detect the DLLs used by a binary.
Using "ldd" (Linux), "depends.exe" (Windows), or
"otool" (macOS) the list of used DLLs is retrieved.
"""
if (Utils.getOS() in ("Linux", "NetBSD", "FreeBSD", "OpenBSD")
or Utils.isPosixWindows()):
return _detectBinaryPathDLLsPosix(
dll_filename=original_filename,
package_name=package_name,
original_dir=os.path.dirname(original_filename),
)
elif Utils.isWin32Windows():
with TimerReport(
message="Running 'depends.exe' for %s took %%.2f seconds" %
binary_filename,
decider=Options.isShowProgress,
):
return detectBinaryPathDLLsWindowsDependencyWalker(
is_main_executable=is_main_executable,
source_dir=source_dir,
original_dir=os.path.dirname(original_filename),
binary_filename=binary_filename,
package_name=package_name,
use_cache=use_cache,
update_cache=update_cache,
)
elif Utils.isMacOS():
return _detectBinaryPathDLLsMacOS(
original_dir=os.path.dirname(original_filename),
binary_filename=original_filename,
package_name=package_name,
keep_unresolved=False,
recursive=True,
)
else:
# Support your platform above.
assert False, Utils.getOS()
def getPython2ExePath():
""" Find a way to call any Python2. Scons needs it."""
if python_version < 300:
return sys.executable
elif Utils.getOS() == "Windows":
python_exe = _getPython2ExePathWindows()
if python_exe is not None:
return python_exe
else:
sys.exit("""\
Error, while Nuitka is fully Python3 compatible, it needs to find a
Python2 executable under C:\\Python26 or C:\\Python27 to execute
scons which is not yet Python3 compatible.""")
candidate = Execution.getExecutablePath("python2.7")
if candidate is None:
candidate = Execution.getExecutablePath("python2.6")
if candidate is None:
candidate = Execution.getExecutablePath("python2")
# Our weakest bet is that there is no "python3" named "python", but we
# take it, as on some systems it's true.
if candidate is None:
candidate = "python"
return candidate
def setupSconsEnvironment():
# For the scons file to find the static C++ files and include path. The
# scons file is unable to use __file__ for the task.
os.environ["NUITKA_SCONS"] = getSconsDataPath()
if Utils.getOS() == "Windows":
# On Windows this Scons variable must be set by us.
os.environ["SCONS_LIB_DIR"] = Utils.joinpath(getSconsInlinePath(),
"lib", "scons-2.3.2")
# Remove environment variables that can only harm if we have to switch
# major Python versions, these cannot help Python2 to execute scons, this
# is a bit of noise, but helpful.
if python_version >= 300:
if "PYTHONPATH" in os.environ:
old_pythonpath = os.environ["PYTHONPATH"]
del os.environ["PYTHONPATH"]
else:
old_pythonpath = None
if "PYTHONHOME" in os.environ:
old_pythonhome = os.environ["PYTHONHOME"]
del os.environ["PYTHONHOME"]
else:
old_pythonhome = None
yield
if python_version >= 300:
if old_pythonpath is not None:
os.environ["PYTHONPATH"] = old_pythonpath
if old_pythonhome is not None:
os.environ["PYTHONHOME"] = old_pythonhome
def getPython2ExePath():
""" Find a way to call any Python2. Scons needs it."""
if python_version < 300:
return sys.executable
elif Utils.getOS() == "Windows":
python_exe = _getPython2ExePathWindows()
if python_exe is not None:
return python_exe
else:
sys.exit("""\
Error, while Nuitka is fully Python3 compatible, it needs to find a
Python2 executable under C:\\Python26 or C:\\Python27 to execute
scons which is not yet Python3 compatible.""")
candidate = Execution.getExecutablePath("python2.7")
if candidate is None:
candidate = Execution.getExecutablePath("python2.6")
if candidate is None:
candidate = Execution.getExecutablePath("python2")
# Our weakest bet is that there is no "python3" named "python", but we
# take it, as on some systems it's true.
if candidate is None:
candidate = "python"
return candidate
def cleanSourceDirectory(source_dir):
if Utils.isDir(source_dir):
for path, _filename in Utils.listDir(source_dir):
if Utils.getExtension(path) in (".cpp", ".hpp", ".c", ".o", ".os",
".obj", ".bin", ".res", ".rc",
".manifest"):
Utils.deleteFile(path, True)
else:
Utils.makePath(source_dir)
static_source_dir = Utils.joinpath(
source_dir,
"static"
)
if Utils.isDir(static_source_dir):
for path, _filename in Utils.listDir(static_source_dir):
if Utils.getExtension(path) in (".o", ".os", ".obj"):
Utils.deleteFile(path, True)
win32_source_dir = Utils.joinpath(
static_source_dir,
"win32_ucontext_src"
)
if Utils.getOS() == "Windows":
Utils.deleteFile(
Utils.joinpath(win32_source_dir, "fibers_win32.obj"),
False
)
def detectEarlyImports():
if Options.freezeAllStdlib():
stdlib_modules = set()
# Scan the standard library paths (multiple in case of virtualenv.
for stdlib_dir in getStandardLibraryPaths():
for module_name in scanStandardLibraryPath(stdlib_dir):
stdlib_modules.add(module_name)
import_code = "imports = " + repr(sorted(stdlib_modules)) + '\n'\
"for imp in imports:\n" \
" try:\n" \
" __import__(imp)\n" \
" except ImportError:\n" \
" pass\n"
else:
# TODO: Should recursively include all of encodings module.
import_code = "import encodings.utf_8;import encodings.ascii;import encodings.idna;"
if Utils.getOS() == "Windows":
import_code += "import encodings.mbcs;import encodings.cp437;"
# String method hex depends on it.
if Utils.python_version < 300:
import_code += "import encodings.hex_codec;"
import_code += "import locale;"
result = _detectImports(import_code, False)
debug("Finished detecting early imports.")
return result
def detectEarlyImports():
if Options.freezeAllStdlib():
stdlib_modules = set()
# Scan the standard library paths (multiple in case of virtualenv.
for stdlib_dir in getStandardLibraryPaths():
for module_name in scanStandardLibraryPath(stdlib_dir):
stdlib_modules.add(module_name)
import_code = "imports = " + repr(sorted(stdlib_modules)) + '\n'\
"for imp in imports:\n" \
" try:\n" \
" __import__(imp)\n" \
" except ImportError:\n" \
" pass\n"
else:
# TODO: Should recursively include all of encodings module.
import_code = "import encodings.utf_8;import encodings.ascii;import encodings.idna;"
if Utils.getOS() == "Windows":
import_code += "import encodings.mbcs;import encodings.cp437;"
# String method hex depends on it.
if Utils.python_version < 300:
import_code += "import encodings.hex_codec;"
import_code += "import locale;"
result = _detectImports(import_code, False)
debug("Finished detecting early imports.")
return result
def setupSconsEnvironment():
# For the scons file to find the static C++ files and include path. The
# scons file is unable to use __file__ for the task.
os.environ["NUITKA_SCONS"] = getSconsDataPath()
if Utils.getOS() == "Windows":
# On Windows this Scons variable must be set by us.
os.environ["SCONS_LIB_DIR"] = Utils.joinpath(
getSconsInlinePath(),
"lib",
"scons-2.3.2"
)
# On Windows, we use the Python.DLL path for some things. We pass it
# via environment variable
os.environ["NUITKA_PYTHON_DLL_PATH"] = getTargetPythonDLLPath()
os.environ["NUITKA_PYTHON_EXE_PATH"] = sys.executable
# Remove environment variables that can only harm if we have to switch
# major Python versions, these cannot help Python2 to execute scons, this
# is a bit of noise, but helpful.
if python_version >= 300:
if "PYTHONPATH" in os.environ:
old_pythonpath = os.environ["PYTHONPATH"]
del os.environ["PYTHONPATH"]
else:
old_pythonpath = None
if "PYTHONHOME" in os.environ:
old_pythonhome = os.environ["PYTHONHOME"]
del os.environ["PYTHONHOME"]
else:
old_pythonhome = None
yield
if python_version >= 300:
if old_pythonpath is not None:
os.environ["PYTHONPATH"] = old_pythonpath
if old_pythonhome is not None:
os.environ["PYTHONHOME"] = old_pythonhome
if Utils.getOS() == "Windows":
del os.environ["NUITKA_PYTHON_DLL_PATH"]
del os.environ["NUITKA_PYTHON_EXE_PATH"]
def detectEarlyImports():
encoding_names = [
filename[:-3] for _path, filename in Utils.listDir(
Utils.dirname(sys.modules["encodings"].__file__))
if filename.endswith(".py") if "__init__" not in filename
]
if Utils.getOS() != "Windows":
encoding_names.remove("mbcs")
if "cp65001" in encoding_names:
encoding_names.remove("cp65001")
import_code = ';'.join("import encodings.%s" % encoding_name
for encoding_name in encoding_names)
import_code += ";import locale;"
# For Python3 we patch inspect without knowing if it is used.
if python_version >= 300:
import_code += "import inspect;"
# We might need the pickle module when creating global constants.
if python_version >= 300:
import_code += "import pickle;"
else:
import_code += "import cPickle;"
result = _detectImports(command=import_code,
user_provided=False,
technical=True)
if Options.shallFreezeAllStdlib():
stdlib_modules = set()
# Scan the standard library paths (multiple in case of virtualenv.
for stdlib_dir in getStandardLibraryPaths():
for module_name in scanStandardLibraryPath(stdlib_dir):
stdlib_modules.add(module_name)
import_code = "imports = " + repr(sorted(stdlib_modules)) + '\n'\
"for imp in imports:\n" \
" try:\n" \
" __import__(imp)\n" \
" except (ImportError, SyntaxError):\n" \
" pass\n"
early_names = [module.getFullName() for module in result]
result += [
module for module in _detectImports(
command=import_code, user_provided=False, technical=False)
if module.getFullName() not in early_names
]
debug("Finished detecting early imports.")
return result
def getSconsBinaryCall():
""" Return a way to execute Scons.
Using potentially in-line copy if no system Scons is available
or if we are on Windows.
"""
if Utils.getOS() != "Windows" and Utils.isFile("/usr/bin/scons"):
return ["/usr/bin/scons"]
else:
return [getPython2ExePath(), Utils.joinpath(getSconsInlinePath(), "bin", "scons.py")]
def shallUseStaticLibPython():
"""*bool* = derived from `sys.prefix` and `os.name`
Notes:
Currently only AnaConda on non-Windows can do this.
"""
# For AnaConda default to trying static lib python library, which
# normally is just not available or if it is even unusable.
return (os.path.exists(os.path.join(sys.prefix, "conda-meta"))
and not Utils.isWin32Windows() and not Utils.getOS() == "Darwin")
def getResultFullpath(main_module):
result = getResultBasepath(main_module)
if Options.shallMakeModule():
if Utils.getOS() == "Windows":
result += ".pyd"
else:
result += ".so"
else:
result += ".exe"
return result
def detectEarlyImports():
# TODO: Should recursively include all of encodings module.
import_code = "import encodings.utf_8;import encodings.ascii;import encodings.idna;"
if Utils.getOS() == "Windows":
import_code += "import encodings.mbcs;import encodings.cp437;"
# String method hex depends on it.
if python_version < 300:
import_code += "import encodings.hex_codec;"
import_code += "import locale;"
# For Python3 we patch inspect without knowing if it is used.
if python_version >= 300:
import_code += "import inspect;"
# We might need the pickle module when creating global constants.
if python_version >= 300:
import_code += "import pickle;"
else:
import_code += "import cPickle;"
result = _detectImports(command=import_code,
user_provided=False,
technical=True)
if Options.shallFreezeAllStdlib():
stdlib_modules = set()
# Scan the standard library paths (multiple in case of virtualenv.
for stdlib_dir in getStandardLibraryPaths():
for module_name in scanStandardLibraryPath(stdlib_dir):
stdlib_modules.add(module_name)
import_code = "imports = " + repr(sorted(stdlib_modules)) + '\n'\
"for imp in imports:\n" \
" try:\n" \
" __import__(imp)\n" \
" except (ImportError, SyntaxError):\n" \
" pass\n"
early_names = [module.getFullName() for module in result]
result += [
module for module in _detectImports(
command=import_code, user_provided=False, technical=False)
if module.getFullName() not in early_names
]
debug("Finished detecting early imports.")
return result
def getSconsBinaryCall():
""" Return a way to execute Scons.
Using potentially in-line copy if no system Scons is available
or if we are on Windows.
"""
if Utils.getOS() != "Windows" and Utils.isFile("/usr/bin/scons"):
return ["/usr/bin/scons"]
else:
return [
getPython2ExePath(),
Utils.joinpath(getSconsInlinePath(), "bin", "scons.py")
]
def executeModule(tree, clean_path):
python_command = "__import__('%s')" % tree.getName()
if Utils.getOS() == "Windows":
python_command = '"%s"' % python_command
args = (
sys.executable,
"python",
"-c",
python_command,
)
callExec(clean_path=clean_path, add_path=True, args=args)
def getSconsBinaryCall():
""" Return a way to execute Scons.
Using potentially in-line copy if no system Scons is available
or if we are on Windows.
"""
if Utils.getOS() != "Windows":
scons_path = Execution.getExecutablePath("scons")
if scons_path is not None:
return [scons_path]
return [
getPython2ExePath(),
Utils.joinpath(getSconsInlinePath(), "bin", "scons.py")
]
def _getSconsBinaryCall():
""" Return a way to execute Scons.
Using potentially in-line copy if no system Scons is available
or if we are on Windows, there it is mandatory.
"""
if Utils.getOS() != "Windows":
scons_path = Execution.getExecutablePath("scons")
if scons_path is not None:
return [scons_path]
return [
_getPythonForSconsExePath(),
os.path.join(_getSconsInlinePath(), "bin", "scons.py")
]
def _expandProjectArg(arg, filename_arg, for_eval):
def wrap(value):
if for_eval:
return repr(value)
else:
return value
values = {
"OS": wrap(Utils.getOS()),
"Arch": wrap(Utils.getArchitecture()),
"Version": getNuitkaVersion(),
"MAIN_DIRECTORY": wrap(os.path.dirname(filename_arg) or "."),
}
arg = arg.format(**values)
return arg
def getSconsBinaryCall():
""" Return a way to execute Scons.
Using potentially in-line copy if no system Scons is available
or if we are on Windows.
"""
if Utils.getOS() != "Windows":
scons_path = Execution.getExecutablePath("scons")
if scons_path is not None:
return [scons_path]
return [
getPython2ExePath(),
Utils.joinpath(getSconsInlinePath(), "bin", "scons.py")
]
def getResultFullpath(main_module):
""" Get the final output binary result full path.
"""
result = getResultBasepath(main_module)
if Options.shallMakeModule():
result += Utils.getSharedLibrarySuffix()
else:
if Options.getOutputFilename() is not None:
result = Options.getOutputFilename()
elif Utils.getOS() == "Windows":
result += ".exe"
elif not Options.isStandaloneMode():
result += ".bin"
return result
def getResultFullpath(main_module):
""" Get the final output binary result full path.
"""
result = getResultBasepath(main_module)
if Options.shallMakeModule():
result += Utils.getSharedLibrarySuffix()
else:
if Options.getOutputFilename() is not None:
result = Options.getOutputFilename()
elif Utils.getOS() == "Windows":
result += ".exe"
elif not Options.isStandaloneMode():
result += ".bin"
return result
def executeModule(tree, clean_path):
python_command = "__import__('%s')" % tree.getName()
if Utils.getOS() == "Windows":
python_command = '"%s"' % python_command
args = (
sys.executable,
"python",
"-c",
python_command,
)
callExec(
clean_path = clean_path,
add_path = True,
args = args
)
def _getSconsBinaryCall():
""" Return a way to execute Scons.
Using potentially in-line copy if no system Scons is available
or if we are on Windows, there it is mandatory.
"""
if Utils.getOS() != "Windows":
scons_path = Execution.getExecutablePath("scons")
if scons_path is not None:
return [scons_path]
return [
_getPythonForSconsExePath(),
"-W",
"ignore", # Disable Python warnings in case of debug Python.
os.path.join(_getSconsInlinePath(), "bin", "scons.py"),
]
def _getPython2ExePath():
""" Find a way to call any Python2.
Scons needs it as it doesn't support Python3.
"""
python_exe = Options.getPython2PathForScons()
if python_exe is not None:
return python_exe
if python_version < 300:
return sys.executable
elif Utils.getOS() == "Windows":
python_exe = _getPython2ExePathWindows()
if python_exe is not None:
return python_exe
else:
sys.exit("""\
Error, while Nuitka is fully Python3 compatible, it needs to find a
Python2 executable under C:\\Python26 or C:\\Python27 to execute
Scons utility which is used to build the C files to binary, and which
is not yet Python3 compatible.
You may provide it using option "--python2-for-scons=path_to_python.exe"
in case it is not visible in registry, e.g. uninstalled AnaConda Python.
""")
candidate = Execution.getExecutablePath("python2.7")
if candidate is None:
candidate = Execution.getExecutablePath("python2.6")
if candidate is None:
candidate = Execution.getExecutablePath("python2")
# Our weakest bet is that there is no "python3" named "python", but we
# take it, as on some systems it's true.
if candidate is None:
candidate = "python"
return candidate
def getPython2ExePath():
""" Find a way to call Python2. Scons needs it."""
if python_version < 300:
return sys.executable
elif Utils.getOS() == "Windows":
python_exe = _getPython2ExePathWindows()
if python_exe is not None:
return python_exe
else:
sys.exit("""\
Error, need to find Python2 executable under C:\\Python26 or \
C:\\Python27 to execute scons which is not Python3 compatible.""")
elif Utils.isFile("/usr/bin/python2.7"):
return "/usr/bin/python2.7"
elif Utils.isFile("/usr/bin/python2.6"):
return "/usr/bin/python2.6"
elif Utils.isFile("/usr/bin/python2"):
return "/usr/bin/python2"
else:
return "python"
def getPython2ExePath():
""" Find a way to call Python2. Scons needs it."""
if Utils.python_version < 300:
return sys.executable
elif Utils.getOS() == "Windows":
python_exe = _getPython2ExePathWindows()
if python_exe is not None:
return python_exe
else:
sys.exit("""\
Error, need to find Python2 executable under C:\\Python26 or \
C:\\Python27 to execute scons which is not Python3 compatible.""")
elif Utils.isFile("/usr/bin/python2.7"):
return "/usr/bin/python2.7"
elif Utils.isFile("/usr/bin/python2.6"):
return "/usr/bin/python2.6"
elif Utils.isFile("/usr/bin/python2"):
return "/usr/bin/python2"
else:
return "python"
def _getPythonForSconsExePath():
""" Find a way to call any Python2.
Scons needs it as it doesn't support Python3.
"""
python_exe = Options.getPythonPathForScons()
if python_exe is not None:
return python_exe
if python_version < 300 or python_version >= 350:
return sys.executable
elif Utils.getOS() == "Windows":
python_exe = _getPythonSconsExePathWindows()
if python_exe is not None:
return python_exe
else:
sys.exit(
"""\
Error, while Nuitka works with Python 3.2 to 3.4, scons does not, and Nuitka
needs to find a Python executable 2.6/2.7 or 3.5 or higher. Simply under the
C:\\PythonXY, e.g. C:\\Python27 to execute the scons utility which is used
to build the C files to binary.
You may provide it using option "--python-for-scons=path_to_python.exe"
in case it is not visible in registry, e.g. due to using uninstalled
AnaConda Python.
"""
)
for version_candidate in ("2.7", "2.6", "3.5", "3.6", "3.7"):
candidate = Execution.getExecutablePath("python" + version_candidate)
if candidate is not None:
return candidate
# Lets be optimistic, this is most often going to be new enough or a
# Python2 variant.
return "python"
def _getPythonForSconsExePath():
""" Find a way to call any Python2.
Scons needs it as it doesn't support Python3.
"""
python_exe = Options.getPythonPathForScons()
if python_exe is not None:
return python_exe
if python_version < 300 or python_version >= 350:
return sys.executable
elif Utils.getOS() == "Windows":
python_exe = _getPythonSconsExePathWindows()
if python_exe is not None:
return python_exe
else:
sys.exit(
"""\
Error, while Nuitka works with Python 3.3 and 3.4, scons does not, and Nuitka
needs to find a Python executable 2.6/2.7 or 3.5 or higher. Simply under the
C:\\PythonXY, e.g. C:\\Python27 to execute the scons utility which is used
to build the C files to binary.
You may provide it using option "--python-for-scons=path_to_python.exe"
in case it is not visible in registry, e.g. due to using uninstalled
AnaConda Python.
"""
)
for version_candidate in ("2.7", "2.6", "3.5", "3.6", "3.7", "3.8"):
candidate = Execution.getExecutablePath("python" + version_candidate)
if candidate is not None:
return candidate
# Lets be optimistic, this is most often going to be new enough or a
# Python2 variant.
return "python"
def detectEarlyImports():
# TODO: Should recursively include all of encodings module.
import_code = "import encodings.utf_8;import encodings.ascii;import encodings.idna;"
if Utils.getOS() == "Windows":
import_code += "import encodings.mbcs;import encodings.cp437;"
# String method hex depends on it.
if python_version < 300:
import_code += "import encodings.hex_codec;"
import_code += "import locale;"
# For Python3 we patch inspect without knowing if it is used.
if python_version >= 300:
import_code += "import inspect;"
# We might need the pickle module when creating global constants.
if python_version >= 300:
import_code += "import pickle;"
else:
import_code += "import cPickle;"
result = _detectImports(
command = import_code,
user_provided = False,
technical = True
)
if Options.shallFreezeAllStdlib():
stdlib_modules = set()
# Scan the standard library paths (multiple in case of virtualenv.
for stdlib_dir in getStandardLibraryPaths():
for module_name in scanStandardLibraryPath(stdlib_dir):
stdlib_modules.add(module_name)
import_code = "imports = " + repr(sorted(stdlib_modules)) + '\n'\
"for imp in imports:\n" \
" try:\n" \
" __import__(imp)\n" \
" except (ImportError, SyntaxError):\n" \
" pass\n"
early_names = [
module.getFullName()
for module in result
]
result += [
module
for module in _detectImports(
command = import_code,
user_provided = False,
technical = False
)
if module.getFullName() not in early_names
]
debug("Finished detecting early imports.")
return result
# other defaults and work a bit different with parameters.
is_nuitka_run = os.path.basename(sys.argv[0]).lower().endswith("-run")
if not is_nuitka_run:
usage = "usage: %prog [--module] [--run] [options] main_module.py"
else:
usage = "usage: %prog [options] main_module.py"
parser = OptionParser(
usage=usage,
version="\n".join(
(
getNuitkaVersion(),
"Python: " + sys.version.split("\n")[0],
"Executable: " + sys.executable,
"OS: " + Utils.getOS(),
"Arch: " + Utils.getArchitecture(),
)
),
)
parser.add_option(
"--module",
action="store_false",
dest="executable",
default=True,
help="""\
Create an extension module executable instead of a program. Defaults to off.""",
)
parser.add_option(
# Indicator if we were called as "nuitka-run" in which case we assume some
# other defaults and work a bit different with parameters.
is_nuitka_run = os.path.basename(sys.argv[0]).lower().endswith("-run")
if not is_nuitka_run:
usage = "usage: %prog [--module] [--run] [options] main_module.py"
else:
usage = "usage: %prog [options] main_module.py"
parser = OptionParser(
usage=usage,
version="\n".join((
getNuitkaVersion(),
"Python: " + sys.version.split("\n")[0],
"Executable: " + sys.executable,
"OS: " + Utils.getOS(),
"Arch: " + Utils.getArchitecture(),
)),
)
parser.add_option(
"--module",
action="store_false",
dest="executable",
default=True,
help="""\
Create an extension module executable instead of a program. Defaults to off.""",
)
parser.add_option(
"--standalone",
def scanStandardLibraryPath(stdlib_dir):
# There is a lot of filtering here, done in branches, so there # is many of
# them, but that's acceptable, pylint: disable=too-many-branches,too-many-statements
for root, dirs, filenames in os.walk(stdlib_dir):
import_path = root[len(stdlib_dir):].strip("/\\")
import_path = import_path.replace("\\", ".").replace("/", ".")
if import_path == "":
if "site-packages" in dirs:
dirs.remove("site-packages")
if "dist-packages" in dirs:
dirs.remove("dist-packages")
if "test" in dirs:
dirs.remove("test")
if "idlelib" in dirs:
dirs.remove("idlelib")
if "turtledemo" in dirs:
dirs.remove("turtledemo")
if "ensurepip" in filenames:
filenames.remove("ensurepip")
if "ensurepip" in dirs:
dirs.remove("ensurepip")
# Ignore "lib-dynload" and "lib-tk" and alike.
dirs[:] = [
dirname for dirname in dirs if not dirname.startswith("lib-")
if dirname != "Tools" if not dirname.startswith("plat-")
]
if import_path in (
"tkinter",
"importlib",
"ctypes",
"unittest",
"sqlite3",
"distutils",
"email",
"bsddb",
):
if "test" in dirs:
dirs.remove("test")
if import_path == "distutils.command":
# Misbehaving and crashing while importing the world.
if "bdist_conda.py" in filenames:
filenames.remove("bdist_conda.py")
if import_path in ("lib2to3", "json", "distutils"):
if "tests" in dirs:
dirs.remove("tests")
if import_path == "asyncio":
if "test_utils.py" in filenames:
filenames.remove("test_utils.py")
if python_version >= 0x340 and Utils.isWin32Windows():
if import_path == "multiprocessing":
filenames.remove("popen_fork.py")
filenames.remove("popen_forkserver.py")
filenames.remove("popen_spawn_posix.py")
if python_version >= 0x300 and Utils.isPosixWindows():
if import_path == "curses":
filenames.remove("has_key.py")
if Utils.getOS() == "NetBSD":
if import_path == "xml.sax":
filenames.remove("expatreader.py")
for filename in filenames:
if filename.endswith(
".py") and filename not in _excluded_stdlib_modules:
module_name = filename[:-3]
if import_path == "":
yield module_name
else:
yield import_path + "." + module_name
if python_version >= 0x300:
if "__pycache__" in dirs:
dirs.remove("__pycache__")
for dirname in dirs:
if import_path == "":
yield dirname
else:
yield import_path + "." + dirname
def makeSourceDirectory(main_module):
""" Get the full list of modules imported, create code for all of them.
"""
# We deal with a lot of details here, but rather one by one, and split makes
# no sense, pylint: disable=R0912,R0914
assert main_module.isCompiledPythonModule()
# The global context used to generate code.
global_context = CodeGeneration.makeGlobalContext()
assert main_module in ModuleRegistry.getDoneModules()
# We might have chosen to include it as bytecode, and only compiled it for
# fun, and to find its imports. In this case, now we just can drop it. Or
# a module may shadow a frozen module, but be a different one, then we can
# drop the frozen one.
# TODO: This really should be done when the compiled module comes into
# existence.
for module in ModuleRegistry.getDoneUserModules():
if module.isCompiledPythonModule():
uncompiled_module = ModuleRegistry.getUncompiledModule(
module_name = module.getFullName(),
module_filename = module.getCompileTimeFilename()
)
if uncompiled_module is not None:
# We now need to decide which one to keep, compiled or uncompiled
# module. Some uncompiled modules may have been asked by the user
# or technically required. By default, frozen code if it exists
# is preferred, as it will be from standalone mode adding it.
if uncompiled_module.isUserProvided():
ModuleRegistry.removeDoneModule(module)
else:
ModuleRegistry.removeUncompiledModule(uncompiled_module)
# Lets check if the recurse-to modules are actually present, and warn the
# user if one of those was not found.
for any_case_module in Options.getShallFollowModules():
for module in ModuleRegistry.getDoneUserModules():
if module.getFullName() == any_case_module:
break
else:
warning(
"Didn't recurse to '%s', apparently not used." % \
any_case_module
)
# Prepare code generation, i.e. execute finalization for it.
for module in ModuleRegistry.getDoneModules():
if module.isCompiledPythonModule():
Finalization.prepareCodeGeneration(module)
# Pick filenames.
source_dir = getSourceDirectoryPath(main_module)
module_filenames = pickSourceFilenames(
source_dir = source_dir,
modules = ModuleRegistry.getDoneModules()
)
# First pass, generate code and use constants doing so, but prepare the
# final code generation only, because constants code will be added at the
# end only.
prepared_modules = {}
for module in ModuleRegistry.getDoneModules():
if module.isCompiledPythonModule():
cpp_filename = module_filenames[module]
prepared_modules[cpp_filename] = CodeGeneration.prepareModuleCode(
global_context = global_context,
module = module,
module_name = module.getFullName(),
)
# Main code constants need to be allocated already too.
if module is main_module and not Options.shallMakeModule():
prepared_modules[cpp_filename][1].getConstantCode(0)
# Second pass, generate the actual module code into the files.
for module in ModuleRegistry.getDoneModules():
if module.isCompiledPythonModule():
cpp_filename = module_filenames[module]
template_values, module_context = prepared_modules[cpp_filename]
source_code = CodeGeneration.generateModuleCode(
module_context = module_context,
template_values = template_values
)
# The main of an executable module gets a bit different code.
if module is main_module and not Options.shallMakeModule():
source_code = MainCodes.generateMainCode(
main_module = main_module,
context = module_context,
codes = source_code
)
writeSourceCode(
filename = cpp_filename,
source_code = source_code
)
if Options.isShowInclusion():
info("Included compiled module '%s'." % module.getFullName())
elif module.isPythonShlibModule():
target_filename = Utils.joinpath(
getStandaloneDirectoryPath(main_module),
*module.getFullName().split('.')
)
if Utils.getOS() == "Windows":
target_filename += ".pyd"
else:
target_filename += ".so"
target_dir = Utils.dirname(target_filename)
if not Utils.isDir(target_dir):
Utils.makePath(target_dir)
shutil.copy(
module.getFilename(),
target_filename
)
standalone_entry_points.append(
(target_filename, module.getPackage())
)
else:
assert False, module
writeSourceCode(
filename = Utils.joinpath(source_dir, "__constants.cpp"),
source_code = ConstantCodes.getConstantsDefinitionCode(
context = global_context
)
)
helper_decl_code, helper_impl_code = CodeGeneration.generateHelpersCode(
ModuleRegistry.getDoneUserModules()
)
writeSourceCode(
filename = Utils.joinpath(source_dir, "__helpers.hpp"),
source_code = helper_decl_code
)
writeSourceCode(
filename = Utils.joinpath(source_dir, "__helpers.cpp"),
source_code = helper_impl_code
)
def makeSourceDirectory(main_module):
# We deal with a lot of details here, but rather one by one, and split makes
# no sense, pylint: disable=R0914,R0912
assert main_module.isPythonModule()
# The global context used to generate code.
global_context = CodeGeneration.makeGlobalContext()
# Get the full list of modules imported, create code for all of them.
modules = ModuleRegistry.getDoneModules()
assert main_module in modules
# Sometimes we need to talk about all modules except main module.
other_modules = ModuleRegistry.getDoneUserModules()
# Lets check if the recurse-to modules are actually present, and warn the
# user if one was not found.
for any_case_module in Options.getShallFollowModules():
for module in other_modules:
if module.getFullName() == any_case_module:
break
else:
warning(
"Didn't recurse to '%s', apparently not used." % \
any_case_module
)
# Prepare code generation, i.e. execute finalization for it.
for module in sorted(modules, key = lambda x : x.getFullName()):
if module.isPythonModule():
Finalization.prepareCodeGeneration(module)
# Pick filenames.
source_dir = getSourceDirectoryPath(main_module)
module_filenames = pickSourceFilenames(
source_dir = source_dir,
modules = modules
)
# First pass, generate code and use constants doing so, but prepare the
# final code generation only, because constants code will be added at the
# end only.
prepared_modules = {}
for module in sorted(modules, key = lambda x : x.getFullName()):
if module.isPythonModule():
cpp_filename = module_filenames[module]
prepared_modules[cpp_filename] = CodeGeneration.prepareModuleCode(
global_context = global_context,
module = module,
module_name = module.getFullName(),
other_modules = other_modules
if module is main_module else
()
)
# Main code constants need to be allocated already too.
if module is main_module and not Options.shallMakeModule():
prepared_modules[cpp_filename][1].getConstantCode(0)
for module in sorted(modules, key = lambda x : x.getFullName()):
if module.isPythonModule():
cpp_filename = module_filenames[module]
template_values, module_context = prepared_modules[cpp_filename]
source_code = CodeGeneration.generateModuleCode(
module_context = module_context,
template_values = template_values
)
# The main of an executable module gets a bit different code.
if module is main_module and not Options.shallMakeModule():
source_code = CodeGeneration.generateMainCode(
main_module = main_module,
context = module_context,
codes = source_code
)
writeSourceCode(
filename = cpp_filename,
source_code = source_code
)
if Options.isShowInclusion():
info("Included compiled module '%s'." % module.getFullName())
elif module.isPythonShlibModule():
target_filename = Utils.joinpath(
getStandaloneDirectoryPath(main_module),
*module.getFullName().split('.')
)
if Utils.getOS() == "Windows":
target_filename += ".pyd"
else:
target_filename += ".so"
target_dir = Utils.dirname(target_filename)
if not Utils.isDir(target_dir):
Utils.makePath(target_dir)
shutil.copy(
module.getFilename(),
target_filename
)
standalone_entry_points.append(
(target_filename, module.getPackage())
)
else:
assert False, module
writeSourceCode(
filename = Utils.joinpath(source_dir, "__constants.cpp"),
source_code = ConstantCodes.getConstantsDefinitionCode(
context = global_context
)
)
helper_decl_code, helper_impl_code = CodeGeneration.generateHelpersCode()
writeSourceCode(
filename = Utils.joinpath(source_dir, "__helpers.hpp"),
source_code = helper_decl_code
)
writeSourceCode(
filename = Utils.joinpath(source_dir, "__helpers.cpp"),
source_code = helper_impl_code
)
def parseArgs():
# singleton with many cases, pylint: disable=global-statement,too-many-branches
global is_nuitka_run, options, positional_args, extra_args
is_nuitka_run, options, positional_args, extra_args = parseOptions()
if options.verbose:
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.getLogger().setLevel(logging.INFO)
# Standalone mode implies an executable, not importing "site" module, which is
# only for this machine, recursing to all modules, and even including the
# standard library.
if options.is_standalone:
if not options.executable:
sys.exit(
"""\
Error, conflicting options, cannot make standalone module, only executable."""
)
options.recurse_all = True
if Utils.getOS() == "NetBSD":
logging.warning(
"Standalone mode on NetBSD is not functional, due to $ORIGIN linkage not being supported."
)
for any_case_module in getShallFollowModules():
if any_case_module.startswith("."):
bad = True
else:
for char in "/\\:":
if char in any_case_module:
bad = True
break
else:
bad = False
if bad:
sys.exit(
"""\
Error, '--follow-import-to' takes only module names, not directory path '%s'."""
% any_case_module
)
for no_case_module in getShallFollowInNoCase():
if no_case_module.startswith("."):
bad = True
else:
for char in "/\\:":
if char in no_case_module:
bad = True
break
else:
bad = False
if bad:
sys.exit(
"""\
Error, '--nofollow-import-to' takes only module names, not directory path '%s'."""
% no_case_module
)
scons_python = getPythonPathForScons()
if scons_python is not None and not os.path.exists(scons_python):
sys.exit("Error, no such Python binary '%s'." % scons_python)
if options.output_filename is not None and (
isStandaloneMode() or shallMakeModule()
):
sys.exit(
"""\
Error, can only specify output filename for acceleration mode, not for module
mode where filenames are mandatory, and not for standalone where there is a
sane default used inside the dist folder."""
)
def runScons(main_module, quiet):
# Scons gets transported many details, that we express as variables, and
# have checks for them, leading to many branches and statements,
# pylint: disable=too-many-branches,too-many-statements
options = {
"name": os.path.basename(getTreeFilenameWithSuffix(main_module, "")),
"result_name": getResultBasepath(main_module),
"source_dir": getSourceDirectoryPath(main_module),
"debug_mode": _asBoolStr(Options.isDebug()),
"python_debug": _asBoolStr(Options.isPythonDebug()),
"unstripped_mode": _asBoolStr(Options.isUnstripped()),
"module_mode": _asBoolStr(Options.shallMakeModule()),
"full_compat": _asBoolStr(Options.isFullCompat()),
"experimental": ",".join(Options.getExperimentalIndications()),
"trace_mode": _asBoolStr(Options.shallTraceExecution()),
"python_version": python_version_str,
"target_arch": Utils.getArchitecture(),
"python_prefix": sys.prefix,
"nuitka_src": SconsInterface.getSconsDataPath(),
"nuitka_cache": getCacheDir(),
"module_count": "%d"
% (
1
+ len(ModuleRegistry.getDoneUserModules())
+ len(ModuleRegistry.getUncompiledNonTechnicalModules())
),
}
if not Options.shallMakeModule():
options["result_exe"] = getResultFullpath(main_module)
# Ask Scons to cache on Windows, except where the directory is thrown
# away. On non-Windows you can should use ccache instead.
if not Options.isRemoveBuildDir() and Utils.getOS() == "Windows":
options["cache_mode"] = "true"
if Options.isLto():
options["lto_mode"] = "true"
# For AnaConda default to trying static lib python library, which
# normally is just not available or if it is even unusable.
if "Anaconda" in sys.version:
options["static_libpython"] = "true"
if Options.shallDisableConsoleWindow():
options["win_disable_console"] = "true"
if Options.isStandaloneMode():
options["standalone_mode"] = "true"
if (
not Options.isStandaloneMode()
and not Options.shallMakeModule()
and isUninstalledPython()
):
options["uninstalled_python"] = "true"
if ModuleRegistry.getUncompiledTechnicalModules():
options["frozen_modules"] = str(
len(ModuleRegistry.getUncompiledTechnicalModules())
)
if Options.isShowScons():
options["show_scons"] = "true"
if Options.isMingw64():
options["mingw_mode"] = "true"
if Options.getMsvcVersion():
msvc_version = Options.getMsvcVersion()
msvc_version = msvc_version.replace("exp", "Exp")
if "." not in msvc_version:
msvc_version += ".0"
options["msvc_version"] = msvc_version
if Options.isClang():
options["clang_mode"] = "true"
if Options.getIconPath():
options["icon_path"] = Options.getIconPath()
if Options.isProfile():
options["profile_mode"] = "true"
if "no_warnings" in getPythonFlags():
options["no_python_warnings"] = "true"
if "no_asserts" in getPythonFlags():
options["python_sysflag_optimize"] = "true"
if python_version < 300 and sys.flags.py3k_warning:
options["python_sysflag_py3k_warning"] = "true"
if python_version < 300 and (sys.flags.division_warning or sys.flags.py3k_warning):
options["python_sysflag_division_warning"] = "true"
if sys.flags.bytes_warning:
options["python_sysflag_bytes_warning"] = "true"
if int(os.environ.get("NUITKA_SITE_FLAG", "no_site" in Options.getPythonFlags())):
options["python_sysflag_no_site"] = "true"
if "trace_imports" in Options.getPythonFlags():
options["python_sysflag_verbose"] = "true"
if python_version < 300 and sys.flags.unicode:
options["python_sysflag_unicode"] = "true"
if python_version >= 370 and sys.flags.utf8_mode:
options["python_sysflag_utf8"] = "true"
abiflags = getPythonABI()
if abiflags:
options["abiflags"] = abiflags
return SconsInterface.runScons(options, quiet), options
def runScons(options, quiet):
# For the scons file to find the static C++ files and include path. The
# scons file is unable to use __file__ for the task.
os.environ["NUITKA_SCONS"] = getSconsDataPath()
if Utils.getOS() == "Windows":
# On Windows this Scons variable must be set by us.
os.environ["SCONS_LIB_DIR"] = Utils.joinpath(
getSconsInlinePath(),
"lib",
"scons-2.3.2"
)
scons_command = getSconsBinaryCall()
if quiet:
scons_command.append("--quiet")
scons_command += [
# The scons file
"-f",
Utils.joinpath(getSconsDataPath(), "SingleExe.scons"),
# Parallel compilation.
"--jobs",
str(Options.getJobLimit()),
# Do not warn about deprecation from Scons
"--warn=no-deprecated",
# Don't load "site_scons" at all.
"--no-site-dir",
]
if Options.isShowScons():
scons_command.append("--debug=explain")
# Option values to provide to scons. Find these in the caller.
for key, value in options.items():
scons_command += [key + '=' + value]
if Options.isShowScons():
Tracing.printLine("Scons command:", ' '.join(scons_command))
# Remove environment variables that can only harm if we have to switch
# major Python versions, these cannot help Python2 to execute scons, this
# is a bit of noise, but helpful, pylint: disable=R0912
if Utils.python_version >= 300:
if "PYTHONPATH" in os.environ:
old_pythonpath = os.environ["PYTHONPATH"]
del os.environ["PYTHONPATH"]
else:
old_pythonpath = None
if "PYTHONHOME" in os.environ:
old_pythonhome = os.environ["PYTHONHOME"]
del os.environ["PYTHONHOME"]
else:
old_pythonhome = None
result = 0 == subprocess.call(scons_command, shell = False)
if Utils.python_version >= 300:
if old_pythonpath is not None:
os.environ["PYTHONPATH"] = old_pythonpath
if old_pythonhome is not None:
os.environ["PYTHONHOME"] = old_pythonhome
return result
if command:
result = _detectImports(command, True)
debug("Finished detecting late imports.")
return result
else:
return ""
# Some modules we want to blacklist.
ignore_modules = [
"__main__.py",
"__init__.py",
"antigravity.py",
]
if Utils.getOS() != "Windows":
ignore_modules.append("wintypes.py")
ignore_modules.append("cp65001.py")
def scanStandardLibraryPath(stdlib_dir):
# There is a lot of black-listing here, done in branches, so there
# is many of them, but that's acceptable, pylint: disable=R0912
for root, dirs, filenames in os.walk(stdlib_dir):
import_path = root[len(stdlib_dir):].strip("/\\")
import_path = import_path.replace('\\', '.').replace('/','.')
if import_path == "":
if "site-packages" in dirs:
dirs.remove("site-packages")
if "dist-packages" in dirs:
def isRelevant():
return Utils.getOS() == "Windows" and not Options.shallMakeModule()
def runScons(main_module, quiet):
# Scons gets transported many details, that we express as variables, and
# have checks for them, leading to many branches, pylint: disable=R0912
python_version_str = "%d.%d" % (sys.version_info[0], sys.version_info[1])
if hasattr(sys, "abiflags"):
if Options.isPythonDebug() or \
hasattr(sys, "getobjects"):
if sys.abiflags.startswith('d'):
python_version_str += sys.abiflags
else:
python_version_str += 'd' + sys.abiflags
else:
python_version_str += sys.abiflags
def asBoolStr(value):
return "true" if value else "false"
options = {
"name" : Utils.basename(
getTreeFilenameWithSuffix(main_module, "")
),
"result_name" : getResultBasepath(main_module),
"source_dir" : getSourceDirectoryPath(main_module),
"debug_mode" : asBoolStr(Options.isDebug()),
"python_debug" : asBoolStr(Options.isPythonDebug()),
"unstripped_mode" : asBoolStr(Options.isUnstripped()),
"module_mode" : asBoolStr(Options.shallMakeModule()),
"optimize_mode" : asBoolStr(Options.isOptimize()),
"full_compat" : asBoolStr(Options.isFullCompat()),
"experimental" : asBoolStr(Options.isExperimental()),
"trace_mode" : asBoolStr(Options.shallTraceExecution()),
"python_version" : python_version_str,
"target_arch" : Utils.getArchitecture(),
"python_prefix" : sys.prefix,
"nuitka_src" : SconsInterface.getSconsDataPath(),
"module_count" : "%d" % (
len(ModuleRegistry.getDoneUserModules()) + 1
)
}
# Ask Scons to cache on Windows, except where the directory is thrown
# away. On non-Windows you can should use ccache instead.
if not Options.isRemoveBuildDir() and Utils.getOS() == "Windows":
options["cache_mode"] = "true"
if Options.isLto():
options["lto_mode"] = "true"
if Options.shallDisableConsoleWindow():
options["win_disable_console"] = "true"
if Options.isStandaloneMode():
options["standalone_mode"] = "true"
if not Options.isStandaloneMode() and \
not Options.shallMakeModule() and \
isUninstalledPython():
options["uninstalled_python"] = "true"
if ModuleRegistry.getUncompiledModules():
options["frozen_modules"] = str(
len(ModuleRegistry.getUncompiledModules())
)
if Options.isShowScons():
options["show_scons"] = "true"
if Options.isMingw():
options["mingw_mode"] = "true"
if Options.getMsvcVersion():
msvc_version = Options.getMsvcVersion()
msvc_version = msvc_version.replace("exp", "Exp")
if '.' not in msvc_version:
msvc_version += ".0"
options["msvc_version"] = msvc_version
if Options.isClang():
options["clang_mode"] = "true"
if Options.getIconPath():
options["icon_path"] = Options.getIconPath()
if Options.isProfile():
options["profile_mode"] = "true"
return SconsInterface.runScons(options, quiet), options
def copyUsedDLLs(source_dir, dist_dir, standalone_entry_points):
# This is terribly complex, because we check the list of used DLLs
# trying to avoid duplicates, and detecting errors with them not
# being binary identical, so we can report them. And then of course
# we also need to handle OS specifics.
# pylint: disable=too-many-branches,too-many-locals,too-many-statements
used_dlls = detectUsedDLLs(
source_dir=source_dir,
standalone_entry_points=standalone_entry_points,
use_cache=not Options.shallNotUseDependsExeCachedResults()
and not Options.getWindowsDependencyTool() == "depends.exe",
update_cache=not Options.shallNotStoreDependsExeCachedResults()
and not Options.getWindowsDependencyTool() == "depends.exe",
)
removed_dlls = set()
warned_about = set()
# Fist make checks and remove some.
for dll_filename1, sources1 in tuple(iterItems(used_dlls)):
if dll_filename1 in removed_dlls:
continue
for dll_filename2, sources2 in tuple(iterItems(used_dlls)):
if dll_filename1 == dll_filename2:
continue
if dll_filename2 in removed_dlls:
continue
# Colliding basenames are an issue to us.
if os.path.basename(dll_filename1) != os.path.basename(
dll_filename2):
continue
# May already have been removed earlier
if dll_filename1 not in used_dlls:
continue
if dll_filename2 not in used_dlls:
continue
dll_name = os.path.basename(dll_filename1)
if Options.isShowInclusion():
inclusion_logger.info(
"""Colliding DLL names for %s, checking identity of \
'%s' <-> '%s'.""" % (dll_name, dll_filename1, dll_filename2))
# Check that if a DLL has the same name, if it's identical, then it's easy.
if haveSameFileContents(dll_filename1, dll_filename2):
del used_dlls[dll_filename2]
removed_dlls.add(dll_filename2)
continue
# For Win32 we can check out file versions.
if Utils.isWin32Windows():
dll_version1 = getWindowsDLLVersion(dll_filename1)
dll_version2 = getWindowsDLLVersion(dll_filename2)
if dll_version2 < dll_version1:
del used_dlls[dll_filename2]
removed_dlls.add(dll_filename2)
solved = True
elif dll_version1 < dll_version2:
del used_dlls[dll_filename1]
removed_dlls.add(dll_filename1)
solved = True
else:
solved = False
if solved:
if dll_name not in warned_about and dll_name not in ms_runtime_dlls:
warned_about.add(dll_name)
inclusion_logger.warning(
"Conflicting DLLs for '%s' in your installation, newest file version used, hoping for the best."
% dll_name)
continue
# So we have conflicting DLLs, in which case we do report the fact.
inclusion_logger.warning("""\
Ignoring non-identical DLLs for '%s'.
%s used by:
%s
different from
%s used by
%s""" % (
dll_name,
dll_filename1,
"\n ".join(sources1),
dll_filename2,
"\n ".join(sources2),
))
del used_dlls[dll_filename2]
removed_dlls.add(dll_filename2)
dll_map = []
for dll_filename, sources in iterItems(used_dlls):
dll_name = os.path.basename(dll_filename)
target_path = os.path.join(dist_dir, dll_name)
shutil.copyfile(dll_filename, target_path)
dll_map.append((dll_filename, dll_name))
if Options.isShowInclusion():
inclusion_logger.info(
"Included used shared library '%s' (used by %s)." %
(dll_filename, ", ".join(sources)))
if Utils.getOS() == "Darwin":
# For macOS, the binary and the DLLs needs to be changed to reflect
# the relative DLL location in the ".dist" folder.
for standalone_entry_point in standalone_entry_points:
fixupBinaryDLLPathsMacOS(
binary_filename=standalone_entry_point.dest_path,
dll_map=dll_map,
original_location=standalone_entry_point.source_path,
)
for original_path, dll_filename in dll_map:
fixupBinaryDLLPathsMacOS(
binary_filename=os.path.join(dist_dir, dll_filename),
dll_map=dll_map,
original_location=original_path,
)
# Remove code signature from CPython installed library
candidate = os.path.join(
dist_dir,
"Python",
)
if os.path.exists(candidate):
removeMacOSCodeSignature(candidate)
# Remove rpath settings.
if Utils.getOS() in ("Linux", "Darwin"):
# For Linux, the "rpath" of libraries may be an issue and must be
# removed.
if Utils.getOS() == "Darwin":
start = 0
else:
start = 1
for standalone_entry_point in standalone_entry_points[start:]:
removeSharedLibraryRPATH(standalone_entry_point.dest_path)
for _original_path, dll_filename in dll_map:
removeSharedLibraryRPATH(os.path.join(dist_dir, dll_filename))
if Utils.isWin32Windows():
if python_version < 0x300:
# For Win32, we might have to remove SXS paths
for standalone_entry_point in standalone_entry_points[1:]:
removeSxsFromDLL(standalone_entry_point.dest_path)
for _original_path, dll_filename in dll_map:
removeSxsFromDLL(os.path.join(dist_dir, dll_filename))
def main():
""" Main program flow of Nuitka
At this point, options will be parsed already, Nuitka will be executing
in the desired version of Python with desired flags, and we just get
to execute the task assigned.
We might be asked to only re-compile generated C++, dump only an XML
representation of the internal node tree after optimization, etc.
"""
# Main has to fullfil many options, leading to many branches and statements
# to deal with them. pylint: disable=R0912
positional_args = Options.getPositionalArgs()
assert len(positional_args) > 0
filename = Options.getPositionalArgs()[0]
# Inform the importing layer about the main script directory, so it can use
# it when attempting to follow imports.
Importing.setMainScriptDirectory(
main_dir = Utils.dirname(Utils.abspath(filename))
)
# Detect to be frozen modules if any, so we can consider to not recurse
# to them.
if Options.isStandaloneMode():
for module in detectEarlyImports():
ModuleRegistry.addUncompiledModule(module)
if module.getName() == "site":
origin_prefix_filename = Utils.joinpath(
Utils.dirname(module.getCompileTimeFilename()),
"orig-prefix.txt"
)
if Utils.isFile(origin_prefix_filename):
data_files.append(
(filename, "orig-prefix.txt")
)
# Turn that source code into a node tree structure.
try:
main_module = createNodeTree(
filename = filename
)
except (SyntaxError, IndentationError) as e:
# Syntax or indentation errors, output them to the user and abort.
sys.exit(
SyntaxErrors.formatOutput(e)
)
if Options.shallDumpBuiltTreeXML():
for module in ModuleRegistry.getDoneModules():
dumpTreeXML(module)
elif Options.shallDisplayBuiltTree():
displayTree(main_module)
else:
result, options = compileTree(
main_module = main_module
)
# Exit if compilation failed.
if not result:
sys.exit(1)
if Options.shallNotDoExecCppCall():
sys.exit(0)
# Remove the source directory (now build directory too) if asked to.
if Options.isRemoveBuildDir():
shutil.rmtree(
getSourceDirectoryPath(main_module)
)
if Options.isStandaloneMode():
binary_filename = options["result_name"] + ".exe"
standalone_entry_points.insert(
0,
(binary_filename, None)
)
dist_dir = getStandaloneDirectoryPath(main_module)
for module in ModuleRegistry.getDoneUserModules():
standalone_entry_points.extend(
Plugins.considerExtraDlls(dist_dir, module)
)
if Utils.getOS() == "NetBSD":
warning("Standalone mode on NetBSD is not functional, due to $ORIGIN linkage not being supported.")
copyUsedDLLs(
dist_dir = dist_dir,
standalone_entry_points = standalone_entry_points
)
for source_filename, target_filename in data_files:
shutil.copy2(
source_filename,
Utils.joinpath(
getStandaloneDirectoryPath(main_module),
target_filename
)
)
# Modules should not be executable, but Scons creates them like it, fix
# it up here.
if Utils.getOS() != "Windows" and Options.shallMakeModule():
subprocess.call(
(
"chmod",
"-x",
getResultFullpath(main_module)
)
)
# Execute the module immediately if option was given.
if Options.shallExecuteImmediately():
if Options.shallMakeModule():
executeModule(
tree = main_module,
clean_path = Options.shallClearPythonPathEnvironment()
)
else:
executeMain(
binary_filename = getResultFullpath(main_module),
clean_path = Options.shallClearPythonPathEnvironment()
)
Error, need only one positional argument unless "--run" is specified to
pass them to the compiled program execution.""")
if options.verbose:
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.getLogger().setLevel(logging.INFO)
# Standalone mode implies an executable, not importing "site" module, which is
# only for this machine, recursing to all modules, and even including the
# standard library.
if options.is_standalone:
options.executable = True
options.recurse_all = True
if Utils.getOS() == "NetBSD":
logging.warning("Standalone mode on NetBSD is not functional, due to $ORIGIN linkage not being supported.")
def shallTraceExecution():
return options.trace_execution
def shallExecuteImmediately():
return options.immediate_execution
def shallRunInDebugger():
return options.debugger
def shallDumpBuiltTreeXML():
return options.dump_xml
def shallDisplayBuiltTree():
def detectEarlyImports():
encoding_names = [
filename[:-3]
for _path, filename in
Utils.listDir(Utils.dirname(sys.modules["encodings"].__file__))
if filename.endswith(".py")
if "__init__" not in filename
]
if Utils.getOS() != "Windows":
encoding_names.remove("mbcs")
if "cp65001" in encoding_names:
encoding_names.remove("cp65001")
import_code = ";".join(
"import encodings.%s" % encoding_name
for encoding_name in
encoding_names
)
import_code += ";import locale;"
# For Python3 we patch inspect without knowing if it is used.
if python_version >= 300:
import_code += "import inspect;"
# We might need the pickle module when creating global constants.
if python_version >= 300:
import_code += "import pickle;"
else:
import_code += "import cPickle;"
result = _detectImports(
command = import_code,
user_provided = False,
technical = True
)
if Options.shallFreezeAllStdlib():
stdlib_modules = set()
# Scan the standard library paths (multiple in case of virtualenv.
for stdlib_dir in getStandardLibraryPaths():
for module_name in scanStandardLibraryPath(stdlib_dir):
stdlib_modules.add(module_name)
import_code = "imports = " + repr(sorted(stdlib_modules)) + '\n'\
"for imp in imports:\n" \
" try:\n" \
" __import__(imp)\n" \
" except (ImportError, SyntaxError):\n" \
" pass\n"
early_names = [
module.getFullName()
for module in result
]
result += [
module
for module in _detectImports(
command = import_code,
user_provided = False,
technical = False
)
if module.getFullName() not in early_names
]
debug("Finished detecting early imports.")
return result
_detectedShlibFile(
filename = filename,
module_name = module_name
)
return result
# Some modules we want to blacklist.
ignore_modules = [
"__main__.py",
"__init__.py",
"antigravity.py",
]
if Utils.getOS() != "Windows":
ignore_modules.append("wintypes.py")
ignore_modules.append("cp65001.py")
def scanStandardLibraryPath(stdlib_dir):
# There is a lot of black-listing here, done in branches, so there
# is many of them, but that's acceptable, pylint: disable=R0912
for root, dirs, filenames in os.walk(stdlib_dir):
import_path = root[len(stdlib_dir):].strip("/\\")
import_path = import_path.replace('\\', '.').replace('/','.')
if import_path == "":
if "site-packages" in dirs:
dirs.remove("site-packages")
def main():
""" Main program flow of Nuitka
At this point, options will be parsed already, Nuitka will be executing
in the desired version of Python with desired flags, and we just get
to execute the task assigned.
We might be asked to only re-compile generated C, dump only an XML
representation of the internal node tree after optimization, etc.
"""
# Main has to fulfill many options, leading to many branches and statements
# to deal with them. pylint: disable=too-many-branches
filename = Options.getPositionalArgs()[0]
# Inform the importing layer about the main script directory, so it can use
# it when attempting to follow imports.
Importing.setMainScriptDirectory(
main_dir = os.path.dirname(os.path.abspath(filename))
)
# Detect to be frozen modules if any, so we can consider to not recurse
# to them.
if Options.isStandaloneMode():
for module in detectEarlyImports():
ModuleRegistry.addUncompiledModule(module)
if module.getName() == "site":
origin_prefix_filename = os.path.join(
os.path.dirname(module.getCompileTimeFilename()),
"orig-prefix.txt"
)
if os.path.isfile(origin_prefix_filename):
data_files.append(
(filename, "orig-prefix.txt")
)
# Turn that source code into a node tree structure.
try:
main_module = createNodeTree(
filename = filename
)
except (SyntaxError, IndentationError) as e:
handleSyntaxError(e)
if Options.shallDumpBuiltTreeXML():
# XML output only.
for module in ModuleRegistry.getDoneModules():
dumpTreeXML(module)
else:
# Make the actual compilation.
result, options = compileTree(
main_module = main_module
)
# Exit if compilation failed.
if not result:
sys.exit(1)
if Options.shallNotDoExecCCompilerCall():
if Options.isShowMemory():
MemoryUsage.showMemoryTrace()
sys.exit(0)
if Options.isStandaloneMode():
binary_filename = options["result_exe"]
standalone_entry_points.insert(
0,
(binary_filename, binary_filename, None)
)
dist_dir = getStandaloneDirectoryPath(main_module)
for module in ModuleRegistry.getDoneUserModules():
standalone_entry_points.extend(
Plugins.considerExtraDlls(dist_dir, module)
)
for module in ModuleRegistry.getUncompiledModules():
standalone_entry_points.extend(
Plugins.considerExtraDlls(dist_dir, module)
)
copyUsedDLLs(
source_dir = getSourceDirectoryPath(main_module),
dist_dir = dist_dir,
standalone_entry_points = standalone_entry_points
)
for module in ModuleRegistry.getDoneModules():
data_files.extend(
Plugins.considerDataFiles(module)
)
for source_filename, target_filename in data_files:
target_filename = os.path.join(
getStandaloneDirectoryPath(main_module),
target_filename
)
makePath(os.path.dirname(target_filename))
shutil.copy2(
source_filename,
target_filename
)
# Remove the source directory (now build directory too) if asked to.
if Options.isRemoveBuildDir():
removeDirectory(
path = getSourceDirectoryPath(main_module),
ignore_errors = False
)
# Modules should not be executable, but Scons creates them like it, fix
# it up here. TODO: Move inside scons file and avoid subprocess call.
if Utils.getOS() != "Windows" and Options.shallMakeModule():
subprocess.call(
(
"chmod",
"-x",
getResultFullpath(main_module)
)
)
if Options.shallMakeModule() and Options.shallCreatePyiFile():
pyi_filename = getResultBasepath(main_module) + ".pyi"
with open(pyi_filename, 'w') as pyi_file:
pyi_file.write(
"""\
# This file was generated by Nuitka and describes the types of the
# created shared library.
# At this time it lists only the imports made and can be used by the
# tools that bundle libraries, including Nuitka itself. For instance
# standalone mode usage of the created library will need it.
# In the future, this will also contain type information for values
# in the module, so IDEs will use this. Therefore please include it
# when you make software releases of the extension module that it
# describes.
%(imports)s
# This is not Python source even if it looks so. Make it clear for
# now. This was decided by PEP 484 designers.
__name__ = ...
""" % {
"imports" : '\n'.join(
"import %s" % module_name
for module_name in
getImportedNames()
)
}
)
# Execute the module immediately if option was given.
if Options.shallExecuteImmediately():
if Options.shallMakeModule():
executeModule(
tree = main_module,
clean_path = Options.shallClearPythonPathEnvironment()
)
else:
executeMain(
binary_filename = getResultFullpath(main_module),
clean_path = Options.shallClearPythonPathEnvironment()
)
def copyUsedDLLs(dist_dir, standalone_entry_points):
# This is terribly complex, because we check the list of used DLLs
# trying to avoid duplicates, and detecting errors with them not
# being binary identical, so we can report them. And then of course
# we also need to handle OS specifics, pylint: disable=R0912
dll_map = []
used_dlls = detectUsedDLLs(standalone_entry_points)
for dll_filename1, sources1 in tuple(iterItems(used_dlls)):
for dll_filename2, sources2 in tuple(iterItems(used_dlls)):
if dll_filename1 == dll_filename2:
continue
# Colliding basenames are an issue to us.
if Utils.basename(dll_filename1) != Utils.basename(dll_filename2):
continue
# May already have been removed earlier
if dll_filename1 not in used_dlls:
continue
if dll_filename2 not in used_dlls:
continue
dll_name = Utils.basename(dll_filename1)
if Options.isShowInclusion():
info(
"""Colliding DLL names for %s, checking identity of \
'%s' <-> '%s'.""" % (
dll_name,
dll_filename1,
dll_filename2,
)
)
# Check that if a DLL has the same name, if it's identical,
# happens at least for OSC and Fedora 20.
import filecmp
if filecmp.cmp(dll_filename1, dll_filename2):
del used_dlls[dll_filename2]
continue
# So we have conflicting DLLs, in which case we do not proceed.
sys.exit(
"""Error, conflicting DLLs for '%s'.
%s used by:
%s
different from
%s used by
%s""" % (
dll_name,
dll_filename1,
"\n ".join(sources1),
dll_filename2,
"\n ".join(sources2)
)
)
for dll_filename, sources in iterItems(used_dlls):
dll_name = Utils.basename(dll_filename)
target_path = Utils.joinpath(
dist_dir,
dll_name
)
shutil.copy(
dll_filename,
target_path
)
dll_map.append(
(dll_filename, dll_name)
)
if Options.isShowInclusion():
info(
"Included used shared library '%s' (used by %s)." % (
dll_filename,
", ".join(sources)
)
)
if Utils.getOS() == "Darwin":
# For MacOS, the binary and the DLLs needs to be changed to reflect
# the relative DLL location in the ".dist" folder.
for standalone_entry_point in standalone_entry_points:
fixupBinaryDLLPaths(
binary_filename = standalone_entry_point[1],
is_exe = standalone_entry_point is standalone_entry_points[0],
dll_map = dll_map
)
for _original_path, dll_filename in dll_map:
fixupBinaryDLLPaths(
binary_filename = Utils.joinpath(
dist_dir,
dll_filename
),
is_exe = False,
dll_map = dll_map
)
if Utils.getOS() == "Linux":
# For Linux, the "rpath" of libraries may be an issue and must be
# removed.
for _original_path, dll_filename in dll_map:
removeSharedLibraryRPATH(
Utils.joinpath(dist_dir, dll_filename)
)
for standalone_entry_point in standalone_entry_points[1:]:
removeSharedLibraryRPATH(
standalone_entry_point[1]
)
def copyUsedDLLs(dist_dir, standalone_entry_points):
# This is terribly complex, because we check the list of used DLLs
# trying to avoid duplicates, and detecting errors with them not
# being binary identical, so we can report them. And then of course
# we also need to handle OS specifics, pylint: disable=R0912
dll_map = []
used_dlls = detectUsedDLLs(standalone_entry_points)
for dll_filename1, sources1 in tuple(iterItems(used_dlls)):
for dll_filename2, sources2 in tuple(iterItems(used_dlls)):
if dll_filename1 == dll_filename2:
continue
# Colliding basenames are an issue to us.
if Utils.basename(dll_filename1) != Utils.basename(dll_filename2):
continue
# May already have been removed earlier
if dll_filename1 not in used_dlls:
continue
if dll_filename2 not in used_dlls:
continue
dll_name = Utils.basename(dll_filename1)
if Options.isShowInclusion():
info(
"""Colliding DLL names for %s, checking identity of \
'%s' <-> '%s'.""" % (
dll_name,
dll_filename1,
dll_filename2,
)
)
# Check that if a DLL has the same name, if it's identical,
# happens at least for OSC and Fedora 20.
import filecmp
if filecmp.cmp(dll_filename1, dll_filename2):
del used_dlls[dll_filename2]
continue
# So we have conflicting DLLs, in which case we do not proceed.
sys.exit(
"""Error, conflicting DLLs for '%s'.
%s used by:
%s
different from
%s used by
%s""" % (
dll_name,
dll_filename1,
"\n ".join(sources1),
dll_filename2,
"\n ".join(sources2)
)
)
for dll_filename, sources in iterItems(used_dlls):
dll_name = Utils.basename(dll_filename)
target_path = Utils.joinpath(
dist_dir,
dll_name
)
shutil.copy(
dll_filename,
target_path
)
dll_map.append(
(dll_filename, dll_name)
)
if Options.isShowInclusion():
info(
"Included used shared library '%s' (used by %s)." % (
dll_filename,
", ".join(sources)
)
)
if Utils.getOS() == "Darwin":
# For MacOS, the binary and the DLLs needs to be changed to reflect
# the relative DLL location in the ".dist" folder.
for standalone_entry_point in standalone_entry_points:
fixupBinaryDLLPaths(
binary_filename = standalone_entry_point[0],
is_exe = standalone_entry_point is standalone_entry_points[0],
dll_map = dll_map
)
for _original_path, dll_filename in dll_map:
fixupBinaryDLLPaths(
binary_filename = Utils.joinpath(
dist_dir,
dll_filename
),
is_exe = False,
dll_map = dll_map
)
if Utils.getOS() == "Linux":
# For Linux, the "rpath" of libraries may be an issue and must be
# removed.
for _original_path, dll_filename in dll_map:
removeSharedLibraryRPATH(
Utils.joinpath(dist_dir, dll_filename)
)
for standalone_entry_point in standalone_entry_points[1:]:
removeSharedLibraryRPATH(
standalone_entry_point[0]
)
