359 lines
11 KiB
Python
359 lines
11 KiB
Python
# -*- mode: python -*-
|
|
|
|
Import("env use_system_version_of_library usemozjs boostSuffix get_option")
|
|
Import("wiredtiger")
|
|
|
|
snappySuffix = '-1.1.3'
|
|
zlibSuffix = '-1.2.8'
|
|
pcreSuffix = "-8.38"
|
|
mozjsSuffix = '-38'
|
|
yamlSuffix = '-0.5.3'
|
|
|
|
thirdPartyIncludePathList = [
|
|
('s2', '#/src/third_party/s2'),
|
|
('tz', '#/src/third_party/tz'),
|
|
]
|
|
|
|
if not use_system_version_of_library('tcmalloc'):
|
|
thirdPartyIncludePathList.append(
|
|
('gperftools', '#/src/third_party/gperftools-2.2/src'))
|
|
|
|
if not use_system_version_of_library('pcre'):
|
|
thirdPartyIncludePathList.append(
|
|
('pcre', '#/src/third_party/pcre' + pcreSuffix))
|
|
|
|
if not use_system_version_of_library('boost'):
|
|
thirdPartyIncludePathList.append(
|
|
('boost', '#/src/third_party/boost' + boostSuffix))
|
|
|
|
if not use_system_version_of_library('snappy'):
|
|
thirdPartyIncludePathList.append(
|
|
('snappy', '#/src/third_party/snappy' + snappySuffix))
|
|
|
|
# Valgrind is a header only include as valgrind.h includes everything we need
|
|
if not use_system_version_of_library('valgrind'):
|
|
thirdPartyIncludePathList.append(
|
|
('valgrind', '#/src/third_party/valgrind-3.11.0/include'))
|
|
|
|
if not use_system_version_of_library('zlib'):
|
|
thirdPartyIncludePathList.append(
|
|
('zlib', '#/src/third_party/zlib' + zlibSuffix))
|
|
|
|
# TODO: figure out if we want to offer system versions of mozjs. Mozilla
|
|
# hasn't offered a source tarball since 24, but in theory they could.
|
|
#
|
|
#if not use_system_version_of_library('mozjs'):
|
|
if True:
|
|
thirdPartyIncludePathList.append(
|
|
('mozjs', ['#/src/third_party/mozjs' + mozjsSuffix + '/include',
|
|
'#/src/third_party/mozjs' + mozjsSuffix + '/mongo_sources',
|
|
'#/src/third_party/mozjs' + mozjsSuffix + '/platform/' + env["TARGET_ARCH"] + "/" + env["TARGET_OS"] + "/include",
|
|
]))
|
|
|
|
if not use_system_version_of_library('stemmer'):
|
|
thirdPartyIncludePathList.append(
|
|
('stemmer', '#/src/third_party/libstemmer_c/include'))
|
|
|
|
# Note that the wiredtiger.h header is generated, so
|
|
# we want to look for it in the build directory not
|
|
# the source directory.
|
|
# The wiredtiger_ext.h is a static file in the source tree
|
|
# In the system installs, wiredtiger.h and wiredtiger_ext.h are in the same directory
|
|
if wiredtiger and not use_system_version_of_library('wiredtiger'):
|
|
thirdPartyIncludePathList.append(
|
|
('wiredtiger', '$BUILD_DIR/third_party/wiredtiger'))
|
|
thirdPartyIncludePathList.append(
|
|
('wiredtiger_ext', '#/src/third_party/wiredtiger/src/include'))
|
|
|
|
if not use_system_version_of_library('yaml'):
|
|
thirdPartyIncludePathList.append(
|
|
('yaml', '#/src/third_party/yaml-cpp' + yamlSuffix + '/include'))
|
|
|
|
if not use_system_version_of_library('asio'):
|
|
thirdPartyIncludePathList.append(
|
|
('asio', '#/src/third_party/asio-asio-1-11-0/asio/include'))
|
|
|
|
if not use_system_version_of_library('intel_decimal128'):
|
|
thirdPartyIncludePathList.append(
|
|
('intel_decimal128', '#/src/third_party/IntelRDFPMathLib20U1/LIBRARY'))
|
|
|
|
def injectAllThirdPartyIncludePaths(thisEnv):
|
|
thisEnv.PrependUnique(CPPPATH=[entry[1] for entry in thirdPartyIncludePathList])
|
|
|
|
def injectThirdPartyIncludePaths(thisEnv, libraries):
|
|
thisEnv.PrependUnique(CPPPATH=[
|
|
entry[1] for entry in thirdPartyIncludePathList if entry[0] in libraries])
|
|
|
|
env.AddMethod(injectAllThirdPartyIncludePaths, 'InjectAllThirdPartyIncludePaths')
|
|
env.AddMethod(injectThirdPartyIncludePaths, 'InjectThirdPartyIncludePaths')
|
|
|
|
|
|
murmurEnv = env.Clone()
|
|
murmurEnv.SConscript('murmurhash3/SConscript', exports={ 'env' : murmurEnv })
|
|
|
|
|
|
s2Env = env.Clone()
|
|
s2Env.InjectThirdPartyIncludePaths(libraries=['s2', 'boost'])
|
|
s2Env.InjectMongoIncludePaths()
|
|
s2Env.SConscript('s2/SConscript', exports={'env' : s2Env})
|
|
|
|
|
|
if use_system_version_of_library("pcre"):
|
|
pcreEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_PCRE_SYSLIBDEP'],
|
|
env['LIBDEPS_PCRECPP_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
pcreEnv = env.Clone()
|
|
pcreEnv.InjectThirdPartyIncludePaths(libraries=['pcre'])
|
|
pcreEnv.SConscript('pcre' + pcreSuffix + '/SConscript', exports={ 'env' : pcreEnv })
|
|
pcreEnv = pcreEnv.Clone(
|
|
LIBDEPS=[
|
|
'pcre' + pcreSuffix + '/pcrecpp',
|
|
])
|
|
|
|
pcreEnv.Library(
|
|
target="shim_pcrecpp",
|
|
source=[
|
|
'shim_pcrecpp.cc',
|
|
])
|
|
|
|
|
|
boostEnv = env
|
|
if use_system_version_of_library("boost"):
|
|
# On windows, we don't need the syslibdeps because autolib will select the right libraries
|
|
# for us automatically.
|
|
if not env.TargetOSIs('windows'):
|
|
boostEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_BOOST_PROGRAM_OPTIONS_SYSLIBDEP'],
|
|
env['LIBDEPS_BOOST_FILESYSTEM_SYSLIBDEP'],
|
|
env['LIBDEPS_BOOST_THREAD_SYSLIBDEP'],
|
|
env['LIBDEPS_BOOST_SYSTEM_SYSLIBDEP'],
|
|
env['LIBDEPS_BOOST_CHRONO_SYSLIBDEP'],
|
|
env['LIBDEPS_BOOST_REGEX_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
boostDirectory = 'boost' + boostSuffix
|
|
boostEnv = env.Clone()
|
|
boostEnv.InjectThirdPartyIncludePaths(libraries=['boost'])
|
|
boostEnv.SConscript(boostDirectory + '/SConscript', exports={ 'env' : boostEnv })
|
|
boostEnv = boostEnv.Clone(
|
|
LIBDEPS=[
|
|
boostDirectory + '/boost_program_options',
|
|
boostDirectory + '/boost_filesystem',
|
|
boostDirectory + '/boost_thread',
|
|
boostDirectory + '/boost_system',
|
|
boostDirectory + '/boost_chrono',
|
|
boostDirectory + '/boost_regex',
|
|
])
|
|
|
|
boostEnv.Library(
|
|
target="shim_boost",
|
|
source=[
|
|
'shim_boost.cpp',
|
|
])
|
|
|
|
|
|
if use_system_version_of_library("snappy"):
|
|
snappyEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_SNAPPY_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
snappyEnv = env.Clone()
|
|
snappyEnv.InjectThirdPartyIncludePaths(libraries=['snappy'])
|
|
snappyEnv.InjectMongoIncludePaths()
|
|
snappyEnv.SConscript('snappy' + snappySuffix + '/SConscript', exports={ 'env' : snappyEnv })
|
|
snappyEnv = snappyEnv.Clone(
|
|
LIBDEPS=[
|
|
'snappy' + snappySuffix + '/snappy',
|
|
])
|
|
|
|
snappyEnv.Library(
|
|
target="shim_snappy",
|
|
source=[
|
|
'shim_snappy.cpp',
|
|
])
|
|
|
|
if use_system_version_of_library("zlib"):
|
|
zlibEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_ZLIB_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
zlibEnv = env.Clone()
|
|
zlibEnv.InjectThirdPartyIncludePaths(libraries=['zlib'])
|
|
zlibEnv.InjectMongoIncludePaths()
|
|
zlibEnv.SConscript('zlib' + zlibSuffix + '/SConscript', exports={ 'env' : zlibEnv })
|
|
zlibEnv = zlibEnv.Clone(
|
|
LIBDEPS=[
|
|
'zlib' + zlibSuffix + '/zlib',
|
|
])
|
|
|
|
zlibEnv.Library(
|
|
target="shim_zlib",
|
|
source=[
|
|
'shim_zlib.cpp',
|
|
])
|
|
|
|
if usemozjs:
|
|
mozjsEnv = env.Clone()
|
|
mozjsEnv.SConscript('mozjs' + mozjsSuffix + '/SConscript', exports={'env' : mozjsEnv })
|
|
mozjsEnv = mozjsEnv.Clone(
|
|
LIBDEPS=[
|
|
'mozjs' + mozjsSuffix + '/mozjs',
|
|
'shim_zlib',
|
|
])
|
|
|
|
mozjsEnv.Library(
|
|
target="shim_mozjs",
|
|
source=[
|
|
'shim_mozjs.cpp',
|
|
])
|
|
|
|
gperftoolsEnv = env
|
|
if (gperftoolsEnv['MONGO_ALLOCATOR'] == "tcmalloc"):
|
|
if use_system_version_of_library("tcmalloc"):
|
|
gperftoolsEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_TCMALLOC_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
gperftoolsEnv = env.Clone()
|
|
gperftoolsEnv.InjectThirdPartyIncludePaths(libraries=['gperftools'])
|
|
gperftoolsEnv.InjectMongoIncludePaths()
|
|
gperftoolsEnv.SConscript('gperftools-2.2/SConscript', exports={ 'env' : gperftoolsEnv })
|
|
gperftoolsEnv = gperftoolsEnv.Clone(
|
|
LIBDEPS=[
|
|
'gperftools-2.2/tcmalloc_minimal',
|
|
])
|
|
|
|
gperftoolsEnv.Library(
|
|
target="shim_allocator",
|
|
source=[
|
|
"shim_allocator.cpp",
|
|
])
|
|
|
|
|
|
if use_system_version_of_library("stemmer"):
|
|
stemmerEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_STEMMER_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
stemmerEnv = env.Clone()
|
|
stemmerEnv.InjectThirdPartyIncludePaths(libraries=['stemmer'])
|
|
stemmerEnv.SConscript('libstemmer_c/SConscript', exports={ 'env' : stemmerEnv })
|
|
stemmerEnv = stemmerEnv.Clone(
|
|
LIBDEPS=[
|
|
'libstemmer_c/stemmer',
|
|
])
|
|
|
|
stemmerEnv.Library(
|
|
target="shim_stemmer",
|
|
source=[
|
|
'shim_stemmer.cpp'
|
|
])
|
|
|
|
|
|
if use_system_version_of_library("yaml"):
|
|
yamlEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_YAML_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
yamlEnv = env.Clone()
|
|
yamlEnv.InjectThirdPartyIncludePaths(libraries=['yaml', 'boost'])
|
|
yamlEnv.SConscript('yaml-cpp' + yamlSuffix + '/SConscript', exports={ 'env' : yamlEnv })
|
|
yamlEnv = yamlEnv.Clone(
|
|
LIBDEPS=[
|
|
'yaml-cpp' + yamlSuffix + '/yaml',
|
|
])
|
|
|
|
yamlEnv.Library(
|
|
target="shim_yaml",
|
|
source=[
|
|
'shim_yaml.cpp',
|
|
])
|
|
|
|
|
|
tzEnv = env.Clone()
|
|
if env.TargetOSIs('solaris'):
|
|
tzEnv.InjectThirdPartyIncludePaths(libraries=['tz'])
|
|
tzEnv.SConscript('tz/SConscript', exports={ 'env' : tzEnv })
|
|
tzEnv = tzEnv.Clone(
|
|
LIBDEPS=[
|
|
'tz/tz',
|
|
])
|
|
|
|
tzEnv.Library(
|
|
target='shim_tz',
|
|
source=[
|
|
'shim_tz.cpp',
|
|
])
|
|
|
|
|
|
if wiredtiger:
|
|
if use_system_version_of_library("wiredtiger"):
|
|
wiredtigerEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_WIREDTIGER_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
wiredtigerEnv = env.Clone()
|
|
wiredtigerEnv.InjectThirdPartyIncludePaths(libraries=['wiredtiger'])
|
|
wiredtigerEnv.SConscript('wiredtiger/SConscript', exports={ 'env' : wiredtigerEnv })
|
|
wiredtigerEnv = wiredtigerEnv.Clone(
|
|
LIBDEPS=[
|
|
'wiredtiger/wiredtiger',
|
|
])
|
|
|
|
wiredtigerEnv.Library(
|
|
target="shim_wiredtiger",
|
|
source=[
|
|
'shim_wiredtiger.cpp'
|
|
])
|
|
|
|
if use_system_version_of_library("asio"):
|
|
asioEnv = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_ASIO_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
asioEnv = env.Clone()
|
|
asioEnv.InjectThirdPartyIncludePaths(libraries=['asio'])
|
|
asioEnv.SConscript('asio-asio-1-11-0/SConscript', exports={ 'env' : asioEnv })
|
|
asioEnv = asioEnv.Clone(
|
|
LIBDEPS=[
|
|
'asio-asio-1-11-0/asio',
|
|
])
|
|
|
|
asioEnv.Library(
|
|
target="shim_asio",
|
|
source=[
|
|
'shim_asio.cpp'
|
|
])
|
|
|
|
if get_option("experimental-decimal-support") == "on":
|
|
if use_system_version_of_library("intel_decimal128"):
|
|
intelDecimal128Env = env.Clone(
|
|
SYSLIBDEPS=[
|
|
env['LIBDEPS_INTEL_DECIMAL128_SYSLIBDEP'],
|
|
])
|
|
else:
|
|
intelDecimal128Env = env.Clone()
|
|
intelDecimal128Env.InjectThirdPartyIncludePaths(libraries=['intel_decimal128'])
|
|
intelDecimal128Env.SConscript('IntelRDFPMathLib20U1/SConscript', exports={ 'env' : intelDecimal128Env })
|
|
intelDecimal128Env = intelDecimal128Env.Clone(
|
|
LIBDEPS=[
|
|
'IntelRDFPMathLib20U1/intel_decimal128',
|
|
])
|
|
|
|
intelDecimal128Env.Library(
|
|
target="shim_intel_decimal128",
|
|
source=[
|
|
'shim_intel_decimal128.cpp'
|
|
])
|