def test_aix(self):
with mock.patch("platform.machine", mock.MagicMock(return_value='00FB91F44C00')),\
mock.patch("platform.processor", mock.MagicMock(return_value='powerpc')),\
mock.patch("platform.system", mock.MagicMock(return_value='AIX')),\
mock.patch("conans.client.tools.oss.OSInfo.get_aix_conf", mock.MagicMock(return_value='32')),\
mock.patch('subprocess.check_output', mock.MagicMock(return_value='7.1.0.0')):
self.assertEqual('ppc32', detected_architecture())
with mock.patch("platform.machine", mock.MagicMock(return_value='00FB91F44C00')),\
mock.patch("platform.processor", mock.MagicMock(return_value='powerpc')),\
mock.patch("platform.system", mock.MagicMock(return_value='AIX')),\
mock.patch("conans.client.tools.oss.OSInfo.get_aix_conf", mock.MagicMock(return_value='64')),\
mock.patch('subprocess.check_output', mock.MagicMock(return_value='7.1.0.0')):
self.assertEqual('ppc64', detected_architecture())
def test_solaris(self):
with mock.patch("platform.machine", mock.MagicMock(return_value='sun4v')),\
mock.patch("platform.processor", mock.MagicMock(return_value='sparc')),\
mock.patch("platform.system", mock.MagicMock(return_value='SunOS')),\
mock.patch("platform.architecture", mock.MagicMock(return_value=('64bit', 'ELF'))),\
mock.patch("platform.release", mock.MagicMock(return_value='5.11')):
self.assertEqual('sparcv9', detected_architecture())
with mock.patch("platform.machine", mock.MagicMock(return_value='i86pc')),\
mock.patch("platform.processor", mock.MagicMock(return_value='i386')),\
mock.patch("platform.system", mock.MagicMock(return_value='SunOS')),\
mock.patch("platform.architecture", mock.MagicMock(return_value=('64bit', 'ELF'))),\
mock.patch("platform.release", mock.MagicMock(return_value='5.11')):
self.assertEqual('x86_64', detected_architecture())
def test_various(self, mocked_machine, expected_arch):
with mock.patch("platform.machine",
mock.MagicMock(return_value=mocked_machine)):
self.assertEqual(
expected_arch, detected_architecture(),
"given '%s' expected '%s'" % (mocked_machine, expected_arch))
def _get_host_build_target_flags(self):
"""Based on google search for build/host triplets, it could need a lot
and complex verification"""
arch_detected = detected_architecture() or platform.machine()
os_detected = detected_os() or platform.system()
if self._os_target and self._arch_target:
try:
target = get_gnu_triplet(self._os_target, self._arch_target,
self._compiler)
except ConanException as exc:
self._conanfile.output.warn(str(exc))
target = None
else:
target = None
if os_detected is None or arch_detected is None or self._arch is None or self._os is None:
return False, False, target
if not cross_building(self._conanfile.settings, os_detected,
arch_detected):
return False, False, target
try:
build = get_gnu_triplet(os_detected, arch_detected, self._compiler)
except ConanException as exc:
self._conanfile.output.warn(str(exc))
build = None
try:
host = get_gnu_triplet(self._os, self._arch, self._compiler)
except ConanException as exc:
self._conanfile.output.warn(str(exc))
host = None
return build, host, target
def _get_build_os_arch(self):
if hasattr(self._conanfile, 'settings_build'):
os_build, arch_build = get_build_os_arch(self._conanfile)
else:
# FIXME: Why not use 'os_build' and 'arch_build' from conanfile.settings?
os_build = detected_os() or platform.system()
arch_build = detected_architecture() or platform.machine()
return arch_build, os_build
def vcvars_command(settings,
arch=None,
compiler_version=None,
force=False,
vcvars_ver=None,
winsdk_version=None,
output=None):
output = default_output(output, 'conans.client.tools.win.vcvars_command')
arch_setting = arch or settings.get_safe("arch")
compiler = settings.get_safe("compiler")
if compiler == 'Visual Studio':
compiler_version = compiler_version or settings.get_safe(
"compiler.version")
else:
# vcvars might be still needed for other compilers, e.g. clang-cl or Intel C++,
# as they might be using Microsoft STL and other tools
# (e.g. resource compiler, manifest tool, etc)
# in this case, use the latest Visual Studio available on the machine
last_version = latest_vs_version_installed(output=output)
compiler_version = compiler_version or last_version
os_setting = settings.get_safe("os")
if not compiler_version:
raise ConanException(
"compiler.version setting required for vcvars not defined")
# https://msdn.microsoft.com/en-us/library/f2ccy3wt.aspx
arch_setting = arch_setting or 'x86_64'
arch_build = settings.get_safe("arch_build") or detected_architecture()
if arch_build == 'x86_64':
# Only uses x64 tooling if arch_build explicitly defines it, otherwise
# Keep the VS default, which is x86 toolset
# This will probably be changed in conan 2.0
if ((settings.get_safe("arch_build")
or os.getenv("PreferredToolArchitecture") == "x64")
and int(compiler_version) >= 12):
x86_cross = "amd64_x86"
else:
x86_cross = "x86"
vcvars_arch = {
'x86': x86_cross,
'x86_64': 'amd64',
'armv7': 'amd64_arm',
'armv8': 'amd64_arm64'
}.get(arch_setting)
elif arch_build == 'x86':
vcvars_arch = {
'x86': 'x86',
'x86_64': 'x86_amd64',
'armv7': 'x86_arm',
'armv8': 'x86_arm64'
}.get(arch_setting)
if not vcvars_arch:
raise ConanException('unsupported architecture %s' % arch_setting)
existing_version = os.environ.get("VisualStudioVersion")
if existing_version:
command = ["echo Conan:vcvars already set"]
existing_version = existing_version.split(".")[0]
if existing_version != compiler_version:
message = "Visual environment already set to %s\n " \
"Current settings visual version: %s" % (existing_version, compiler_version)
if not force:
raise ConanException("Error, %s" % message)
else:
output.warn(message)
else:
vs_path = vs_installation_path(str(compiler_version))
if not vs_path or not os.path.isdir(vs_path):
raise ConanException(
"VS non-existing installation: Visual Studio %s" %
str(compiler_version))
else:
if int(compiler_version) > 14:
vcvars_path = os.path.join(vs_path,
"VC/Auxiliary/Build/vcvarsall.bat")
command = [
'set "VSCMD_START_DIR=%%CD%%" && '
'call "%s" %s' % (vcvars_path, vcvars_arch)
]
else:
vcvars_path = os.path.join(vs_path, "VC/vcvarsall.bat")
command = ['call "%s" %s' % (vcvars_path, vcvars_arch)]
if int(compiler_version) >= 14:
if winsdk_version:
command.append(winsdk_version)
if vcvars_ver:
command.append("-vcvars_ver=%s" % vcvars_ver)
if os_setting == 'WindowsStore':
os_version_setting = settings.get_safe("os.version")
if os_version_setting == '8.1':
command.append('store 8.1')
elif os_version_setting == '10.0':
windows_10_sdk = find_windows_10_sdk()
if not windows_10_sdk:
raise ConanException(
"cross-compiling for WindowsStore 10 (UWP), "
"but Windows 10 SDK wasn't found")
command.append('store %s' % windows_10_sdk)
else:
raise ConanException('unsupported Windows Store version %s' %
os_version_setting)
return " ".join(command)
def vcvars_command(settings, arch=None, compiler_version=None, force=False):
arch_setting = arch or settings.get_safe("arch")
compiler_version = compiler_version or settings.get_safe("compiler.version")
os_setting = settings.get_safe("os")
if not compiler_version:
raise ConanException("compiler.version setting required for vcvars not defined")
# https://msdn.microsoft.com/en-us/library/f2ccy3wt.aspx
arch_setting = arch_setting or 'x86_64'
if detected_architecture() == 'x86_64':
vcvars_arch = {'x86': 'x86',
'x86_64': 'amd64',
'armv7': 'amd64_arm',
'armv8': 'amd64_arm64'}.get(arch_setting)
elif detected_architecture() == 'x86':
vcvars_arch = {'x86': 'x86',
'x86_64': 'x86_amd64',
'armv7': 'x86_arm',
'armv8': 'x86_arm64'}.get(arch_setting)
if not vcvars_arch:
raise ConanException('unsupported architecture %s' % arch_setting)
command = ""
existing_version = os.environ.get("VisualStudioVersion")
if existing_version:
command = "echo Conan:vcvars already set"
existing_version = existing_version.split(".")[0]
if existing_version != compiler_version:
message = "Visual environment already set to %s\n " \
"Current settings visual version: %s" % (existing_version, compiler_version)
if not force:
raise ConanException("Error, %s" % message)
else:
_global_output.warn(message)
else:
vs_path = vs_installation_path(str(compiler_version))
if not vs_path or not os.path.isdir(vs_path):
_global_output.warn("VS non-existing installation")
else:
vcvars_path = ""
if int(compiler_version) > 14:
vcvars_path = os.path.join(vs_path, "VC/Auxiliary/Build/vcvarsall.bat")
command = ('set "VSCMD_START_DIR=%%CD%%" && '
'call "%s" %s' % (vcvars_path, vcvars_arch))
else:
vcvars_path = os.path.join(vs_path, "VC/vcvarsall.bat")
command = ('call "%s" %s' % (vcvars_path, vcvars_arch))
if os_setting == 'WindowsStore':
os_version_setting = settings.get_safe("os.version")
if os_version_setting == '8.1':
command += ' store 8.1'
elif os_version_setting == '10.0':
windows_10_sdk = find_windows_10_sdk()
if not windows_10_sdk:
raise ConanException("cross-compiling for WindowsStore 10 (UWP), "
"but Windows 10 SDK wasn't found")
command += ' store ' + windows_10_sdk
else:
raise ConanException('unsupported Windows Store version %s' % os_version_setting)
return command
def vcvars_command(conanfile=None,
arch=None,
compiler_version=None,
force=False,
vcvars_ver=None,
winsdk_version=None,
output=None,
settings=None):
# Handle input arguments (backwards compatibility with 'settings' as first argument)
# TODO: This can be promoted to a decorator pattern for any function
if conanfile and settings:
raise ConanException(
"Do not set both arguments, 'conanfile' and 'settings',"
" to call 'vcvars_command' function")
from conans.model.conan_file import ConanFile
if conanfile and not isinstance(conanfile, ConanFile):
return vcvars_command(settings=conanfile,
arch=arch,
compiler_version=compiler_version,
force=force,
vcvars_ver=vcvars_ver,
winsdk_version=winsdk_version,
output=output)
if settings:
warnings.warn(
"argument 'settings' has been deprecated, use 'conanfile' instead")
if not conanfile:
# TODO: If Conan is using 'profile_build' here we don't have any information about it,
# we are falling back to the old behavior (which is probably wrong here)
conanfile = namedtuple('_ConanFile', ['settings'])(settings)
del settings
# Here starts the actual implementation for this function
output = default_output(output, 'conans.client.tools.win.vcvars_command')
arch_setting = arch or conanfile.settings.get_safe("arch")
compiler = conanfile.settings.get_safe("compiler")
compiler_base = conanfile.settings.get_safe("compiler.base")
if compiler == 'Visual Studio':
compiler_version = compiler_version or conanfile.settings.get_safe(
"compiler.version")
elif compiler_base == "Visual Studio":
compiler_version = compiler_version or conanfile.settings.get_safe(
"compiler.base.version")
else:
# vcvars might be still needed for other compilers, e.g. clang-cl or Intel C++,
# as they might be using Microsoft STL and other tools
# (e.g. resource compiler, manifest tool, etc)
# in this case, use the latest Visual Studio available on the machine
last_version = latest_vs_version_installed(output=output)
compiler_version = compiler_version or last_version
os_setting = conanfile.settings.get_safe("os")
if not compiler_version:
raise ConanException(
"compiler.version setting required for vcvars not defined")
# https://msdn.microsoft.com/en-us/library/f2ccy3wt.aspx
vcvars_arch = None
arch_setting = arch_setting or 'x86_64'
_, settings_arch_build = get_build_os_arch(conanfile)
arch_build = settings_arch_build
if not hasattr(conanfile, 'settings_build'):
arch_build = arch_build or detected_architecture()
if os_setting == 'WindowsCE':
vcvars_arch = "x86"
elif arch_build == 'x86_64':
# Only uses x64 tooling if arch_build explicitly defines it, otherwise
# Keep the VS default, which is x86 toolset
# This will probably be changed in conan 2.0
if ((settings_arch_build
or os.getenv("PreferredToolArchitecture") == "x64")
and int(compiler_version) >= 12):
x86_cross = "amd64_x86"
else:
x86_cross = "x86"
vcvars_arch = {
'x86': x86_cross,
'x86_64': 'amd64',
'armv7': 'amd64_arm',
'armv8': 'amd64_arm64'
}.get(arch_setting)
elif arch_build == 'x86':
vcvars_arch = {
'x86': 'x86',
'x86_64': 'x86_amd64',
'armv7': 'x86_arm',
'armv8': 'x86_arm64'
}.get(arch_setting)
if not vcvars_arch:
raise ConanException('unsupported architecture %s' % arch_setting)
existing_version = os.environ.get("VisualStudioVersion")
if existing_version:
command = ["echo Conan:vcvars already set"]
existing_version = existing_version.split(".")[0]
if existing_version != compiler_version:
message = "Visual environment already set to %s\n " \
"Current settings visual version: %s" % (existing_version, compiler_version)
if not force:
raise ConanException("Error, %s" % message)
else:
output.warn(message)
else:
vs_path = vs_installation_path(str(compiler_version))
if not vs_path or not os.path.isdir(vs_path):
raise ConanException(
"VS non-existing installation: Visual Studio %s" %
str(compiler_version))
else:
if int(compiler_version) > 14:
vcvars_path = os.path.join(vs_path,
"VC/Auxiliary/Build/vcvarsall.bat")
command = [
'set "VSCMD_START_DIR=%%CD%%" && '
'call "%s" %s' % (vcvars_path, vcvars_arch)
]
else:
vcvars_path = os.path.join(vs_path, "VC/vcvarsall.bat")
command = ['call "%s" %s' % (vcvars_path, vcvars_arch)]
if int(compiler_version) >= 14:
if winsdk_version:
command.append(winsdk_version)
if vcvars_ver:
command.append("-vcvars_ver=%s" % vcvars_ver)
if os_setting == 'WindowsStore':
os_version_setting = conanfile.settings.get_safe("os.version")
if os_version_setting == '8.1':
winsdk_version = winsdk_version or "8.1"
command.append('store %s' % winsdk_version)
elif os_version_setting == '10.0':
winsdk_version = winsdk_version or find_windows_10_sdk()
if not winsdk_version:
raise ConanException(
"cross-compiling for WindowsStore 10 (UWP), "
"but Windows 10 SDK wasn't found")
command.append('store %s' % winsdk_version)
else:
raise ConanException('unsupported Windows Store version %s' %
os_version_setting)
return " ".join(command)
def vcvars_command(settings, arch=None, compiler_version=None, force=False):
arch_setting = arch or settings.get_safe("arch")
compiler_version = compiler_version or settings.get_safe("compiler.version")
os_setting = settings.get_safe("os")
if not compiler_version:
raise ConanException("compiler.version setting required for vcvars not defined")
# https://msdn.microsoft.com/en-us/library/f2ccy3wt.aspx
arch_setting = arch_setting or 'x86_64'
if detected_architecture() == 'x86_64':
vcvars_arch = {'x86': 'x86',
'x86_64': 'amd64',
'armv7': 'amd64_arm',
'armv8': 'amd64_arm64'}.get(arch_setting)
elif detected_architecture() == 'x86':
vcvars_arch = {'x86': 'x86',
'x86_64': 'x86_amd64',
'armv7': 'x86_arm',
'armv8': 'x86_arm64'}.get(arch_setting)
if not vcvars_arch:
raise ConanException('unsupported architecture %s' % arch_setting)
existing_version = os.environ.get("VisualStudioVersion")
if existing_version:
command = "echo Conan:vcvars already set"
existing_version = existing_version.split(".")[0]
if existing_version != compiler_version:
message = "Visual environment already set to %s\n " \
"Current settings visual version: %s" % (existing_version, compiler_version)
if not force:
raise ConanException("Error, %s" % message)
else:
_global_output.warn(message)
else:
env_var = "vs%s0comntools" % compiler_version
if env_var == 'vs150comntools':
vs_path = os.getenv(env_var)
if not vs_path: # Try to locate with vswhere
vs_root = vs_installation_path("15")
if vs_root:
vs_path = os.path.join(vs_root, "Common7", "Tools")
else:
raise ConanException("VS2017 '%s' variable not defined, "
"and vswhere didn't find it" % env_var)
if not os.path.isdir(vs_path):
_global_output.warn('VS variable %s points to the non-existing path "%s",'
'please check that you have set it correctly' % (env_var, vs_path))
vcvars_path = os.path.join(vs_path, "../../VC/Auxiliary/Build/vcvarsall.bat")
command = ('set "VSCMD_START_DIR=%%CD%%" && '
'call "%s" %s' % (vcvars_path, vcvars_arch))
else:
try:
vs_path = os.environ[env_var]
except KeyError:
raise ConanException("VS '%s' variable not defined. Please install VS" % env_var)
if not os.path.isdir(vs_path):
_global_output.warn('VS variable %s points to the non-existing path "%s",'
'please check that you have set it correctly' % (env_var, vs_path))
vcvars_path = os.path.join(vs_path, "../../VC/vcvarsall.bat")
command = ('call "%s" %s' % (vcvars_path, vcvars_arch))
if os_setting == 'WindowsStore':
os_version_setting = settings.get_safe("os.version")
if os_version_setting == '8.1':
command += ' store 8.1'
elif os_version_setting == '10.0':
windows_10_sdk = find_windows_10_sdk()
if not windows_10_sdk:
raise ConanException("cross-compiling for WindowsStore 10 (UWP), "
"but Windows 10 SDK wasn't found")
command += ' store ' + windows_10_sdk
else:
raise ConanException('unsupported Windows Store version %s' % os_version_setting)
return command
def test_e2k(self, processor, expected_arch):
with mock.patch("platform.machine", mock.MagicMock(return_value='e2k')), \
mock.patch("platform.processor", mock.MagicMock(return_value=processor)):
self.assertEqual(expected_arch, detected_architecture())
def vcvars_command(settings, arch=None, compiler_version=None, force=False):
arch_setting = arch or settings.get_safe("arch")
compiler_version = compiler_version or settings.get_safe("compiler.version")
os_setting = settings.get_safe("os")
if not compiler_version:
raise ConanException("compiler.version setting required for vcvars not defined")
# https://msdn.microsoft.com/en-us/library/f2ccy3wt.aspx
arch_setting = arch_setting or 'x86_64'
if detected_architecture() == 'x86_64':
vcvars_arch = {'x86': 'x86',
'x86_64': 'amd64',
'armv7': 'amd64_arm',
'armv8': 'amd64_arm64'}.get(arch_setting)
elif detected_architecture() == 'x86':
vcvars_arch = {'x86': 'x86',
'x86_64': 'x86_amd64',
'armv7': 'x86_arm',
'armv8': 'x86_arm64'}.get(arch_setting)
if not vcvars_arch:
raise ConanException('unsupported architecture %s' % arch_setting)
command = ""
existing_version = os.environ.get("VisualStudioVersion")
if existing_version:
command = "echo Conan:vcvars already set"
existing_version = existing_version.split(".")[0]
if existing_version != compiler_version:
message = "Visual environment already set to %s\n " \
"Current settings visual version: %s" % (existing_version, compiler_version)
if not force:
raise ConanException("Error, %s" % message)
else:
_global_output.warn(message)
else:
vs_path = vs_installation_path(str(compiler_version))
if not vs_path or not os.path.isdir(vs_path):
raise ConanException("VS non-existing installation: Visual Studio %s" % str(compiler_version))
else:
vcvars_path = ""
if int(compiler_version) > 14:
vcvars_path = os.path.join(vs_path, "VC/Auxiliary/Build/vcvarsall.bat")
command = ('set "VSCMD_START_DIR=%%CD%%" && '
'call "%s" %s' % (vcvars_path, vcvars_arch))
else:
vcvars_path = os.path.join(vs_path, "VC/vcvarsall.bat")
command = ('call "%s" %s' % (vcvars_path, vcvars_arch))
if os_setting == 'WindowsStore':
os_version_setting = settings.get_safe("os.version")
if os_version_setting == '8.1':
command += ' store 8.1'
elif os_version_setting == '10.0':
windows_10_sdk = find_windows_10_sdk()
if not windows_10_sdk:
raise ConanException("cross-compiling for WindowsStore 10 (UWP), "
"but Windows 10 SDK wasn't found")
command += ' store ' + windows_10_sdk
else:
raise ConanException('unsupported Windows Store version %s' % os_version_setting)
return command
def test_toolchain_linux(self, build_type, arch, cppstd, libcxx, shared,
fpic):
settings_mock = _MockSettings(build_type, arch, cppstd, libcxx)
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.options = {"shared": [True, False], "fPIC": [True, False]}
conanfile.default_options = {"shared": shared, "fPIC": fpic}
conanfile.initialize(settings_mock, EnvValues())
toolchain = MakeToolchain(conanfile)
content = toolchain.content
expected_template = Template(
textwrap.dedent("""
# Conan generated toolchain file
ifndef CONAN_TOOLCHAIN_INCLUDED
CONAN_TOOLCHAIN_INCLUDED = TRUE
CONAN_TC_BUILD_TYPE = {{build_type}}
CONAN_TC_OS_HOST = None
CONAN_TC_ARCH_HOST = {{arch_host}}
CONAN_TC_TRIPLET_HOST = False
CONAN_TC_OS_BUILD = Linux
CONAN_TC_ARCH_BUILD = {{arch_build}}
CONAN_TC_TRIPLET_BUILD = False
CONAN_TC_OS_TARGET = None
CONAN_TC_ARCH_TARGET = None
CONAN_TC_TRIPLET_TARGET = None
CONAN_TC_COMPILER = {{compiler}}
CONAN_TC_COMPILER_VERSION = {{compiler_version}}
CONAN_TC_COMPILER_RUNTIME = None
CONAN_TC_LIBCXX = {{libcxx}}
CONAN_TC_CPPSTD_FLAG = {{cppstd_flag}}
CONAN_TC_ARCH_FLAG = {{arch_flag}}
CONAN_TC_BUILD_TYPE_FLAGS = {{build_type_flags}}
CONAN_TC_DEFINES ={{preserved_space}}
CONAN_TC_SET_LIBCXX = True
CONAN_TC_SET_CPPSTD = True
CONAN_TC_SET_ARCH = True
CONAN_TC_SET_FPIC = {{set_fpic}}
CONAN_TC_SET_SHARED = {{set_shared}}
CONAN_TC_CFLAGS += $(CONAN_TC_BUILD_TYPE_FLAGS)
CONAN_TC_CXXFLAGS += $(CONAN_TC_BUILD_TYPE_FLAGS)
ifeq ($(CONAN_TC_BUILD_TYPE),Release)
CONAN_TC_DEFINES += NDEBUG
endif
ifeq ($(CONAN_TC_SET_LIBCXX),True)
CONAN_TC_CLANG_BASED := $(if $(filter $(CONAN_TC_COMPILER),clang apple-clang),true)
ifeq ($(CONAN_TC_CLANG_BASED),True)
CONAN_TC_LIBSTDCXX_BASED := $(if $(filter $(CONAN_TC_LIBCXX),libstdc++ libstdc++11),true)
ifeq ($(CONAN_TC_LIBSTDCXX_BASED),True)
CONAN_TC_CXXFLAGS += -stdlib=libstdc++
else ifeq ($(CONAN_TC_LIBCXX),libc++)
CONAN_TC_CXXFLAGS += -stdlib=libc++
endif
else ifeq ($(CONAN_TC_COMPILER),sun-cc)
ifeq ($(CONAN_TC_LIBCXX),libCstd)
CONAN_TC_CXXFLAGS += -library=Cstd++
else ifeq ($(CONAN_TC_LIBCXX),libstdcxx)
CONAN_TC_CXXFLAGS += -library=stdcxx4
else ifeq ($(CONAN_TC_LIBCXX),libstlport)
CONAN_TC_CXXFLAGS += -library=stlport4
else ifeq ($(CONAN_TC_LIBCXX),libstdc++)
CONAN_TC_CXXFLAGS += -library=stdcpp
endif
endif
ifeq ($(CONAN_TC_LIBCXX),libstdc++11)
CONAN_TC_DEFINES += GLIBCXX_USE_CXX11_ABI=1
else ifeq ($(CONAN_TC_LIBCXX),libstdc++)
CONAN_TC_DEFINES += GLIBCXX_USE_CXX11_ABI=0
endif
endif
ifeq ($(CONAN_TC_SET_CPPSTD),True)
CONAN_TC_CXXFLAGS += $(CONAN_TC_CPPSTD_FLAG)
endif
ifeq ($(CONAN_TC_SET_ARCH),True)
CONAN_TC_CFLAGS += $(CONAN_TC_ARCH_FLAG)
CONAN_TC_CXXFLAGS += $(CONAN_TC_ARCH_FLAG)
CONAN_TC_SHARED_LINKER_FLAGS += $(CONAN_TC_ARCH_FLAG)
CONAN_TC_EXE_LINKER_FLAGS += $(CONAN_TC_ARCH_FLAG)
endif
ifeq ($(CONAN_TC_SET_FPIC),True)
CONAN_TC_CFLAGS += -fPIC
CONAN_TC_CXXFLAGS += -fPIC
CONAN_TC_SHARED_LINKER_FLAGS += -fPIC
CONAN_TC_EXE_LINKER_FLAGS += -pie
endif
ifeq ($(CONAN_TC_SET_SHARED),True)
CONAN_TC_LDFLAGS += -shared
CONAN_TC_LDFLAGS += $(CONAN_TC_SHARED_LINKER_FLAGS)
else
CONAN_TC_LDFLAGS += $(CONAN_TC_EXE_LINKER_FLAGS)
endif
endif
CONAN_TC_CPPFLAGS += $(addprefix -D,$(CONAN_TC_DEFINES))
# Call this function in your Makefile to have Conan variables added to the standard variables
# Example: $(call CONAN_TC_SETUP)
CONAN_TC_SETUP = \\
$(eval CFLAGS += $(CONAN_TC_CFLAGS)) ; \\
$(eval CXXFLAGS += $(CONAN_TC_CXXFLAGS)) ; \\
$(eval CPPFLAGS += $(CONAN_TC_CPPFLAGS)) ; \\
$(eval LDFLAGS += $(CONAN_TC_LDFLAGS)) ;
"""))
context = {
"arch_host": conanfile.settings.get_safe("arch"),
"arch_build": detected_architecture(),
"compiler": conanfile.settings.get_safe("compiler"),
"compiler_version":
conanfile.settings.get_safe("compiler.version"),
"arch_flag": architecture_flag(settings_mock),
"cppstd_flag": cppstd_flag_new(conanfile.settings),
"build_type_flags": " ".join(build_type_flags(conanfile.settings)),
"build_type": build_type,
"libcxx": libcxx,
"set_shared": shared,
"set_fpic": fpic,
"preserved_space": " ",
}
#
expected_content = expected_template.render(context)
self.maxDiff = None
self.assertIn(expected_content, content)
def test_various(self):
# x86
with mock.patch("platform.machine",
mock.MagicMock(return_value='i386')):
self.assertEqual('x86', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='i686')):
self.assertEqual('x86', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='x86_64')):
self.assertEqual('x86_64', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='amd64')):
self.assertEqual('x86_64', detected_architecture())
# ARM
with mock.patch("platform.machine",
mock.MagicMock(return_value='aarch64_be')):
self.assertEqual('armv8', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='armv8b')):
self.assertEqual('armv8', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='armv7l')):
self.assertEqual('armv7', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='armv6l')):
self.assertEqual('armv6', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='arm')):
self.assertEqual('armv6', detected_architecture())
# PowerPC
with mock.patch("platform.machine",
mock.MagicMock(return_value='ppc64le')):
self.assertEqual('ppc64le', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='ppc64')):
self.assertEqual('ppc64', detected_architecture())
# MIPS
with mock.patch("platform.machine",
mock.MagicMock(return_value='mips')):
self.assertEqual('mips', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='mips64')):
self.assertEqual('mips64', detected_architecture())
# SPARC
with mock.patch("platform.machine",
mock.MagicMock(return_value='sparc')):
self.assertEqual('sparc', detected_architecture())
with mock.patch("platform.machine",
mock.MagicMock(return_value='sparc64')):
self.assertEqual('sparcv9', detected_architecture())