def make(self, target=None, args=None):
make_program = self._conanfile.conf.get(
"tools.gnu:make_program",
default="mingw32-make" if self._use_win_mingw() else "make")
str_args = self._make_args
str_extra_args = " ".join(args) if args is not None else ""
jobs = ""
if "-j" not in str_args and "nmake" not in make_program.lower():
njobs = build_jobs(self._conanfile)
if njobs:
jobs = "-j{}".format(njobs)
command = join_arguments(
[make_program, target, str_args, str_extra_args, jobs])
self._conanfile.run(command)
def make(self, args="", make_program=None, target=None, vars=None):
if not self._conanfile.should_build:
return
make_program = os.getenv(
"CONAN_MAKE_PROGRAM") or make_program or "make"
with environment_append(vars or self.vars):
str_args = args_to_string(args)
cpu_count_option = (("-j%s" %
cpu_count(output=self._conanfile.output))
if "-j" not in str_args else None)
self._conanfile.run("%s" % join_arguments(
[make_program, target, str_args, cpu_count_option]),
win_bash=self._win_bash,
subsystem=self.subsystem)
def command_line(self):
if self.generator_platform and not is_generator_platform_supported(
self.generator):
raise ConanException(
'CMake does not support generator platform with generator '
'"%s:. Please check your conan profile to either remove the '
'generator platform, or change the CMake generator.' %
self.generator)
if self.toolset and not is_toolset_supported(self.generator):
raise ConanException(
'CMake does not support toolsets with generator "%s:.'
'Please check your conan profile to either remove the toolset,'
' or change the CMake generator.' % self.generator)
generator = self.generator
generator_platform = self.generator_platform
if self.generator_platform and 'Visual Studio' in generator:
# FIXME: Conan 2.0 We are adding the platform to the generator instead of using
# the -A argument to keep previous implementation, but any modern CMake will support
# (and recommend) passing the platform in its own argument.
# Get the version from the generator, as it could have been defined by user argument
compiler_version = re.search("Visual Studio ([0-9]*)",
generator).group(1)
if Version(compiler_version) < "16" and self._settings.get_safe(
"os") != "WindowsCE":
if self.generator_platform == "x64":
generator += " Win64" if not generator.endswith(
" Win64") else ""
generator_platform = None
elif self.generator_platform == "ARM":
generator += " ARM" if not generator.endswith(
" ARM") else ""
generator_platform = None
elif self.generator_platform == "Win32":
generator_platform = None
args = ['-G "{}"'.format(generator)] if generator else []
if generator_platform:
args.append('-A "{}"'.format(generator_platform))
args.append(self.flags)
args.append('-Wno-dev')
if self.toolset:
args.append('-T "%s"' % self.toolset)
return join_arguments(args)
def build(self, args=None, build_dir=None, targets=None):
if not self._conanfile.should_build:
return
if self.backend != "ninja":
raise ConanException("Build only supported with 'ninja' backend")
args = args or []
build_dir = build_dir or self.build_dir or self._conanfile.build_folder
arg_list = join_arguments([
'-C "%s"' % build_dir,
args_to_string(args),
args_to_string(targets)
])
self._run("ninja %s" % arg_list)
def configure(self,
args=None,
defs=None,
source_dir=None,
build_dir=None,
pkg_config_paths=None,
cache_build_folder=None,
build_folder=None,
source_folder=None):
if not self._conanfile.should_configure:
return
args = args or []
defs = defs or {}
# overwrite default values with user's inputs
self.options.update(defs)
source_dir, self.build_dir = self._get_dirs(source_folder,
build_folder, source_dir,
build_dir,
cache_build_folder)
if pkg_config_paths:
pc_paths = os.pathsep.join(
get_abs_path(f, self._conanfile.install_folder)
for f in pkg_config_paths)
else:
pc_paths = self._conanfile.install_folder
mkdir(self.build_dir)
bt = {
"RelWithDebInfo": "debugoptimized",
"MinSizeRel": "release",
"Debug": "debug",
"Release": "release"
}.get(str(self.build_type), "")
build_type = "--buildtype=%s" % bt
arg_list = join_arguments([
"--backend=%s" % self.backend, self.flags,
args_to_string(args), build_type
])
command = 'meson "%s" "%s" %s' % (source_dir, self.build_dir, arg_list)
with environment_append({"PKG_CONFIG_PATH": pc_paths}):
self._run(command)
def configure(self, args=None, defs=None, source_dir=None, build_dir=None,
source_folder=None, build_folder=None, cache_build_folder=None,
pkg_config_paths=None):
# TODO: Deprecate source_dir and build_dir in favor of xxx_folder
if not self._conanfile.should_configure:
return
args = args or []
defs = defs or {}
source_dir, self.build_dir = self._get_dirs(source_folder, build_folder,
source_dir, build_dir,
cache_build_folder)
mkdir(self.build_dir)
arg_list = join_arguments([
self.command_line,
args_to_string(args),
defs_to_string(defs),
args_to_string([source_dir])
])
if pkg_config_paths:
pkg_env = {"PKG_CONFIG_PATH":
os.pathsep.join(get_abs_path(f, self._conanfile.install_folder)
for f in pkg_config_paths)}
else:
# If we are using pkg_config generator automate the pcs location, otherwise it could
# read wrong files
set_env = "pkg_config" in self._conanfile.generators \
and "PKG_CONFIG_PATH" not in os.environ
pkg_env = {"PKG_CONFIG_PATH": self._conanfile.install_folder} if set_env else None
with environment_append(pkg_env):
command = "cd %s && %s %s" % (args_to_string([self.build_dir]), self._cmake_program,
arg_list)
if platform.system() == "Windows" and self.generator == "MinGW Makefiles":
with tools.remove_from_path("sh"):
self._run(command)
else:
self._run(command)
def command_line(self):
args = ['-G "%s"' % self.generator] if self.generator else []
if self.generator_platform:
if is_generator_platform_supported(self.generator):
args.append('-A "%s"' % self.generator_platform)
else:
raise ConanException(
'CMake does not support generator platform with generator '
'"%s:. Please check your conan profile to either remove the '
'generator platform, or change the CMake generator.' %
self.generator)
args.append(self.flags)
args.append('-Wno-dev')
if self.toolset:
if is_toolset_supported(self.generator):
args.append('-T "%s"' % self.toolset)
else:
raise ConanException(
'CMake does not support toolsets with generator "%s:.'
'Please check your conan profile to either remove the toolset,'
' or change the CMake generator.' % self.generator)
return join_arguments(args)
def _build(self, args=None, build_dir=None, target=None):
args = args or []
build_dir = build_dir or self.build_dir or self._conanfile.build_folder
if target is not None:
args = ["--target", target] + args
if self.generator and self.parallel:
if ("Makefiles" in self.generator or "Ninja" in self.generator) and \
"NMake" not in self.generator:
if "--" not in args:
args.append("--")
args.append("-j%i" % cpu_count(self._conanfile.output))
elif "Visual Studio" in self.generator:
compiler_version = re.search("Visual Studio ([0-9]*)",
self.generator).group(1)
if Version(compiler_version) >= "10":
if "--" not in args:
args.append("--")
# Parallel for building projects in the solution
args.append("/m:%i" %
cpu_count(output=self._conanfile.output))
if self.generator and self.msbuild_verbosity:
if "Visual Studio" in self.generator:
compiler_version = re.search("Visual Studio ([0-9]*)",
self.generator).group(1)
if Version(compiler_version) >= "10":
if "--" not in args:
args.append("--")
args.append("/verbosity:%s" % self.msbuild_verbosity)
arg_list = join_arguments([
args_to_string([build_dir]), self.build_config,
args_to_string(args)
])
command = "%s --build %s" % (self._cmake_program, arg_list)
self._run(command)
def _build(self, build_type=None, target=None):
bf = self._conanfile.build_folder
if self._build_folder:
bf = os.path.join(self._conanfile.build_folder, self._build_folder)
if build_type and not self._is_multiconfiguration:
self._conanfile.output.error(
"Don't specify 'build_type' at build time for "
"single-config build systems")
bt = build_type or self._conanfile.settings.get_safe("build_type")
if not bt:
conan_v2_behavior("build_type setting should be defined.",
v1_behavior=self._conanfile.output.warn)
if bt and self._is_multiconfiguration:
build_config = "--config %s" % bt
else:
build_config = ""
args = []
if target is not None:
args = ["--target", target]
build_flags = _compute_build_flags(self._conanfile, self._generator,
self._parallel,
self._msbuild_verbosity)
if build_flags:
args += ['--'] + build_flags
arg_list = [args_to_string([bf]), build_config, args_to_string(args)]
command = "%s --build %s" % (self._cmake_program,
join_arguments(arg_list))
self._conanfile.output.info("CMake command: %s" % command)
self._conanfile.run(command)
