def get_libraries(self):
if oshelper.os_is_mac():
# FIXME find proper way to detect this
return ['Python']
env = scons.Environment()
flags = env.ParseFlags(
distutils.sysconfig.get_config_var('BLDLIBRARY'))
return flags['LIBS']
def NaClEnvironment(use_c_plus_plus_libs=False,
nacl_platform=None,
toolchain_arch=None,
toolchain_variant=None,
use_ppapi=True,
install_subdir=None,
lib_prefix=None):
'''Make an Environment that uses the NaCl toolchain to build sources.
This modifies a default construction Environment to point the compilers and
other bintools at the NaCl-specific versions, adds some tools that set certain
build flags needed by the NaCl-specific tools, and adds a custom Builder that
generates .nmf files.
Args:
use_c_plus_plus_libs: Indicate whether to insert the C++ NaCl libs at the
right place in the list of LIBS.
nacl_platform: The target NaCl/Chrome/Papper platform for which the
environment, e.g. 'pepper_14'.
toolchain_arch: The target architecture of the toolchain (e.g., x86, pnacl)
toolchain_variant: The libc of the toolchain (e.g., newlib, glibc)
use_ppapi: flag indicating whether to compile again ppapi libraries
install_subdir: subdirectory within the NACL_INSTALL_ROOT for this project.
lib_prefix: an optional list of path components to prepend to the library
path. These components are joined with appropriate path separators
Examples: ['..', '..'], ['..', 'peer_directory'].
Returns:
A SCons Environment with all the various Tool and keywords set to build
NaCl modules.
'''
def GetCommandLineOption(option_name, option_value, option_default):
'''Small helper function to get a command line option.
Returns a command-line option value, which can be overridden. If the
option is set on the command line, then that value is favoured over the
internally set value. If option is neither set on the command line nor
given a value, its default is used.
Args:
option_name: The name of the command line option, e.g. "variant".
option_value: The initial value of the option. This value is used if the
its not set via the command line. Can be None.
option_default: If the option value hasn't been set via the command line
nor via an internal value, then this default value is used. Can be
None.
Returns:
The value of the command-line option, according to the override rules
described above.
'''
cmd_line_value = Script.GetOption(option_name)
if not cmd_line_value and not option_value:
cmd_line_value = option_default
return cmd_line_value or option_value
nacl_utils.AddCommandLineOptions()
env = Script.Environment()
# We must have a nacl_platform, either as argument to this function or from
# the command line. However, if we're cleaning we can relax this requirement.
# (And our build bots will be much happier that way.)
nacl_platform_from_option = Script.GetOption('nacl_platform')
if not nacl_platform_from_option and not nacl_platform:
if Script.GetOption('clean'):
nacl_platform_from_option = '.'
else:
raise ValueError('NaCl platform not specified')
# Setup the base dir for tools, etc. Favor the nacl platform specified on
# the command line if there's a conflict.
nacl_platform_to_use = nacl_platform_from_option or nacl_platform
toolchain_variant = GetCommandLineOption(
'variant', toolchain_variant, nacl_utils.DEFAULT_TOOLCHAIN_VARIANT)
toolchain_arch = GetCommandLineOption('architecture', toolchain_arch,
nacl_utils.DEFAULT_TOOLCHAIN_ARCH)
base_dir = os.getenv('NACL_SDK_ROOT', '')
base_dir = os.path.join(base_dir, nacl_platform_to_use)
toolchain = nacl_utils.ToolchainPath(base_dir=base_dir,
arch=toolchain_arch,
variant=toolchain_variant)
if (toolchain is None):
raise ValueError('Cannot find a NaCl toolchain')
tool_bin_path = os.path.join(toolchain, 'bin')
tool_runtime_path = os.path.join(toolchain, 'runtime')
staging_dir = os.path.abspath(
os.getenv('NACL_INSTALL_ROOT',
os.path.join(os.getenv('NACL_SDK_ROOT', '.'), 'staging')))
if install_subdir:
staging_dir = os.path.join(staging_dir, install_subdir)
lib_prefix = lib_prefix or []
if type(lib_prefix) is not list:
# Break path down into list of directory components
lib_prefix = filter(lambda x: x, lib_prefix.split('/'))
# Invoke the various *nix tools that the NativeClient SDK resembles. This
# is done so that SCons doesn't try to invoke cl.exe on Windows in the
# Object builder.
env.Tool('g++')
env.Tool('gcc')
env.Tool('gnulink')
env.Tool('ar')
env.Tool('as')
env.Tool('nacl_tools')
# TODO(dspringer): Figure out how to make this dynamic and then compute it
# based on the desired target arch.
env.Replace(
tools=['nacl_tools'],
# Replace the normal unix tools with the NaCl ones. Note the
# use of the NACL_ARCHITECTURE prefix for the tools. This
# Environment variable is set in nacl_tools.py; it has no
# default value.
CC=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}gcc'),
CXX=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}g++'),
AR=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}ar'),
AS=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}as'),
GDB=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}gdb'),
# NOTE: use g++ for linking so we can handle C AND C++.
LINK=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}g++'),
LD=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}ld'),
STRIP=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}strip'),
NACL_SEL_LDR32=os.path.join(tool_bin_path, 'sel_ldr_x86_32'),
NACL_IRT_CORE32=os.path.join(tool_runtime_path,
'irt_core_x86_32.nexe'),
NACL_SEL_LDR64=os.path.join(tool_bin_path, 'sel_ldr_x86_64'),
NACL_IRT_CORE64=os.path.join(tool_runtime_path,
'irt_core_x86_64.nexe'),
RANLIB=os.path.join(tool_bin_path, '${NACL_ARCHITECTURE}ranlib'),
ASFLAGS=[
'${EXTRA_ASFLAGS}',
],
# c specific
EXTRA_CFLAGS=[],
CFLAGS=[
'${EXTRA_CFLAGS}',
'-std=gnu99',
],
# c++ specific
EXTRA_CXXFLAGS=[],
CXXFLAGS=[
'${EXTRA_CXXFLAGS}',
'-std=gnu++98',
'-Wno-long-long',
],
# Both C and C++
CCFLAGS=[
'${EXTRA_CCFLAGS}',
'-Wall',
'-Wswitch-enum',
'-pthread',
],
CPPDEFINES=[ # _GNU_SOURCE ensures that strtof() gets declared.
('_GNU_SOURCE', 1),
# This ensures that PRId64 etc. get defined.
('__STDC_FORMAT_MACROS', '1'),
# strdup, and other common stuff
('_BSD_SOURCE', '1'),
('_POSIX_C_SOURCE', '199506'),
('_XOPEN_SOURCE', '600'),
],
CPPPATH=[],
LINKFLAGS=[
'${EXTRA_LINKFLAGS}',
],
# The NaCl environment makes '.nexe' executables. If this is
# not explicitly set, then SCons on Windows doesn't understand
# how to construct a Program builder properly.
PROGSUFFIX='.nexe',
# Target NaCl platform info.
TARGET_NACL_PLATFORM=nacl_platform_to_use,
NACL_TOOLCHAIN_VARIANT=toolchain_variant,
NACL_TOOLCHAIN_ROOT=toolchain,
NACL_INSTALL_ROOT=staging_dir,
NACL_LIB_PREFIX=lib_prefix,
)
# This supresses the "MS_DOS style path" warnings on Windows. It's benign on
# all other platforms.
env['ENV']['CYGWIN'] = 'nodosfilewarning'
# Append the common NaCl libs.
if use_ppapi:
common_nacl_libs = ['ppapi']
if use_c_plus_plus_libs:
common_nacl_libs.extend(['ppapi_cpp'])
env.Append(LIBS=common_nacl_libs)
gen_nmf_builder = env.Builder(suffix='.nmf', action=nacl_utils.GenerateNmf)
env.Append(BUILDERS={'GenerateNmf': gen_nmf_builder})
return env
def __init__(self, target, machine, build, toolchain, available_features=[]):
self.available_features = available_features
self.host_platform = self.detect_platform()
self.host_machine = self.detect_machine()
self.flags = {}
if target is None:
target = self.host_platform
if machine is None:
machine = self.host_machine
if toolchain is None:
if self.host_platform == 'windows':
raise Exception(
'must specify toolchain on Windows (msvs or gnu)')
else:
toolchain = 'gnu'
if build is None:
build = 'debug'
if not build in ['debug', 'release']:
raise Exception("invalid build type")
if target not in ['windows', 'osx', 'linux', 'bsd']:
raise Exception("invalid target platform")
if machine.lower() not in ['x86_64', 'x86', 'i686', 'i586',
'alpha', 'hppa', 'mips', 'mipsel', 's390',
'sparc', 'ia64', 'armel', 'armhf', 'hurd-i386',
'sh3', 'sh4',
'kfreebsd-amd64', 'kfreebsd-i386',
'i486', 'i386', 'ppc', 'ppc64', 'powerpc',
'powerpc64', 'powerpcspe', 's390x',
'amd64', 'em64t', 'intel64', 'arm64',
'ppc64el']:
raise Exception("invalid machine type")
if toolchain not in ['gnu', 'msvs']:
raise Exception('invalid toolchain type')
if toolchain == 'msvs' and self.host_platform != 'windows':
raise Exception(
'cannot use msvs toolchain on non-windows platform')
self.platform = target
self.platform_is_posix = self.platform in ['linux', 'osx', 'bsd']
self.platform_is_linux = self.platform == 'linux'
self.platform_is_osx = self.platform == 'osx'
self.platform_is_bsd = self.platform == 'bsd'
self.platform_is_windows = self.platform == 'windows'
self.machine = machine
self.build = build
self.build_is_debug = build == 'debug'
self.build_is_release = build == 'release'
self.toolchain = toolchain
self.toolchain_is_gnu = self.toolchain == 'gnu'
self.toolchain_is_msvs = self.toolchain == 'msvs'
self.crosscompile = self.host_platform != self.platform
flags_force32 = int(Script.ARGUMENTS.get('force32', 0))
flags_force64 = int(Script.ARGUMENTS.get('force64', 0))
if flags_force32 and flags_force64:
logging.error('Both force32 and force64 cannot be enabled at once')
Script.Exit(1)
if flags_force32:
if self.machine in ['powerpc', 'powerpc64', 'ppc', 'ppc64']:
self.machine = 'powerpc'
else:
self.machine = 'x86'
elif flags_force64:
if self.machine in ['powerpc', 'powerpc64', 'ppc', 'ppc64']:
self.machine = 'powerpc64'
else:
self.machine = 'x86_64'
self.machine_is_64bit = self.machine.lower(
) in ['x86_64', 'powerpc64', 'ppc64', 'amd64', 'em64t', 'intel64']
self.bitwidth = 64 if self.machine_is_64bit else 32
self.architecture_is_x86 = self.machine.lower(
) in ['x86', 'x86_64', 'i386', 'i486', 'i586', 'i686', 'em64t',
'intel64', 'amd64']
self.architecture_is_powerpc = self.machine.lower(
) in ['powerpc', 'powerpc64', 'ppc', 'ppc64']
self.architecture_is_arm = self.machine.lower().startswith('arm')
self.build_dir = util.get_build_dir(self.platform, self.bitwidth)
# Currently this only works for Windows
self.static_dependencies = int(Script.ARGUMENTS.get('staticlibs', 0))
logging.info("Target Platform: %s" % self.platform)
logging.info("Target Machine: %s" % self.machine)
logging.info("Build: %s" % self.build)
logging.info("Toolchain: %s" % self.toolchain)
logging.info(
"Crosscompile: %s" % ("YES" if self.crosscompile else "NO"))
if self.platform_is_windows:
logging.info("Static dependencies: %s" % (
"YES" if self.static_dependencies else "NO"))
if self.crosscompile:
logging.info("Host Platform: %s" % self.host_platform)
logging.info("Host Machine: %s" % self.host_machine)
if self.crosscompile and self.host_platform != 'linux':
raise Exception(
'Cross-compiling on a non-Linux host not currently supported')
tools = ['default']
toolpath = ['#build/']
extra_arguments = {}
import depends
if int(Script.ARGUMENTS.get('qt5', 0)):
tools.append('qt5')
if self.machine_is_64bit:
default_qtdir = depends.Qt.DEFAULT_QT5DIRS64.get(
self.platform, '')
else:
default_qtdir = depends.Qt.DEFAULT_QT5DIRS32.get(
self.platform, '')
else:
tools.append('qt4')
default_qtdir = depends.Qt.DEFAULT_QT4DIRS.get(self.platform, '')
tools.append('protoc')
# Ugly hack to check the qtdir argument
qtdir = Script.ARGUMENTS.get('qtdir',
os.environ.get('QTDIR', default_qtdir))
# Validate the specified qtdir exists
if not os.path.exists(qtdir):
logging.error("QT path does not exist or QT4 is not installed.")
logging.error(
"Please specify your QT path by running 'scons qtdir=[path]'")
Script.Exit(1)
# And that it doesn't contain qt3
elif qtdir.find("qt3") != -1 or qtdir.find("qt/3") != -1:
logging.error("Mixxx now requires QT4 instead of QT3 - please use your QT4 path with the qtdir build flag.")
Script.Exit(1)
logging.info("Qt path: %s" % qtdir)
# Previously this wasn't done for OSX, but I'm not sure why
# -- rryan 6/8/2011
extra_arguments['QTDIR'] = qtdir
if self.platform_is_osx:
tools.append('OSConsX')
toolpath.append('#/build/osx/')
if self.platform_is_windows and self.toolchain_is_msvs:
# NOTE(rryan): Don't use the SCons mssdk tool since it does not
# support x64.
# In SConscript.env we use the MSVS tool to let you generate a
# Visual Studio solution. Consider removing this.
tools.extend(['msvs'])
# SCons's built-in Qt tool attempts to link 'qt' into your binary if
# you don't do this.
extra_arguments['QT_LIB'] = ''
# Causes SCons to bypass MSVC environment detection altogether
# and depend on environment variables.
# TODO(rryan): Expose SCons MSVC auto-detection options.
extra_arguments['MSVC_USE_SCRIPT'] = None
# Setup the appropriate toolchains for cross-compiling
if self.crosscompile:
if self.platform_is_windows:
tools.append('crossmingw')
if self.platform_is_osx:
tools.append('crossosx')
self.env = Script.Environment(
tools=tools, toolpath=toolpath, ENV=os.environ,
**extra_arguments)
self.read_environment_variables()
# Now that environment variables have been read, we can detect the compiler.
self.compiler_is_gcc = 'gcc' in self.env['CC']
self.compiler_is_clang = 'clang' in self.env['CC']
self.virtualize_build_dir()
if self.toolchain_is_gnu:
if flags_force32:
self.env.Append(CCFLAGS='-m32')
elif flags_force64:
self.env.Append(CCFLAGS='-m64')
self.setup_platform_sdk()
if self.platform_is_osx:
if self.architecture_is_powerpc:
self.env.Append(CCFLAGS='-arch ppc')
self.env.Append(LINKFLAGS='-arch ppc')
else:
if self.bitwidth == 32:
self.env.Append(CCFLAGS='-arch i386')
self.env.Append(LINKFLAGS='-arch i386')
elif self.bitwidth == 64:
self.env.Append(CCFLAGS='-arch x86_64')
self.env.Append(LINKFLAGS='-arch x86_64')
if self.crosscompile:
crosscompile_root = Script.ARGUMENTS.get('crosscompile_root', '')
if crosscompile_root == '':
print "Your build setup indicates this is a cross-compile, but you did not specify 'crosscompile_root', which is required."
Script.Exit(1)
crosscompile_root = os.path.abspath(crosscompile_root)
self.env.Append(CPPPATH=os.path.join(crosscompile_root, 'include'))
self.env.Append(LIBPATH=os.path.join(crosscompile_root, 'lib'))
self.env.Append(LIBPATH=os.path.join(crosscompile_root, 'bin'))
self.install_options()
def __init__(self, target, machine, build, toolchain, available_features):
self.available_features = available_features
self.host_platform = self.detect_platform()
self.host_machine = self.detect_machine()
self.flags = {}
if target is None:
target = self.host_platform
if machine is None:
machine = self.host_machine
if toolchain is None:
if self.host_platform == 'windows':
raise Exception(
'must specify toolchain on Windows (msvs or gnu)')
else:
toolchain = 'gnu'
if build is None:
build = 'debug'
if not build in ['debug', 'release']:
raise Exception("invalid build type")
if target not in ['windows', 'osx', 'linux', 'bsd']:
raise Exception("invalid target platform")
if machine.lower() not in [
'x86_64', 'x86', 'i686', 'i586', 'alpha', 'hppa', 's390',
'sparc', 'ia64', 'armel', 'armhf', 'hurd-i386', 'armv5tel',
'armv5tejl', 'armv6l', 'armv6hl', 'armv7l', 'armv7hl',
'armv7hnl', 'sh3', 'sh4', 'kfreebsd-amd64', 'kfreebsd-i386',
'i486', 'i386', 'ppc', 'ppc64', 'powerpc', 'powerpc64',
'powerpcspe', 's390x', 'amd64', 'em64t', 'intel64', 'arm64',
'ppc64el', 'ppc64le', 'm68k', 'mips', 'mipsel', 'mipsr6',
'mipsr6el', 'mips64', 'mips64r6', 'mips64el', 'mips64r6el',
'mipsn32', 'mipsn32el', 'mipsn32r6', 'mipsn32r6el',
'mipsisa32r6', 'mipsisa32r6el', 'mipsisa64r6', 'mipsisa64r6el',
'aarch64'
]:
raise Exception("invalid machine type")
if toolchain not in ['gnu', 'msvs']:
raise Exception('invalid toolchain type')
if toolchain == 'msvs' and self.host_platform != 'windows':
raise Exception(
'cannot use msvs toolchain on non-windows platform')
self.platform = target
self.platform_is_posix = self.platform in ['linux', 'osx', 'bsd']
self.platform_is_linux = self.platform == 'linux'
self.platform_is_osx = self.platform == 'osx'
self.platform_is_bsd = self.platform == 'bsd'
self.platform_is_windows = self.platform == 'windows'
self.machine = machine
self.build = build
self.build_is_debug = build == 'debug'
self.build_is_release = build == 'release'
self.toolchain = toolchain
self.toolchain_is_gnu = self.toolchain == 'gnu'
self.toolchain_is_msvs = self.toolchain == 'msvs'
self.crosscompile = self.host_platform != self.platform
flags_force32 = int(Script.ARGUMENTS.get('force32', 0))
flags_force64 = int(Script.ARGUMENTS.get('force64', 0))
if flags_force32 and flags_force64:
logging.error('Both force32 and force64 cannot be enabled at once')
Script.Exit(1)
if flags_force32:
if self.machine in ['powerpc', 'powerpc64', 'ppc', 'ppc64']:
self.machine = 'powerpc'
else:
self.machine = 'x86'
elif flags_force64:
if self.machine in ['powerpc', 'powerpc64', 'ppc', 'ppc64']:
self.machine = 'powerpc64'
else:
self.machine = 'x86_64'
self.machine_is_64bit = self.machine.lower() in [
'x86_64', 'powerpc64', 'ppc64', 'amd64', 'em64t', 'intel64'
]
self.bitwidth = 64 if self.machine_is_64bit else 32
self.architecture_is_x86 = self.machine.lower() in [
'x86', 'x86_64', 'i386', 'i486', 'i586', 'i686', 'em64t',
'intel64', 'amd64'
]
self.architecture_is_powerpc = self.machine.lower() in [
'powerpc', 'powerpc64', 'ppc', 'ppc64'
]
self.architecture_is_arm = self.machine.lower().startswith('arm')
self.build_dir = util.get_build_dir(self.platform, self.bitwidth)
# Currently this only works for Windows
self.static_dependencies = int(Script.ARGUMENTS.get('staticlibs', 0))
self.static_qt = int(Script.ARGUMENTS.get('staticqt', 0))
self.bundle_pdbs = self.platform_is_windows and (
self.build_is_debug
or Script.ARGUMENTS.get('bundle_pdbs', '') in ('yes', 'y', '1'))
self.scons_version = ('unknown'
if SCons.__version__.startswith('__VERSION') else
'%s (%s, %s)' % (
SCons.__version__,
SCons.__build__,
SCons.__date__,
))
logging.info("SCons version: %s" % self.scons_version)
logging.info("Python version: %s" % sys.version.replace('\n', ''))
logging.info("Target Platform: %s" % self.platform)
logging.info("Target Machine: %s" % self.machine)
logging.info("Build: %s" % self.build)
logging.info("Toolchain: %s" % self.toolchain)
logging.info("Crosscompile: %s" %
("YES" if self.crosscompile else "NO"))
if self.platform_is_windows:
self.winlib_path = Script.ARGUMENTS.get('winlib', '')
logging.info("Winlib Path: %s" % self.winlib_path)
logging.info("Static dependencies: %s" %
("YES" if self.static_dependencies else "NO"))
logging.info("Static Qt: %s" % ("YES" if self.static_qt else "NO"))
if self.crosscompile:
logging.info("Host Platform: %s" % self.host_platform)
logging.info("Host Machine: %s" % self.host_machine)
if self.crosscompile and self.host_platform != 'linux':
raise Exception(
'Cross-compiling on a non-Linux host not currently supported')
tools = ['default', 'qt5', 'protoc']
toolpath = ['#build/']
extra_arguments = {}
from . import depends
if self.machine_is_64bit:
default_qtdir = depends.Qt.DEFAULT_QT5DIRS64.get(self.platform, '')
else:
default_qtdir = depends.Qt.DEFAULT_QT5DIRS32.get(self.platform, '')
# Try fallback to pkg-config on Linux
if not os.path.isdir(default_qtdir) and self.platform == 'linux':
pkg_config_cmd = ['pkg-config', '--variable=includedir', 'Qt5Core']
try:
output = subprocess.check_output(pkg_config_cmd)
except OSError:
# pkg-config is not installed
pass
except subprocess.CalledProcessError:
# pkg-config failed to find Qt5Core
pass
else:
default_qtdir = output.decode('utf-8').rstrip()
# Ugly hack to check the qtdir argument
qtdir = Script.ARGUMENTS.get('qtdir',
os.environ.get('QTDIR',
default_qtdir)).rstrip()
# Validate the specified qtdir exists
if not os.path.isdir(qtdir):
logging.error(
"Qt path (%s) does not exist or Qt is not installed." % qtdir)
logging.error(
"Please specify your Qt path by running 'scons qtdir=[path]'")
Script.Exit(1)
# And that it doesn't contain qt3 or qt4
elif 'qt3' in qtdir or 'qt/3' in qtdir or 'qt4' in qtdir:
logging.error(
"Mixxx now requires Qt 5. Please set the qtdir build flag to the path to your Qt 5 installation."
)
Script.Exit(1)
logging.info("Qt path: %s" % qtdir)
extra_arguments['QTDIR'] = qtdir
if self.platform_is_osx:
tools.append('OSConsX')
toolpath.append('#/build/osx/')
if self.platform_is_windows and self.toolchain_is_msvs:
# NOTE(rryan): Don't use the SCons mssdk tool since it does not
# support x64.
# In SConscript.env we use the MSVS tool to let you generate a
# Visual Studio solution. Consider removing this.
tools.extend(['msvs', 'signtool'])
toolpath.append('#/build/windows/')
# SCons's built-in Qt tool attempts to link 'qt' into your binary if
# you don't do this.
extra_arguments['QT_LIB'] = ''
# Causes SCons to bypass MSVC environment detection altogether
# and depend on environment variables.
# TODO(rryan): Expose SCons MSVC auto-detection options.
extra_arguments['MSVC_USE_SCRIPT'] = None
# Setup the appropriate toolchains for cross-compiling
if self.crosscompile:
if self.platform_is_windows:
tools.append('crossmingw')
if self.platform_is_osx:
tools.append('crossosx')
self.env = Script.Environment(tools=tools,
toolpath=toolpath,
ENV=os.environ,
**extra_arguments)
self.read_environment_variables()
# Now that environment variables have been read, we can detect the compiler.
if self.toolchain_is_msvs:
self.compiler_is_gcc = False
self.compiler_is_clang = False
else:
cc_version_cmd = shlex.split(self.env['CC']) + ['--version']
cc_version = subprocess.check_output(cc_version_cmd).decode(
'utf-8')
self.compiler_is_gcc = 'gcc' in cc_version.lower()
self.compiler_is_clang = 'clang' in cc_version.lower()
# Determine the major compiler version (only GCC)
if self.compiler_is_gcc:
self.gcc_major_version = None
gcc_version_cmd = shlex.split(
self.env['CC']) + ['-dumpversion']
gcc_version = subprocess.check_output(gcc_version_cmd).decode(
'utf-8')
# If match is None we don't know the version.
if not gcc_version is None:
version_split = gcc_version.split('.')
if version_split:
self.gcc_major_version = int(version_split[0])
self.virtualize_build_dir()
if self.toolchain_is_gnu:
if flags_force32:
self.env.Append(CCFLAGS='-m32')
elif flags_force64:
self.env.Append(CCFLAGS='-m64')
self.setup_platform_sdk()
if self.platform_is_osx:
if self.architecture_is_powerpc:
self.env.Append(CCFLAGS='-arch ppc')
self.env.Append(LINKFLAGS='-arch ppc')
else:
if self.bitwidth == 32:
self.env.Append(CCFLAGS='-arch i386')
self.env.Append(LINKFLAGS='-arch i386')
elif self.bitwidth == 64:
self.env.Append(CCFLAGS='-arch x86_64')
self.env.Append(LINKFLAGS='-arch x86_64')
if self.crosscompile:
crosscompile_root = Script.ARGUMENTS.get('crosscompile_root', '')
if crosscompile_root == '':
print(
"Your build setup indicates this is a cross-compile, but you did not specify 'crosscompile_root', which is required."
)
Script.Exit(1)
crosscompile_root = os.path.abspath(crosscompile_root)
self.env.Append(CPPPATH=os.path.join(crosscompile_root, 'include'))
self.env.Append(LIBPATH=os.path.join(crosscompile_root, 'lib'))
self.env.Append(LIBPATH=os.path.join(crosscompile_root, 'bin'))
self.install_options()
def _build_environment():
result = scons.Environment(options=options)
result.Tool('subst', toolpath=[os.path.dirname(__file__) + '/tools'])
if 'icpc' in result['CXX']:
result.Append(CCFLAGS='-wd177,383,424,810,981,1418,1419,1572')
result.Append(LINKFLAGS='-static-intel')
if oshelper.os_is_windows():
if result.get('OPENSCENEGRAPH_DEBUG',
None): # FIXME move this elswhere
result.Append(
CXXFLAGS=
'/EHsc /W3 /MDd /wd4099 /wd4244 /wd4800 /wd4996 /wd4251 /wd4661'
) # FIXME remove deactivation of warnings
else:
result.Append(CXXFLAGS=[
'/EHsc', '/W3', '/MD', '/wd4099', '/wd4244', '/wd4800',
'/wd4996', '/wd4251', '/wd4661'
]) # FIXME remove deactivation of warnings
result.Append(CPPDEFINES=['AV_INSTANTIATE_FIELD_TEMPLATES'])
result.Append(CCFLAGS='/bigobj')
result.Append(LINKFLAGS=['/MANIFEST'])
result['SHLINKCOM'] = [
result['SHLINKCOM'],
'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;2'
]
else:
result.Append(CCFLAGS='-ansi -Wall')
if result['DEBUG']:
if oshelper.os_is_windows():
result.Append(CCFLAGS='/DEBUG /Zi /D_DEBUG /Ob0 /Od /RTC1')
else:
result.Append(CCFLAGS='-g')
else:
if not oshelper.os_is_windows():
result.Append(CCFLAGS='-O2 -DNDEBUG')
if result['CXX'] == 'g++':
result.Append(CCFLAGS='-fno-strict-aliasing')
if result['TRACE_LOGGING']:
result.Append(CPPDEFINES='TRACE_LOGGING')
if result['BUILD_32']:
#linux or mac
if not oshelper.os_is_windows():
result.Append(CCFLAGS='-m32')
result.Append(LINKFLAGS='-m32')
#windows
else:
result.Append(CPPDEFINES=['WIN32'])
else:
if oshelper.os_is_windows():
result.Append(CPPDEFINES=['WIN32'])
result.Append(LINKFLAGS='/MACHINE:X64')
result.PrependENVPath('PATH', result['BINARY_PATH'])
result.Prepend(CPPPATH=result['INCLUDE_PATH'].split(os.pathsep))
result.Prepend(LIBPATH=result['LIBRARY_PATH'].split(os.pathsep))
result.PrependENVPath(oshelper.get_library_search_path_env(),
result['LIBRARY_PATH'])
result.PrependENVPath('PYTHONPATH', result['PYTHON_PATH'])
result.PrependENVPath('PKG_CONFIG_PATH', result['PKG_CONFIG_PATH'])
os.environ['PKG_CONFIG_PATH'] = result['PKG_CONFIG_PATH']
return result
def __init__(self,
target,
machine,
build,
toolchain,
available_features=[]):
self.available_features = available_features
self.host_platform = self.detect_platform()
self.host_machine = self.detect_machine()
self.flags = {}
if target is None:
target = self.host_platform
if machine is None:
machine = self.host_machine
if toolchain is None:
if self.host_platform == 'windows':
raise Exception(
'must specify toolchain on Windows (msvs or gnu)')
else:
toolchain = 'gnu'
if build is None:
build = 'debug'
if not build in ['debug', 'release']:
raise Exception("invalid build type")
if target not in ['windows', 'osx', 'linux', 'bsd']:
raise Exception("invalid target platform")
if machine not in [
'x86_64', 'x86', 'i686', 'i586', 'alpha', 'hppa', 'mips',
'mipsel', 's390', 'sparc', 'ia64', 'armel', 'armhf',
'hurd-i386', 'sh3', 'sh4', 'kfreebsd-amd64', 'kfreebsd-i386',
'i486', 'i386', 'powerpc', 'powerpc64', 'powerpcspe', 's390x',
'amd64', 'AMD64', 'EM64T', 'INTEL64'
]:
raise Exception("invalid machine type")
if toolchain not in ['gnu', 'msvs']:
raise Exception('invalid toolchain type')
if toolchain == 'msvs' and self.host_platform != 'windows':
raise Exception(
'cannot use msvs toolchain on non-windows platform')
self.platform = target
self.platform_is_posix = self.platform in ['linux', 'osx', 'bsd']
self.platform_is_linux = self.platform == 'linux'
self.platform_is_osx = self.platform == 'osx'
self.platform_is_bsd = self.platform == 'bsd'
self.platform_is_windows = self.platform == 'windows'
self.machine = machine
self.build = build
self.build_is_debug = build == 'debug'
self.build_is_release = build == 'release'
self.toolchain = toolchain
self.toolchain_is_gnu = self.toolchain == 'gnu'
self.toolchain_is_msvs = self.toolchain == 'msvs'
self.crosscompile = self.host_platform != self.platform
flags_force32 = int(Script.ARGUMENTS.get('force32', 0))
flags_force64 = int(Script.ARGUMENTS.get('force64', 0))
if flags_force32 and flags_force64:
logging.error('Both force32 and force64 cannot be enabled at once')
Script.Exit(1)
if flags_force32:
if self.machine in ['powerpc', 'powerpc64']:
self.machine = 'powerpc'
else:
self.machine = 'x86'
elif flags_force64:
if self.machine in ['powerpc', 'powerpc64']:
self.machine = 'powerpc64'
else:
self.machine = 'x86_64'
self.machine_is_64bit = self.machine in [
'x86_64', 'powerpc64', 'AMD64', 'EM64T', 'INTEL64'
]
self.bitwidth = 64 if self.machine_is_64bit else 32
self.architecture_is_x86 = self.machine.lower() in [
'x86', 'x86_64', 'i386', 'i486', 'i586', 'i686', 'EM64T', 'INTEL64'
]
self.architecture_is_powerpc = self.machine.lower() in [
'powerpc', 'powerpc64'
]
self.build_dir = util.get_build_dir(self.platform, self.bitwidth)
# Currently this only works for Windows
self.static_dependencies = int(Script.ARGUMENTS.get('staticlibs', 0))
self.msvcdebug = int(Script.ARGUMENTS.get('msvcdebug', 0))
logging.info("Target Platform: %s" % self.platform)
logging.info("Target Machine: %s" % self.machine)
logging.info("Build: %s" % self.build)
logging.info("Toolchain: %s" % self.toolchain)
logging.info("Crosscompile: %s" %
("YES" if self.crosscompile else "NO"))
if self.platform_is_windows:
logging.info("Static dependencies: %s" %
("YES" if self.static_dependencies else "NO"))
logging.info("MSVC Debug build: %s" %
("YES" if self.msvcdebug else "NO"))
if self.crosscompile:
logging.info("Host Platform: %s" % self.host_platform)
logging.info("Host Machine: %s" % self.host_machine)
if self.crosscompile and self.host_platform != 'linux':
raise Exception(
'Cross-compiling on a non-Linux host not currently supported')
tools = ['default']
toolpath = ['#build/']
extra_arguments = {}
tools.append('qt4')
tools.append('protoc')
# Ugly hack to check the qtdir argument
import depends
default_qtdir = depends.Qt.DEFAULT_QTDIRS.get(self.platform, '')
qtdir = Script.ARGUMENTS.get('qtdir',
os.environ.get('QTDIR', default_qtdir))
# Validate the specified qtdir exists
if not os.path.exists(qtdir):
logging.error("QT path does not exist or QT4 is not installed.")
logging.error(
"Please specify your QT path by running 'scons qtdir=[path]'")
Script.Exit(1)
# And that it doesn't contain qt3
elif qtdir.find("qt3") != -1 or qtdir.find("qt/3") != -1:
logging.error(
"Mixxx now requires QT4 instead of QT3 - please use your QT4 path with the qtdir build flag."
)
Script.Exit(1)
logging.info("Qt path: %s" % qtdir)
# Previously this wasn't done for OSX, but I'm not sure why
# -- rryan 6/8/2011
extra_arguments['QTDIR'] = qtdir
if self.platform == 'osx':
tools.append('OSConsX')
toolpath.append('#/build/osx/')
if self.platform_is_windows and self.toolchain == 'msvs':
toolpath.append('msvs')
extra_arguments['VCINSTALLDIR'] = os.getenv(
'VCInstallDir') # TODO(XXX) Why?
extra_arguments['QT_LIB'] = '' # TODO(XXX) Why?
# Setup the appropriate toolchains for cross-compiling
if self.crosscompile:
if self.platform_is_windows:
tools.append('crossmingw')
if self.platform == 'osx':
tools.append('crossosx')
self.env = Script.Environment(tools=tools,
toolpath=toolpath,
ENV=os.environ,
**extra_arguments)
self.read_environment_variables()
self.virtualize_build_dir()
if self.toolchain_is_gnu:
if flags_force32:
self.env.Append(CCFLAGS='-m32')
elif flags_force64:
self.env.Append(CCFLAGS='-m64')
if self.platform == 'osx':
if self.machine == 'powerpc':
self.env.Append(CCFLAGS='-arch ppc')
self.env.Append(LINKFLAGS='-arch ppc')
else:
if self.bitwidth == 32:
self.env.Append(CCFLAGS='-arch i386')
self.env.Append(LINKFLAGS='-arch i386')
elif self.bitwidth == 64:
self.env.Append(CCFLAGS='-arch x86_64')
self.env.Append(LINKFLAGS='-arch x86_64')
if self.crosscompile:
crosscompile_root = Script.ARGUMENTS.get('crosscompile_root', '')
if crosscompile_root == '':
print "Your build setup indicates this is a cross-compile, but you did not specify 'crosscompile_root', which is required."
Script.Exit(1)
crosscompile_root = os.path.abspath(crosscompile_root)
self.env.Append(CPPPATH=os.path.join(crosscompile_root, 'include'))
self.env.Append(LIBPATH=os.path.join(crosscompile_root, 'lib'))
self.env.Append(LIBPATH=os.path.join(crosscompile_root, 'bin'))
self.install_options()
