def _create_build_dir_dict(self, compiler_info, generator_alias, build_configs): build_dir_dict = {} if compiler_info.is_cross_compiler(): assert generator_alias == 'umake' build_root = self._create_cross_compile_build_dir(self._build_root, compiler_info.cmake_toolchain_file, generator_alias) print("cross compile build root: " + build_root) if generator_alias == 'umake': for cfg in build_configs: build_dir_dict[cfg + '.' + 'static'] = os.path.join(build_root, cfg) build_dir_dict[cfg + '.' + 'shared'] = os.path.join(build_root, cfg + '-shared') else: target_arch = compiler_info.target_arch if compiler_info.mingw: toolset_dir = "{}-mingw-{}".format(compiler_info.compiler_family, ver.version_tuple_to_str(compiler_info.version_major_minor)) else: toolset_dir = "{}-{}".format(compiler_info.compiler_family, ver.version_tuple_to_str(compiler_info.version_major_minor)) if self.is_multi_configuration_generator(): for cfg in build_configs: build_dir_dict[cfg + '.' + 'static'] = os.path.join(self._build_root, generator_alias, toolset_dir, target_arch) build_dir_dict[cfg + '.' + 'shared'] = os.path.join(self._build_root, generator_alias, toolset_dir, target_arch + '-shared') else: for cfg in build_configs: build_dir_dict[cfg + '.' + 'static'] = os.path.join(self._build_root, generator_alias, toolset_dir, target_arch, cfg) build_dir_dict[cfg + '.' + 'shared'] = os.path.join(self._build_root, generator_alias, toolset_dir, target_arch, cfg + '-shared') return build_dir_dict
def __init__(self, verbosity=1): self._logger = logging.getLogger(__name__) self._sys_info = SystemInfo() self._verbosity_level = verbosity self._cmake_finder = CMakeFinder(self._sys_info) self._top_dir = None self._build_root = None self._build_tree_create_if_not_exists = True self._build_tree_info = None self._deploy_dir = None self._script_name = os.path.basename(sys.argv[0]) self._cmk_cache_file = 'CMakeCache.txt' # cache entries the user cannot override via -Dxxx self._cmk_reserved_cache_vars = ['BUILD_SHARED_LIBS', 'CMAKE_BUILD_TYPE', 'CMAKE_CONFIGURATION_TYPES', 'CMAKE_CXX_COMPILER', 'CMAKE_C_COMPILER', 'CMAKE_TOOLCHAIN_FILE'] self._dict_to_cmake_generator = {'umake': 'Unix Makefiles', 'mgwmake': 'MinGW Makefiles', 'ninja': 'Ninja', 'xcode': 'Xcode', 'vs15': 'Visual Studio 15 2017', 'vs14': 'Visual Studio 14 2015', 'vs12': 'Visual Studio 12 2013', 'vs11': 'Visual Studio 11 2012', 'vs10': 'Visual Studio 10 2010'} # list of default configuration types for multiconfiguration generators. self._default_config_types = ['debug', 'release'] # self._default_config_types = ['debug', 'release', 'relwithdebinfo'] self._dict_to_cmake_config = {'debug': 'Debug', 'release': 'Release', 'relwithdebinfo': 'RelWithDebInfo', 'minsizerel': 'MinSizeRel'} self._dict_to_vs_platform_name = {'x86_64': 'x64', 'x86': 'Win32'} self._prefer_vs_native_toolsets = True if self._sys_info.is_windows(): self._msvc_registry = bldtools.MsvcRegistry() self._dict_to_vs_platform_toolset = {'msvc-19.0': 'v140', 'msvc-18.0': 'v120', 'msvc-17.0': 'v110', 'msvc-16.0': 'v100'} self._dict_generator_alias_to_msvc_toolsets = {'vs14': ['msvc-19.0', 'msvc-18.0', 'msvc-17.0', 'msvc-16.0'], 'vs12': ['msvc-18.0', 'msvc-17.0', 'msvc-16.0'], 'vs11': ['msvc-17.0', 'msvc-16.0'], 'vs10': ['msvc-16.0']} # vs15 has not a fixed compiler version and therefore the mapping is generated dynamically. if self._msvc_registry.is_version_installed((14, 1)): cl_version = self._msvc_registry.get_compiler_version((14, 1)) msvc_str = 'msvc-' + ver.version_tuple_to_str(cl_version[:2]) if cl_version[1] < 20: self._dict_to_vs_platform_toolset[msvc_str] = 'v141' self._dict_generator_alias_to_msvc_toolsets['vs15'] = [msvc_str, 'msvc-19.0', 'msvc-18.0', 'msvc-17.0', 'msvc-16.0'] else: assert False
def __str__(self): if self.cmake_toolchain_file: s = "toolchain file: %s\n" % self.cmake_toolchain_file else: s = "compiler family: %s\n" % self.compiler_family s += "compiler version (major.minor): %s\n" % ver.version_tuple_to_str(self.version_major_minor) if self.target_arch: s += "target arch: %s\n" % self.target_arch if self.cmake_cxx_compiler: s += "cmake cxx compiler: %s\n" % self.cmake_cxx_compiler s += "cmake c compiler: %s\n" % self.cmake_c_compiler return s
def cm_import(self, svn_url): assert self._cm_version is not None dst_dir_base = os.path.join(self._svn_import_dir, ver.version_tuple_to_str(self._cm_version)) # remove the destination directory to get rid of any existing files if os.path.exists(dst_dir_base): shutil.rmtree(dst_dir_base) os.makedirs(dst_dir_base) for file_info in self._pkg_file_list: # print("Copying " + file_info.cm_file + " -> " + file_info.dst_dir) dst_dir = os.path.join(dst_dir_base, file_info.dst_dir) if not os.path.exists(dst_dir): os.makedirs(dst_dir) print("Copying " + os.path.basename(file_info.cm_file) + " -> " + dst_dir) shutil.copy(file_info.cm_file, dst_dir) svn_import_args = ['svn', 'import', '--no-ignore', '-m'] # add a standard import comment svn_import_args.append( "cmsvn_import.py: importing CodeMeter software " + ver.version_tuple_to_str(self._cm_version)) svn_import_args.append(self._svn_import_dir) svn_import_args.append(svn_url) # print("svn import command:", svn_import_args) # print("cmsvn_import.py: starting the import ... ") if self._dry_run: print("\n*** DRY RUN ***\n" + ' '.join(svn_import_args) + "\n") else: retv = subprocess.call(svn_import_args) if retv != 0: raise Exception( "svn import failed, please contact technical support.") if os.path.exists(self._svn_import_dir): shutil.rmtree(self._svn_import_dir)
def __call__(self): parser = argparse.ArgumentParser() parser.add_argument( "-v", action="store_true", dest="verbose", default=False, help= "enable verbose output suitable for humans. The default format is intended for scripting frameworks like Boost.Build." ) parser.add_argument( "--ignore-env-vars", action="store_false", dest="use_env", default=True, help= "disable environment variable ANDROID_NDK_ROOT in finding the desired NDK." ) util.app_args_add_log_level(parser) args = parser.parse_args() # configure the python logger util.app_configure_logging(args.log_level) ndk_finder = pyhhi.build.common.android.NdkFinder(args.use_env) if args.verbose: print('%-42s %s' % ('NDK root:', ndk_finder.get_ndk_root())) print('%-42s %s' % ('NDK version:', ver.version_tuple_to_str(ndk_finder.get_ndk_version()))) print('%-42s %s' % ('NDK-SA root:', ndk_finder.get_ndksa_root(None))) print('%-42s %s' % ('Avail. platforms:', ndk_finder.get_ndk_platforms())) toolchains = ndk_finder.get_ndksa_toolchains('gnustl') if toolchains: print( '%-42s %s' % ('Avail. standalone toolchains using gnustl:', toolchains)) toolchains = ndk_finder.get_ndksa_toolchains('libc++') if toolchains: print( '%-42s %s' % ('Avail. standalone toolchains using libc++:', toolchains))
def _get_current_cmakebuild_version(self, top_dir): assert os.path.exists(top_dir) cmakebuild_top_dir = os.path.join(top_dir, 'CMakeBuild') if not os.path.exists(cmakebuild_top_dir): return None re_version_dir = re.compile(r'^\d+[0-9.]+-\d+$') version_list = [] for fname in os.listdir(cmakebuild_top_dir): if os.path.isdir(os.path.join(cmakebuild_top_dir, fname)): if re_version_dir.match(fname) and os.path.exists(os.path.join(cmakebuild_top_dir, fname, 'CMakeBuild', 'bin', 'cmake.py')): version_list.append(ver.version_tuple_from_str(fname)) if not version_list: return None if len(version_list) > 1: raise InvalidInputParameterError("Workspace {} contains multiple CMakeBuild versions, please update manually.".format(top_dir)) self._logger.debug("found CMakeBuild {} in {}".format(ver.version_tuple_to_str(version_list[0]), top_dir)) return version_list[0]
def _query_platforms(self, ndk_root): platforms_dir = os.path.join(ndk_root, 'platforms') assert os.path.exists(platforms_dir) re_platform = re.compile('android-(\d+)$') # enumerate installed platforms in ascending order. version_list = [ ver.version_tuple_from_str(re_platform.match(d).group(1)) for d in os.listdir(platforms_dir) if re_platform.match(d) ] if version_list: version_list = ver.version_list_sort(version_list) ndk_platforms = [ 'android-' + ver.version_tuple_to_str(version) for version in version_list ] return ndk_platforms else: assert False
def _is_boost_python_enabled(self, toolset, platform_index, target): build_python = False platform_info = toolset.get_platform_info(platform_index) if toolset.is_mingw() or (platform_info.get_target_os() == 'android'): return build_python python_version = self._sys_info.get_python_version() if platform_info.get_target_os() == 'linux': # This is neither mingw or android if target in ['x86_64', 'x86']: python_header_file = os.path.join( '/usr/include', 'python' + ver.version_tuple_to_str(python_version[:2]), 'Python.h') if os.path.exists(python_header_file): build_python = True elif platform_info.get_target_os() == 'macosx': #python_header_file = os.path.join('/usr/include', 'python' + ver.version_tuple_to_str(python_version[:2]), 'Python.h') #if os.path.exists(python_header_file): build_python = True elif toolset.get_toolset() == 'msvc': # This implies msvc and target either x86 or x86_64. if self._sys_info.get_python_arch() == target: build_python = True return build_python
def launch_config(self, compiler_info, generator_alias, build_configs, lnk_variant, cmake_argv_optional): cur_dir = os.getcwd() cmake_argv = [] if self._is_multi_configuration_generator(): tmp_build_configs = [build_configs[0]] else: tmp_build_configs = build_configs for cfg in tmp_build_configs: b_dir = self._build_tree_info.get_build_dir(cfg, lnk_variant) if not os.path.exists(b_dir): os.makedirs(b_dir) if generator_alias.startswith('vs'): if compiler_info.compiler_family == 'msvc': if self._is_vs_64bit_native_toolset_supported( generator_alias): vs_toolset = self._dict_to_vs_platform_toolset[ 'msvc-' + ver.version_tuple_to_str( compiler_info.version_major_minor )] + ',host=x64' else: vs_toolset = self._dict_to_vs_platform_toolset[ 'msvc-' + ver.version_tuple_to_str( compiler_info.version_major_minor)] elif compiler_info.compiler_family == 'intel': vs_toolset = "Intel C++ Compiler %d.%d" % ( compiler_info.version_major_minor[0], compiler_info.version_major_minor[1]) else: assert False cmake_argv = [ '-G', self._dict_to_cmake_generator[generator_alias], '-T', vs_toolset, '-A', self._dict_to_vs_platform_name[compiler_info.target_arch] ] elif generator_alias == 'xcode': cmake_argv = [ '-G', self._dict_to_cmake_generator[generator_alias] ] elif generator_alias in ['umake', 'mgwmake', 'ninja']: cmake_argv = [ '-G', self._dict_to_cmake_generator[generator_alias], '-DCMAKE_BUILD_TYPE=' + self._dict_to_cmake_config[cfg] ] if compiler_info.is_cross_compiler(): cmake_argv.append('-DCMAKE_TOOLCHAIN_FILE=' + compiler_info.cmake_toolchain_file) else: if compiler_info.cmake_cxx_compiler: cmake_argv.append('-DCMAKE_CXX_COMPILER=' + compiler_info.cmake_cxx_compiler) if compiler_info.cmake_c_compiler: cmake_argv.append('-DCMAKE_C_COMPILER=' + compiler_info.cmake_c_compiler) if cmake_argv_optional: # Add any additional arguments to the cmake command line. cmake_argv.extend(cmake_argv_optional) if lnk_variant == 'shared': cmake_argv.append('-DBUILD_SHARED_LIBS=1') if self._is_multi_configuration_generator(): cmake_config_types = [ self._dict_to_cmake_config[x] for x in self._default_config_types ] for b_cfg in build_configs: if b_cfg not in self._default_config_types: cmake_config_types.append( self._dict_to_cmake_config[b_cfg]) cmake_argv.append('-DCMAKE_CONFIGURATION_TYPES=' + ';'.join(cmake_config_types)) # cmake_argv.append(self._top_dir) # print("launch_config(): cmake_args", cmake_argv) # print("build dir:", b_dir) # print("top dir:", self._top_dir) os.chdir(b_dir) cmake_argv.append(os.path.relpath(self._top_dir)) retv = self.launch_cmake(cmake_argv) os.chdir(cur_dir) if retv != 0: sys.exit(1)
def test_cmake_version_parser(self): cmk_finder = cmksupp.CMakeFinder() for ver_tuple in self._cmk_version_test_set: cmk_version = cmk_finder._parse_cmake_version_retv(ver_tuple[0]) self.assertEqual(ver_tuple[1], ver.version_tuple_to_str(cmk_version))
def main(self, argv): parser = argparse.ArgumentParser() parser.add_argument( "-v", "--verbose", action="store_true", dest="verbose", help= "enable verbose output suitable for humans. The default format is intended for scripting frameworks like Boost.Build/bjam." ) parser.add_argument("--print-env", action="store_true", dest="print_env", help="print environment variables") util.app_args_add_log_level(parser) args = parser.parse_args(argv) # configure the python logger util.app_configure_logging(args.log_level) # creates the system info object and performs python version checks sys_info = pyhhi.build.common.system.SystemInfo(True) if args.verbose: print('%-30s %s' % ('python version:', ver.version_tuple_to_str(sys_info.get_python_version()))) print('%-30s %s' % ('python executable:', sys_info.get_python_executable())) if sys_info.is_windows(): print('%-30s %s' % ('python executable (short path):', sys_info.get_short_path( sys_info.get_python_executable()))) print('%-30s %s' % ('python launcher:', sys_info.get_python_launcher())) print('%-30s %s' % ('python implementation:', sys_info.get_python_implementation())) print('%-30s %s' % ('python architecture:', sys_info.get_python_arch())) if sys_info.is_windows(): print('%-30s %s' % ('python module win32api?:', str(sys_info.is_win32api_installed()))) print('%-30s %s' % ('platform:', sys_info.get_platform_long())) print('%-30s %s' % ('os distro:', sys_info.get_os_distro())) if sys_info.is_linux(): print('%-30s %s' % ('debian?:', str(sys_info.is_debian()))) print('%-30s %s' % ('redhat?:', str(sys_info.is_redhat()))) print('%-30s %s' % ('suse?:', str(sys_info.is_suse()))) print('%-30s %s' % ('package format:', sys_info.get_pkg_fmt())) print('%-30s %s' % ('package architecture:', sys_info.get_pkg_arch())) elif sys_info.is_windows(): print('%-30s %s' % ('windows8?:', str(sys_info.is_windows8()))) print('%-30s %s' % ('os codename:', sys_info.get_os_codename())) print('%-30s %s' % ('os version:', ver.version_tuple_to_str(sys_info.get_os_version()))) print('%-30s %s' % ('os architecture:', sys_info.get_os_arch())) print('%-30s %s' % ('locale.prefencoding:', locale.getpreferredencoding(False))) print('%-30s %s' % ('number of processors:', sys_info.get_number_processors())) print('%-30s %s' % ('home directory:', sys_info.get_home_dir())) desktop_dir = sys_info.get_desktop_dir() if desktop_dir is not None: print('%-30s %s' % ('desktop:', desktop_dir)) # get_program_dir(self, target_arch): if sys_info.is_windows(): program_dir = sys_info.get_program_dir(sys_info.get_os_arch()) print('%-30s %s' % ('program dir:', program_dir)) if sys_info.get_os_arch() == 'x86_64': program_dir = sys_info.get_program_dir('x86') print('%-30s %s' % ('program dir x86:', program_dir)) label = 'path:' for d in sys_info.get_path(): print('%-30s %s' % (label, d)) label = ' ' elif args.print_env: env_var_list = [] for env_var in os.environ: env_var_list.append(env_var) env_var_list.sort() for env_var in env_var_list: print(env_var + '=' + os.getenv(env_var)) else: print(sys_info.get_system_info_full_str())
def __call__(self): def lowercase_arg(string): return string.lower() _usage = """%(prog)s [options] [toolset] This script lists the toolset properties in a single line separated by a ';'. The description can be easily parsed by Boost.Build jam code to simplify toolset setup. Examples: %(prog)s gcc %(prog)s msvc-12.0 %(prog)s gcc-4.9 %(prog)s --target-os=iphone clang %(prog)s --target-os=iphone --target-arch=armv7 clang %(prog)s --target-os=iphonesimulator clang %(prog)s arm-linux-androideabi-g++ %(prog)s --api-level=19 arm-linux-androideabi-g++ %(prog)s aarch64-linux-android-g++ %(prog)s i686-linux-android-g++ %(prog)s x86_64-linux-android-g++ """ parser = argparse.ArgumentParser(usage=_usage) parser.add_argument( "toolset", action="store", nargs='?', help="optional argument to override the default toolset.") util.app_args_add_log_level(parser) parser.add_argument( "-v", action="store_true", dest="verbose", default=False, help= "enable verbose output suitable for humans. The default format is intended for scripting frameworks like Boost.Build/b2." ) parser.add_argument( "--internal-version", action="store_true", dest="internal_version", default=False, help="list toolset's internal version, supported by msvc-x.y.") parser.add_argument( "--api-level", action="store", dest="api_level", type=int, help= "override the default Android API level, the default is either the latest or fixed when the toolchain has been created." ) parser.add_argument( "--target-os", action="store", dest="target_os", type=lowercase_arg, help= "add a target OS filter, by default all toolset information is emitted." ) parser.add_argument( "--target-arch", action="store", dest="target_arch", type=lowercase_arg, help= "add a target ARCH filter, by default the complete toolset information is emitted." ) parser.add_argument( "--short-path-name", action="store_true", dest="short_path_name", default=False, help="translate the compiler path into a short path on windows.") args = parser.parse_args() # configure the python logger util.app_configure_logging(args.log_level) if args.toolset: ts = bldtools.Toolset(self._sys_info, args.toolset) else: ts = bldtools.Toolset(self._sys_info) if args.api_level: # Override the default Android API level for platform_info in ts.get_platform_info(): platform_info.set_api_level(args.api_level) if args.verbose: print(ts, "\n") #print("Summary: " + ts.get_toolset_info_short()) elif args.internal_version: if ts.get_internal_version(): print(ver.version_tuple_to_str(ts.get_internal_version())) else: if self._sys_info.is_windows() and args.short_path_name: compiler_command = self._sys_info.get_short_path( ts.get_compiler_command()) else: compiler_command = ts.get_compiler_command() if ts.get_toolset() == 'msvc': tvl = list(ts.get_version()) tvl.extend(ts.get_internal_version()) toolset_version = tuple(tvl) else: toolset_version = ts.get_version() toolset_info_list = [ ts.get_toolset(), ver.version_tuple_to_str(toolset_version), compiler_command ] compiler_prefix = ts.get_compiler_prefix() if compiler_prefix is None: toolset_info_list.append('none') else: toolset_info_list.append(compiler_prefix) target_os_arch_list = [] target_os_rtl_list = [] for platform_info in ts.get_platform_info(): target_os = platform_info.get_target_os() if args.target_os and (target_os != args.target_os): # filter out platforms by target_os; e.g. return just the iphone toolset information. continue isysroot = platform_info.get_isysroot() for target_arch in platform_info.get_target_arch(): if args.target_arch and (target_arch != args.target_arch): # filter out target architectures if provided. continue if isysroot: assert self._sys_info.is_macosx() target_os_arch_list.append(target_os + '%' + target_arch + '%' + isysroot) else: if target_os == 'android': target_os_arch_list.append( '%s-%d%%%s' % (target_os, platform_info.get_api_level(), target_arch)) else: target_os_arch_list.append(target_os + '%' + target_arch) if (target_os == 'windows') and (ts.get_toolset() == 'gcc'): # mingw: add runtime library information if available. runtime_libs = platform_info.get_target_runtime_libs( target_arch) if runtime_libs: target_os_rtl_list.append(target_arch + '%' + '@'.join(runtime_libs)) toolset_info_list.append('!'.join(target_os_arch_list)) if target_os_rtl_list: toolset_info_list.append('!'.join(target_os_rtl_list)) else: toolset_info_list.append('none') toolset_info_list.append(ts.get_compiler_tag()) toolset_info_list.append(ts.get_boost_compiler_tag()) print(";".join(toolset_info_list))
def cmakebuild_update(self, params): initial_work_dir = os.getcwd() # (Re)create GitHelper in case the log level has been changed. self._git_helper = vcsutil.GitHelper() params = self._check_params(params) if params.top_dir is None: params.top_dir = util.get_top_dir() self._summary_lines = [] if params.update_prepare: print("{}: preparing CMakeBuild update ...".format(self._prog_name)) cmakebuild_version_current = self._get_current_cmakebuild_version(params.top_dir) if cmakebuild_version_current is None: print("{}: no existing CMakeBuild version found.".format(params.top_dir)) if not self._is_workspace_clean(params.top_dir): return if params.cmakebuild_tag is None: cmakebuild_tag = self._git_helper.get_latest_cmakebuild_tag(params.cmakebuild_repo) if cmakebuild_version_current and (ver.version_compare(cmakebuild_version_current, ver.version_tuple_from_str(cmakebuild_tag)) == 0): print("{}: CMakeBuild is up to date, nothing to be done.".format(params.top_dir)) return else: # Validate CMakeBuild tag cmakebuild_tags = self._git_helper.get_remote_tags(params.cmakebuild_repo) if params.cmakebuild_tag not in cmakebuild_tags: raise InvalidInputParameterError("requested tag {0} does not exists in {1}.".format(params.cmakebuild_tag, params.cmakebuild_repo)) cmakebuild_tag = params.cmakebuild_tag if cmakebuild_version_current and (ver.version_compare(ver.version_tuple_from_str(cmakebuild_tag), cmakebuild_version_current) <= 0): print("{}: CMakeBuild is up to date, nothing to be done.".format(params.top_dir)) return install_dir = os.path.join(params.top_dir, 'build', 'cmakebuild_update') self._install_self(install_dir) update_script = os.path.join(install_dir, self._prog_name) # Prepare execv argument vector to call self with different arguments using the current python executable. if self._sys_info.is_windows(): child_args = [self._sys_info.get_short_path(self._sys_info.get_python_executable())] else: child_args = [self._sys_info.get_python_executable()] child_args.extend([update_script, '--update']) if cmakebuild_tag: child_args.extend(['-t', cmakebuild_tag]) if params.cmakebuild_repo: child_args.extend(['--cmakebuild-repo', params.cmakebuild_repo]) # Add currrent log option to child_args[] to propagate the current log option to the child process. log_level = self._logger.getEffectiveLevel() log_level_str = None if log_level == logging.DEBUG: log_level_str = 'debug' elif log_level == logging.INFO: log_level_str = 'info' elif log_level == logging.WARNING: log_level_str = 'warning' elif log_level == logging.ERROR: log_level_str = 'error' elif log_level == logging.CRITICAL: log_level_str = 'critical' if log_level_str is not None: child_args.append('--log={}'.format(log_level_str)) child_args.append(params.top_dir) os.chdir(params.top_dir) if self._sys_info.is_windows(): # Unfortunately, there are issues with os.execv() on Windows and therefore a subprocess call is used instead. util.subproc_check_call_flushed(child_args) else: # execv() is preferred as the child is likely to remove python files just being executed # by the current python process. os.execv(child_args[0], child_args) else: try: print("{}: updating CMakeBuild in {} to {}".format(self._prog_name, params.top_dir, params.cmakebuild_tag)) os.chdir(params.top_dir) if not self._is_workspace_clean(): return self._append_item_to_summary("Git workspace:", params.top_dir) if self._list_summary: cmakebuild_version_current = self._get_current_cmakebuild_version(params.top_dir) if cmakebuild_version_current is not None: self._append_item_to_summary("Current CMakeBuild version:", "{}-{:d}".format(ver.version_tuple_to_str(cmakebuild_version_current[:3]), cmakebuild_version_current[-1])) self._append_item_to_summary("New CMakeBuild version:", params.cmakebuild_tag) # Inventory of CMakeBuild to remember existing directories to be removed later on. (git_cmakebuild_dirs, cmakebuild_dirs) = self._get_git_cmakebuild_dirs(params.top_dir) if params.cmakebuild_tag in git_cmakebuild_dirs: git_cmakebuild_dirs.remove(params.cmakebuild_tag) if params.cmakebuild_tag in cmakebuild_dirs: cmakebuild_dirs.remove(params.cmakebuild_tag) # print("found existing Git CMakeBuild subdirs:", git_cmakebuild_dirs) # print("found existing CMakeBuild subdirs:", cmakebuild_dirs) # Add new CMakeBuild subtree self._add_cmakebuild_to_git_repo(params.cmakebuild_tag, params.cmakebuild_repo) # Update .svnimportprops in case is does exist. svnimportprops_file = os.path.join(params.top_dir, '.svnimportprops') svnimportprops_modified = self._update_svnimportprops(svnimportprops_file, params.cmakebuild_tag) for dname in git_cmakebuild_dirs: git_argv = [self._git_executable, 'rm', '-r', os.path.join('CMakeBuild', dname)] util.subproc_check_call_flushed(git_argv) if svnimportprops_modified or git_cmakebuild_dirs: # Need a git commit if '.svnimportprops' has been updated or git rm -r has been launched. git_comment = [] if git_cmakebuild_dirs: git_comment.append("rm -r CMakeBuild/{}".format(','.join(git_cmakebuild_dirs))) if svnimportprops_modified: git_comment.append("modifying {}".format('.svnimportprops')) git_argv = [self._git_executable, 'commit', '-am', '{}: {}'.format(self._prog_name, ', '.join(git_comment))] util.subproc_check_call_flushed(git_argv) # Check again to get rid of any python cache files cmakebuild_dirs.extend(git_cmakebuild_dirs) for dname in cmakebuild_dirs: dname_path = os.path.join(params.top_dir, 'CMakeBuild', dname) if os.path.exists(dname_path): util.rmtree(dname_path) print("{}: finished updating CMakeBuild in {} to {}".format(self._prog_name, params.top_dir, params.cmakebuild_tag)) if self._list_summary: print("\n{0:^80}".format("Summary")) print("{0:^80}".format("=======")) for line in self._summary_lines: print(line) finally: pass os.chdir(initial_work_dir)
def build_boost(self, build_params): #print("BoostBuilder.build_boost() starting ...") # extract the boost version boost_version = get_boost_version(build_params.boost_dir) self._boost_version = boost_version # print("BoostBuilder: boost version:", boost_version) # check the boost version against the minimal version we support if ver.version_compare(boost_version, self._min_boost_version) < 0: raise Exception( "The boost version " + ver.version_tuple_to_str(boost_version) + " is not supported anymore, please contact technical support.") # construct a new toolset toolset = bldtools.Toolset(self._sys_info, build_params.toolset, build_params.cxx_runtime) self._toolset = toolset if toolset.get_toolset() == 'intel': if self._sys_info.is_windows(): # Update MSVC environment to be used with the Intel compiler if build_params.msvc_rt is None: # Use latest MSVC by default msvc_registry = bldtools.MsvcRegistry() msvc_version = msvc_registry.get_latest_version() build_params.msvc_rt = "msvc-%d.%d" % (msvc_version[0], msvc_version[1]) # self._intel_msvc_suffix = self._intel_msvc_suffix_dict[ build_params.msvc_rt] elif self._sys_info.is_macosx(): if ver.version_compare(boost_version, (1, 66, 0)) == 0: # Is intel-darwin.jam patched? intel_darwin_boost = os.path.join(build_params.boost_dir, 'tools', 'build', 'src', 'tools', 'intel-darwin.jam') intel_darwin_patched = os.path.join( util.get_top_dir(), 'CMakeBuild', 'patches', 'Boost', ver.version_tuple_to_str(boost_version), 'tools', 'build', 'src', 'tools', 'intel-darwin.jam') assert os.path.exists(intel_darwin_boost) assert os.path.exists(intel_darwin_patched) if not filecmp.cmp(intel_darwin_boost, intel_darwin_patched, shallow=False): raise Exception( """intel-darwin.jam requires a patch. Consider a manual update: cp %s %s or contact technical support. """ % (intel_darwin_patched, intel_darwin_boost)) platform_info = toolset.get_platform_info(build_params.platform_index) if (platform_info.get_target_os() == 'macosx') and (build_params.macosx_version_min is None): # At times Xcode ships with OSX SDK version > macosx version, this is not permitted by default. if ver.version_compare(platform_info.get_sdk_version(), self._sys_info.get_os_version()) > 0: build_params.macosx_version_min = self._sys_info.get_os_version( )[:2] # check the optional target if build_params.targets: for target in build_params.targets: if target not in platform_info.get_target_arch(): raise Exception( "The target " + target + " is not supported. Please check target and toolset.") else: # no target(s) specified, use the defaults if toolset.get_toolset() == 'msvc': build_params.targets = list(platform_info.get_target_arch()) elif platform_info.get_target_os() in [ 'iphone', 'iphonesimulator' ]: if build_params.macosx_version_min: target_os_version = build_params.macosx_version_min else: target_os_version = platform_info.get_target_os_version() if ver.version_compare(target_os_version, (11, 0)) >= 0: # No support for 32 bit IOS targets anymore. if platform_info.get_target_os() == 'iphone': build_params.targets = ['arm64'] elif platform_info.get_target_os() == 'iphonesimulator': build_params.targets = ['x86_64'] else: assert False else: if platform_info.get_target_os() == 'iphone': build_params.targets = ['arm64', 'armv7'] elif platform_info.get_target_os() == 'iphonesimulator': build_params.targets = ['x86_64', 'x86'] else: assert False else: build_params.targets = [platform_info.get_target_arch(0)] # update the build parameters given the attributes of the toolset. self._update_build_params(toolset, build_params) #print(build_params) #return boost_lib_files_missing = False lib_dir_list = [] if build_params.rebuild_all: boost_lib_files_missing = True if not build_params.dry_run: for target in build_params.targets: if platform_info.get_target_os() == 'windows': bin_dir = self.get_boost_bin_dir( build_params.boost_dir, toolset, build_params.platform_index, target) if os.path.exists(bin_dir): shutil.rmtree(bin_dir) lib_dir = self.get_boost_lib_dir( build_params.boost_dir, toolset, build_params.platform_index, target) lib_dir_list.append(lib_dir) if os.path.exists(lib_dir): shutil.rmtree(lib_dir) else: for target in build_params.targets: lib_dir = self.get_boost_lib_dir(build_params.boost_dir, toolset, build_params.platform_index, target) lib_dir_list.append(lib_dir) if not os.path.exists(lib_dir): boost_lib_files_missing = True if boost_lib_files_missing: self._build_libs(boost_version, toolset, build_params) if not build_params.dry_run: if self._sys_info.is_macosx(): if len(build_params.targets) > 1: # create a fat binary/universal library file fat_binary_tool = bldtools.FatBinaryTool() platform_info = toolset.get_platform_info( build_params.platform_index) assert ((platform_info.get_target_os() == 'iphone') or (platform_info.get_target_os() == 'iphonesimulator')) src_lib_dirs = [] for target in build_params.targets: lib_dir = self.get_boost_lib_dir( build_params.boost_dir, toolset, build_params.platform_index, target) src_lib_dirs.append(lib_dir) dst_lib_dir = self.get_boost_lib_dir( build_params.boost_dir, toolset, build_params.platform_index, 'combined') if os.path.exists(dst_lib_dir): shutil.rmtree(dst_lib_dir) fat_binary_tool.createLibs(src_lib_dirs, dst_lib_dir) # if ver.version_compare( (1, 59, 0), self._boost_version) > 0: platform_info = toolset.get_platform_info( build_params.platform_index) if platform_info.get_target_os() == 'macosx': lib_dir = self.get_boost_lib_dir( build_params.boost_dir, toolset, build_params.platform_index, build_params.targets[0]) print( "Checking install names and dependencies in " + lib_dir) dylib_list = glob.glob(lib_dir + '/*.dylib') inst_name_inspector = bldtools.DyLibInstallNameInfoInspector( ) for dylib in dylib_list: inst_name_info = inst_name_inspector.create_install_name_info( dylib) if not inst_name_info.inst_name.startswith( '@rpath/'): inst_name_inspector.modify_install_name( dylib, os.path.join('@rpath', inst_name_info.basename)) # Walk the dependency list and change all boost libraries from libboost_NNN.dylib to @rpath/libboost_NNN.dylib. depends_dict = {} for libname in inst_name_info.depends_list: if libname.startswith('libboost_'): depends_dict[ libname] = os.path.join( '@rpath', libname) if depends_dict: print("Changing dependencies of " + os.path.basename(dylib)) inst_name_inspector.modify_depends( dylib, depends_dict) print("\n") print( "-------------------- Post build phase --------------------" ) for lib_dir in lib_dir_list: self._list_boost_components(lib_dir) print( "----------------------------------------------------------" ) else: print( "No boost library directories are missing, skipping library build step." ) print("Use --rebuild if you intend to rebuild all libraries.")
def main(self, argv): (boost_build_params, boost_dir, cxx_std) = self._parse_command_line(argv) # Change the current working directory to the top level directory in case the caller has moved # into CMakeBuild or bin to invoke boost_install.py. top_dir = util.get_top_dir() os.chdir(top_dir) msg_list_summary = [] msg_list_summary.append('%-25s %s' % ('python version:', ver.version_tuple_to_str(self._sys_info.get_python_version()))) msg_list_summary.append('%-25s %s' % ('python executable:', self._sys_info.get_python_executable())) msg_list_summary.append('%-25s %s' % ('platform:', self._sys_info.get_platform_long())) msg_list_todo = [] self._sys_info.check_os_detection(msg_list_todo) if boost_dir is None: print("boost_install.py: no boost directory specified, use option --boost-dir.") sys.exit(1) else: boost_build_params.boost_dir = boost_dir if boost_build_params.boost_dir.startswith('/usr/include'): # system layout -> don't try to build the boost SDK and just extract the boost version msg_list_summary.append('%-25s %s' % ('boost version:', ver.version_tuple_to_str(boostbld.get_boost_version(boost_build_params.boost_dir)))) else: # create the BoostBuilder boost_builder = boostbld.BoostBuilder(self._sys_info) if cxx_std: boost_build_params.cxx_std = cxx_std else: re_match = re.match(r'.*-(c\+\+[0-9]+)$', boost_dir) if re_match: boost_build_params.cxx_std = re_match.group(1) else: boost_build_params.cxx_std = 'c++11' # launch Boost building with the current set of build options. boost_builder.build_boost(boost_build_params) # compose the summary msg_list_summary.append('%-25s %s' % ('boost root:', boost_dir)) msg_list_summary.append('%-25s %s' % ('boost version:', ver.version_tuple_to_str(boost_builder.get_boost_version()))) if boost_build_params.targets: msg_list_summary.append('%-25s %s' % ('boost toolset:', boost_builder.get_toolset().get_toolset_info_short(boost_build_params.targets[0]))) bjam_cmd_lines = boost_builder.get_bjam_cmd_lines() if bjam_cmd_lines: msg_list_summary.append('bjam command(s):') msg_list_summary.extend(boost_builder.get_bjam_cmd_lines()) if msg_list_summary: print() print(" SUMMARY ") print(" ======= ") print() for msg in msg_list_summary: print(msg) print() if msg_list_todo: print("\nTODO List:") for msg in msg_list_todo: print(msg) print() print("boost_install.py finished successfully.\n")
def test_version_tuple_to_str(self): self.assertEqual('10', ver.version_tuple_to_str(tuple([10]))) self.assertEqual('10.2', ver.version_tuple_to_str((10, 2)))
def _create_user_config_content(self, toolset, platform_index, target, build_boost_mpi, build_boost_python, cppflags=None, cflags=None, lflags=None, msvc_rt=None): """Check the toolset attributes and determine whether a temporary user-config.jam is needed or not.""" lines = [] platform_info = toolset.get_platform_info(platform_index) toolset_str = toolset.get_toolset() toolset_version_str = ver.version_tuple_to_str( toolset.get_version()[:2]) cxxflags = [] compileflags = [] linkflags = [] rc = [] using_line = None setup_cmd_content = [] setup_cmd = None if cppflags: cxxflags.extend(cppflags) if cflags: compileflags.extend(cflags) if lflags: linkflags.extend(lflags) extra_cflags = platform_info.get_target_cflags(target) if extra_cflags: compileflags.extend(extra_cflags) if toolset_str == 'gcc': using_line = "using %s : %s : %s" % ( toolset_str, toolset_version_str, toolset.get_compiler_command()) if toolset.is_mingw(): if self._sys_info.is_linux(): # mingw on linux is always a prefixed compiler and it does not figure out the path to windres by default. compiler_dir = os.path.dirname( toolset.get_compiler_command()) windres = os.path.join( compiler_dir, toolset.get_compiler_prefix() + '-windres') rc.append(windres) elif toolset_str == 'clang': if platform_info.get_target_os() in ['android', 'linux']: using_line = "using %s : %s : %s" % ( toolset_str, toolset_version_str, toolset.get_compiler_command()) elif platform_info.get_target_os() in [ 'macosx', 'iphone', 'iphonesimulator' ]: using_line = "using %s : : %s" % ( toolset_str, toolset.get_compiler_command()) isysroot = platform_info.get_isysroot() assert isysroot is not None compileflags.extend(['-isysroot', isysroot]) if platform_info.get_target_os() == 'macosx': # Add 3rd party native frameworks folder compileflags.append('-F/Library/Frameworks') linkflags.append('-F/Library/Frameworks') else: arch_flags = None if platform_info.get_target_os() == 'iphone': if target in ['armv7', 'arm64']: arch_flags = ['-arch', target] elif target == 'combined': arch_flags = ['-arch', 'armv7', '-arch', 'arm64'] else: assert False elif platform_info.get_target_os() == 'iphonesimulator': if target == 'x86_64': # Assume -arch x86_64 is the default pass elif target == 'x86': arch_flags = ['-arch', 'i386'] elif target == 'combined': arch_flags = ['-arch', 'x86_64', '-arch', 'i386'] else: assert False else: assert False if arch_flags: compileflags.extend(arch_flags) linkflags.extend(arch_flags) else: assert False elif toolset_str == 'intel': if self._sys_info.is_linux() or self._sys_info.is_macosx(): using_line = "using %s : %s : %s" % ( toolset_str, toolset_version_str, toolset.get_compiler_command()) elif self._sys_info.is_windows(): compiler_cmd = os.path.normpath(toolset.get_compiler_command()) compiler_cmd_escaped = compiler_cmd.replace("\\", "\\\\") assert msvc_rt is not None re_match = re.match(r'msvc-(\d+\.\d+)$', msvc_rt) if re_match: msvc_version_str = re_match.group(1) else: assert False using_line = 'using %s : %s : "%s" :' % ( toolset_str, toolset_version_str, compiler_cmd_escaped) #using_line += ' <rewrite-setup-scripts>off' using_line += ' <compatibility>vc' + msvc_version_str else: assert False elif toolset_str == 'msvc': if toolset_version_str in ['14.0']: msvc_registry = bldtools.MsvcRegistry() if msvc_registry.is_vs2017_toolset( ver.version_tuple_from_str(toolset_version_str)): # target ... setup_cmd = os.path.normpath( os.path.join(self._sys_info.get_home_dir(), 'setup_vs2017_vc140.bat')) # replace single backslashes with double backslashes setup_cmd_escaped = setup_cmd.replace("\\", "\\\\") using_line = 'using %s : %s : : <setup>"%s"' % ( toolset_str, toolset_version_str, setup_cmd_escaped) using_line += ' <rewrite-setup-scripts>off' # call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Auxiliary\Build\vcvarsall.bat" amd64 -vcvars_ver=14.0 if target == 'x86_64': setup_cmd_target = 'amd64' elif target == 'x86': setup_cmd_target = 'amd64_x86' else: assert False setup_cmd_content.append( 'call "%s" %s -vcvars_ver=14.0' % (toolset.get_compiler_command(), setup_cmd_target)) if cxxflags or compileflags or linkflags or rc: assert using_line is not None using_line += " :" if cxxflags: using_line += ' <cxxflags>"%s"' % ' '.join(cxxflags) if compileflags: using_line += ' <compileflags>"%s"' % ' '.join(compileflags) if linkflags: using_line += ' <linkflags>"%s"' % ' '.join(linkflags) if rc: using_line += ' <rc>"%s"' % ' '.join(rc) if using_line: lines.append(using_line + " ;") if build_boost_python: python_config_file = os.path.join(self._sys_info.get_home_dir(), 'user-config-python.jam') if os.path.exists(python_config_file): with open(python_config_file) as f: for line in f: lines.append(line.rstrip()) else: python_version = self._sys_info.get_python_version() if platform_info.get_target_os() == 'windows': python_executable_short_path = self._sys_info.get_short_path_win( self._sys_info.get_python_executable()) python_executable_cstring = python_executable_short_path.replace( "\\", "\\\\") lines.append('using python : %d.%d : "%s" ;' % (python_version[0], python_version[1], python_executable_cstring)) elif platform_info.get_target_os() == 'macosx': lines.append('using python : %d.%d : %s ;' % (python_version[0], python_version[1], self._sys_info.get_python_executable())) elif platform_info.get_target_os() == 'linux': lines.append('using python : %d.%d : %s ;' % (python_version[0], python_version[1], self._sys_info.get_python_executable())) if build_boost_mpi: mpi_config_file = os.path.join(self._sys_info.get_home_dir(), 'user-config-mpi.jam') if os.path.exists(mpi_config_file): with open(mpi_config_file) as f: for line in f: lines.append(line.rstrip()) else: lines.append("using mpi ;") return lines, setup_cmd, setup_cmd_content
def _compose_bjam_arg_list(self, bjam_prog, toolset, build_params, target_arch): platform_info = toolset.get_platform_info(build_params.platform_index) if platform_info.get_target_os() == 'android': is_android = True else: is_android = False cflags_list = [] cxxflags_list = [] linkflags_list = [] bjam_common_args = [bjam_prog] if build_params.bjam_jobs > 1: bjam_common_args.append('-j' + str(build_params.bjam_jobs)) if build_params.debug_configuration: bjam_common_args.append('--debug-configuration') bjam_common_args.append('--layout=versioned') bjam_common_args.append('--prefix=tmp/dist') #if toolset.get_toolset() == 'clang': # if ver.version_compare(toolset.get_version(), (3, 2) ) >= 0: # cxxflags_list.append('-ftemplate-depth=256') if platform_info.get_target_os() in [ 'macosx', 'iphone', 'iphonesimulator' ]: if build_params.max_install_names: # macosx specific flag to help the install_name_tool linkflags_list.append('-headerpad_max_install_names') if build_params.macosx_version_min: version_str = ver.version_tuple_to_str( build_params.macosx_version_min) else: version_str = None target_os_ver = platform_info.get_target_os_version() if platform_info.get_target_os() == 'macosx': # deployment target cannot be larger than the macosx SDK version. if ver.version_compare( target_os_ver, self._sys_info.get_os_version()) < 0: version_str = ver.version_tuple_to_str(target_os_ver) else: # a version hint is required for all portable platforms. version_str = ver.version_tuple_to_str(target_os_ver) if version_str: if platform_info.get_target_os() == 'macosx': cflags_list.append('-mmacosx-version-min=' + version_str) linkflags_list.append('-mmacosx-version-min=' + version_str) elif platform_info.get_target_os() == 'iphone': cflags_list.append('-miphoneos-version-min=' + version_str) linkflags_list.append('-miphoneos-version-min=' + version_str) elif platform_info.get_target_os() == 'iphonesimulator': cflags_list.append('-mios-simulator-version-min=' + version_str) linkflags_list.append('-mios-simulator-version-min=' + version_str) else: assert False if toolset.get_toolset() == 'clang': # For backward compatibility the user may have overridden the default c++ runtime on macosx which is only # sensible in c++03 mode. # On linux libc++ overrides the default c++ runtime. if self._sys_info.is_linux() and build_params.cxx_runtime in [ 'libc++' ]: cxxflags_list.append('-stdlib=' + build_params.cxx_runtime) linkflags_list.append('-stdlib=' + build_params.cxx_runtime) elif self._sys_info.is_macosx() and build_params.cxx_runtime in [ 'libstdc++' ]: cxxflags_list.append('-stdlib=' + build_params.cxx_runtime) linkflags_list.append('-stdlib=' + build_params.cxx_runtime) if toolset.is_mingw(): if build_params.cxx_runtime == 'shared': linkflags_list.append('-shared-libstdc++') linkflags_list.append('-shared-libgcc') elif build_params.cxx_runtime == 'static': linkflags_list.append('-static-libstdc++') linkflags_list.append('-static-libgcc') bjam_common_args.append('variant=release,debug') if is_android: bjam_common_args.append('link=static') elif platform_info.get_target_os() in ['iphone', 'iphonesimulator']: bjam_common_args.append('link=static') else: if (toolset.get_toolset() == 'msvc') and (build_params.cxx_runtime == 'static'): # Experimental feature to build the static boost libraries with dependency on the static MSVC runtime. bjam_common_args.append('link=static') bjam_common_args.append('runtime-link=static') else: bjam_common_args.append('link=static,shared') bjam_common_args.append('install') if build_params.boost_with_list: boost_with_list = list(build_params.boost_with_list) else: boost_with_list = [] bjam_arg_list = [] bjam_arg_list.extend(bjam_common_args) if toolset.get_toolset() == 'msvc': # On windows msvc-x.y selects the VS compiler. bjam_arg_list.append('toolset=' + toolset.get_toolset_versioned()) else: bjam_arg_list.append('toolset=' + toolset.get_toolset()) boost_lib_dir = self.get_boost_lib_dir(build_params.boost_dir, toolset, build_params.platform_index, target_arch) boost_lib_dir = os.path.relpath(boost_lib_dir, build_params.boost_dir) bjam_arg_list.append('--libdir=' + boost_lib_dir) if is_android: # The NDK cross compilers generate position independent code by default, some do -fpic and others -fPIC. bjam_arg_list.append('target-os=android') elif self._sys_info.is_linux(): if toolset.get_toolset() == 'gcc': if toolset.is_mingw(): if ver.version_compare(self.get_boost_version(), (1, 66, 0)) >= 0: # Boost 1.66.0 and higher if target_arch == 'x86_64': bjam_arg_list.append('address-model=64') elif target_arch == 'x86': bjam_arg_list.append('address-model=32') bjam_arg_list.append('target-os=windows') bjam_arg_list.append('threadapi=win32') elif platform_info.get_target_arch(0) in ['arm', 'aarch64']: # is this really supported by every arm compiler? cflags_list.append('-fPIC') else: cflags_list.append('-fPIC') assert self._sys_info.get_os_arch() == target_arch elif toolset.get_toolset() == 'clang': cflags_list.append('-fPIC') elif toolset.get_toolset() == 'intel': cflags_list.append('-fPIC') else: assert False elif self._sys_info.is_windows(): if ver.version_compare(self.get_boost_version(), (1, 66, 0)) >= 0: # Boost 1.66.0 and higher if target_arch == 'x86_64': bjam_arg_list.append('address-model=64') elif target_arch == 'x86': bjam_arg_list.append('address-model=32') else: if toolset.is_mingw(): if (target_arch == 'x86') and ( target_arch != platform_info.get_target_arch(0)): bjam_arg_list.append('address-model=32') elif toolset.get_toolset() == 'msvc': # Assume this compiler is a msvc-x.y variant. if target_arch == 'x86_64': bjam_arg_list.append('address-model=64') elif self._sys_info.is_macosx(): # target-os=iphonesimulator is undefined in Boost.Build inside the BOOST SDK tree. # target-os=iphone does not define dylib as the shared library suffix inside the BOOST SDK tree. #if platform_info.get_target_os() == 'iphone': # bjam_arg_list.append('target-os=' + platform_info.get_target_os()) pass else: assert False if build_params.cxx_std is not None: re_std = re.compile(r'c\+\+(\d+)$') re_match = re_std.match(build_params.cxx_std) if not re_match: raise Exception("C++ standard specification " + build_params.cxx_std + " is not supported.") if toolset.get_toolset() in ['gcc', 'clang', 'intel']: if ver.version_compare(self._boost_version, (1, 66, 0)) >= 0: bjam_arg_list.append('cxxstd=' + re_match.group(1)) else: cxxflags_list.append('-std=' + build_params.cxx_std) build_boost_python = False if build_params.build_python: build_boost_python = self._is_boost_python_enabled( toolset, build_params.platform_index, target_arch) if boost_with_list: for item in boost_with_list: bjam_arg_list.append('--with-' + item) else: # add --without-xxx arguments which cannot be combined with --with-xxx if toolset.is_mingw(): bjam_arg_list.append('--without-locale') if not build_boost_python: bjam_arg_list.append('--without-python') if not build_params.build_mpi: bjam_arg_list.append('--without-mpi') if build_params.custom_user_config: user_config_content = [] setup_cmd_file = None setup_cmd_content = [] else: (user_config_content, setup_cmd_file, setup_cmd_content) = self._create_user_config_content( toolset, build_params.platform_index, target_arch, build_params.build_mpi, build_boost_python, cppflags=cxxflags_list, cflags=cflags_list, lflags=linkflags_list, msvc_rt=build_params.msvc_rt) return bjam_arg_list, user_config_content, setup_cmd_file, setup_cmd_content