################################################################################

vars = Variables(os.path.join(Dir("#").abspath, "config.py"))

vars.Add('cc', "C compiler")

vars.Add('cxx', "C++ compiler")

vars.Add('ccflags', "Extra C/C++/ObjC compiler flags")

vars.Add('cxxflags', "Extra C++ compiler flags")

vars.Add('link', "Linker")

vars.Add('linkflags', "Extra linker flags")

vars.Add(BoolVariable("ccache", "Use CCache", "no"))

vars.Add(EnumVariable("test", "Compile and run tests", "none", ["none", "all", "unit", "system"]))

vars.Add(BoolVariable("optimize", "Compile with optimizations turned on", "no"))

vars.Add(BoolVariable("debug", "Compile with debug information", "yes"))

vars.Add(BoolVariable("allow_warnings", "Allow compilation warnings during compilation", "yes"))

vars.Add(BoolVariable("assertions", "Compile with assertions", "yes"))

vars.Add(BoolVariable("max_jobs", "Build with maximum number of parallel jobs", "no"))

vars.Add(EnumVariable("target", "Choose a target platform for compilation", "native", ["native", "iphone-simulator", "iphone-device", "xcode", "android"]))

vars.Add('android_toolchain', "Path to Android toolchain")

vars.Add(BoolVariable("mac105", "Link against the 10.5 frameworks", "no"))

vars.Add(BoolVariable("mac106", "Link against the 10.6 frameworks", "no"))

if os.name == "nt" :

vars.Add(PathVariable("vcredist", "MSVC redistributable dir", None, PathVariable.PathAccept))

if os.name == "nt" :

vars.Add(PathVariable("wix_bindir", "Path to WiX binaries", "", PathVariable.PathAccept))

if os.name == "nt" :

vars.Add(PackageVariable("bonjour", "Bonjour SDK location", "yes"))

vars.Add(PackageVariable("openssl", "OpenSSL location", "yes"))

vars.Add(BoolVariable("openssl_force_bundled", "Force use of the bundled OpenSSL", "no"))

vars.Add(PackageVariable("hunspell", "Hunspell location", False))

vars.Add(PathVariable("boost_includedir", "Boost headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("boost_libdir", "Boost library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("expat_includedir", "Expat headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("expat_libdir", "Expat library location", None, PathVariable.PathAccept))

vars.Add(PackageVariable("icu", "ICU library location", "no"))

vars.Add(PathVariable("libidn_includedir", "LibIDN headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libidn_libdir", "LibIDN library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libminiupnpc_includedir", "LibMiniUPNPC headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libminiupnpc_libdir", "LibMiniUPNPC library location", None, PathVariable.PathAccept))

vars.Add("libminiupnpc_libname", "LibMiniUPNPC library name", "libminiupnpc" if os.name == "nt" else "miniupnpc")

vars.Add(PathVariable("libnatpmp_includedir", "LibNATPMP headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libnatpmp_libdir", "LibNATPMP library location", None, PathVariable.PathAccept))

vars.Add("libnatpmp_libname", "LibNATPMP library name", "libnatpmp" if os.name == "nt" else "natpmp")

vars.Add(PathVariable("sqlite_includedir", "SQLite headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("sqlite_libdir", "SQLite library location", None, PathVariable.PathAccept))

vars.Add("sqlite_force_bundled", "Force use of the bundled SQLite", None)

vars.Add(PathVariable("lua_includedir", "Lua headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("lua_libdir", "Lua library location", None, PathVariable.PathAccept))

vars.Add("lua_libname", "Lua library name", "liblua" if os.name == "nt" else "lua")

vars.Add("lua_force_bundled", "Force use of the bundled Lua", None)

vars.Add(PathVariable("editline_includedir", "Readline headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("editline_libdir", "Readline library location", None, PathVariable.PathAccept))

vars.Add("editline_libname", "Readline library name", "libedit" if os.name == "nt" else "edit")

vars.Add(PathVariable("avahi_includedir", "Avahi headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("avahi_libdir", "Avahi library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("qt", "Qt location", "", PathVariable.PathAccept))

vars.Add(BoolVariable("qt5", "Compile in Qt5 mode", "no")) # TODO: auto-detect this

vars.Add(PathVariable("docbook_xml", "DocBook XML", None, PathVariable.PathAccept))

vars.Add(PathVariable("docbook_xsl", "DocBook XSL", None, PathVariable.PathAccept))

vars.Add(BoolVariable("build_examples", "Build example programs", "yes"))

vars.Add(BoolVariable("enable_variants", "Build in a separate dir under build/, depending on compile flags", "no"))

vars.Add(BoolVariable("experimental_ft", "Build experimental file transfer", "yes"))

vars.Add(BoolVariable("experimental", "Build experimental features", "no"))

vars.Add(BoolVariable("set_iterator_debug_level", "Set _ITERATOR_DEBUG_LEVEL=0", "yes"))

vars.Add(BoolVariable("unbound", "Build bundled ldns and unbound. Use them for DNS lookup.", "no"))

################################################################################

# Set up default build & configure environment

################################################################################

env_ENV = {

'LD_LIBRARY_PATH' : os.environ.get("LD_LIBRARY_PATH", ""),

'TERM' : os.environ.get("TERM", ""),

}

if "MSVC_VERSION" in ARGUMENTS :

else :

Help(vars.GenerateHelpText(env))

# Workaround for missing Visual Studio 2012 support in SCons

# Requires scons to be run from a VS2012 console

if env.get("MSVC_VERSION", "").startswith("11.0") :

env["ENV"]["LIB"] = os.environ["LIB"]

env["ENV"]["INCLUDE"] = os.environ["INCLUDE"]

env.Tool("BuildVersion", toolpath = ["#/BuildTools/SCons/Tools"])

env.Tool("Flags", toolpath = ["#/BuildTools/SCons/Tools"])

if env["PLATFORM"] == "darwin" :

env.Tool("Nib", toolpath = ["#/BuildTools/SCons/Tools"])

env.Tool("AppBundle", toolpath = ["#/BuildTools/SCons/Tools"])

if env["PLATFORM"] == "win32" :

env.Tool("WindowsBundle", toolpath = ["#/BuildTools/SCons/Tools"])

#So we don't need to escalate with UAC

if "TMP" in os.environ.keys() :

env.Tool("SLOCCount", toolpath = ["#/BuildTools/SCons/Tools"])

# Max out the number of jobs

if env["max_jobs"] :

try :

import multiprocessing

SetOption("num_jobs", multiprocessing.cpu_count())

except NotImplementedError :

pass

env["ENV"][key] = value

env["CC"] = os.environ["CC"]

env["CXX"] = os.environ["CXX"]

# Override the compiler with custom variables set at config time

if "cc" in env :

env["CC"] = env["cc"]

if "cxx" in env :

env["CXX"] = env["cxx"]

if "link" in env :

env["SHLINK"] = env["link"]

env["LINK"] = env["link"]

for flags_type in ["ccflags", "cxxflags", "linkflags"] :

if flags_type in env :

if isinstance(env[flags_type], str) :

# FIXME: Make the splitting more robust

env[flags_type.upper()] = env[flags_type].split(" ")

else :

env.Append(CCFLAGS = ["/MDd"])

else :

env.Append(CCFLAGS = ["-g"])

elif env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["/MD"])

if env.get("universal", 0) :

assert(env["PLATFORM"] == "darwin")

env.Append(CCFLAGS = [

"-arch", "ppc"])

env.Append(LINKFLAGS = [

"-arch", "ppc"])

# Link against other versions of the OS X SDKs.

# FIXME: This method does not work anymore, we need to set deployment targets.

if env.get("mac105", 0) :

assert(env["PLATFORM"] == "darwin")

env.Append(CCFLAGS = [

"-arch", "i386"])

env.Append(LINKFLAGS = [

"-arch", "i386"])

if env.get("mac106", 0) :

assert(env["PLATFORM"] == "darwin")

env.Append(CCFLAGS = [

"-arch", "i386"])

env.Append(LINKFLAGS = [

"-arch", "i386"])

if not env["assertions"] :

env.Append(CPPDEFINES = ["NDEBUG"])

if env["experimental_ft"] :

env.Append(CPPDEFINES = ["SWIFT_EXPERIMENTAL_FT"])

if env["experimental"] :

# If we build shared libs on AMD64, we need -fPIC.

# This should have no performance impact om AMD64

if env["PLATFORM"] == "posix" and platform.machine() == "x86_64" :

env.Append(CCFLAGS = ["-fPIC"])

# Warnings

if env["PLATFORM"] == "win32" :

env.Append(CXXFLAGS = ["/wd4068"])

else :

if "clang" in env["CXX"] :

env.Append(CXXFLAGS = [

"-Weverything",

"-Wno-unknown-warning-option", # To stay compatible between CLang versions

"-Wno-unknown-pragmas", # To stay compatible between CLang versions

"-Wno-weak-vtables", # Virtually none of our elements have outlined methods. This also seems to affect classes in .cpp files, which in turn affects all our tests, which may need fixing in CLang

"-Wno-shadow", # Also warns for shadowing on constructor arguments, which we do a lot

"-Wno-documentation", # We don't care about documentation warnings

assert(env["PLATFORM"] != "win32")

env.Append(CCFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

env.Append(LINKFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

if env["PLATFORM"] == "win32" :

env.Append(LIBS = ["user32", "crypt32", "dnsapi", "iphlpapi", "ws2_32", "wsock32", "Advapi32"])

env.Append(CCFLAGS = ["/EHsc", "/nologo", "/Zm256"])

env.Append(LINKFLAGS = ["/INCREMENTAL:no", "/NOLOGO"])

if int(env["MSVS_VERSION"].split(".")[0]) < 10 :

if env["PLATFORM"] == "darwin" and not env["target"] in ["iphone-device", "iphone-simulator", "xcode", "android"] :

env["PLATFORM_FLAGS"]["FRAMEWORKS"] += ["IOKit", "AppKit", "SystemConfiguration", "Security", "SecurityInterface"]

# Testing

env["TEST_TYPE"] = env["test"]

if "check" in ARGUMENTS :

env["TEST_TYPE"] = "unit"

env["checker_report"] = ARGUMENTS.get("checker_report", False)

env["TEST"] = (env["TEST_TYPE"] != "none") or env.GetOption("clean")

if env.get("valgrind", 0) :

env["TEST_RUNNER"] = "valgrind --suppressions=QA/valgrind.supp -q --leak-check=full --track-origins=yes "

env["TEST_IGNORE_RESULT"] = "ignore_test_result" in ARGUMENTS

env.Append(CCFLAGS = env["XCODE_ARCH_FLAGS"] + ["-fvisibility=hidden", "-miphoneos-version-min=" + env["IPHONEOS_DEPLOYMENT_TARGET"]])

env.Append(LINKFLAGS = "-miphoneos-version-min=" + env["IPHONEOS_DEPLOYMENT_TARGET"])

if os.environ.get("GCC_THUMB_SUPPORT", False) :

env.Append(CCFLAGS = ["-mthumb"])

env.Append(LINKFLAGS = env["XCODE_ARCH_FLAGS"])

env.Append(CPPFLAGS = ["-isysroot", "$XCODE_SDKROOT"])

env.Append(FRAMEWORKS = ["CoreFoundation", "Foundation", "UIKit", "CoreGraphics"])

env.Append(LINKFLAGS = env["XCODE_ARCH_FLAGS"] + ["-isysroot", "$XCODE_SDKROOT", "-L\"$XCODE_SDKROOT/usr/lib\"", "-F\"$XCODE_SDKROOT/System/Library/Frameworks\"", "-F\"$XCODE_SDKROOT/System/Library/PrivateFrameworks\""])

# Bit of a hack, because BOOST doesn't know the endianness for ARM

################################################################################

# Android

################################################################################

if target in ["android"] :

env["ENV"]["PATH"] = env["android_toolchain"] + "/bin:" + env["ENV"]["PATH"]

env["CC"] = "arm-linux-androideabi-gcc"

env["CXX"] = "arm-linux-androideabi-g++"

env["RANLIB"] = "arm-linux-androideabi-ranlib"