+ vars.Add('mt', "manifest tool")

+vars.Add(BoolVariable("distcc", "Use distcc", "no"))

+ vars.Add(BoolVariable("coverage", "Compile with coverage information", "no"))

+ vars.Add(BoolVariable("valgrind", "Run tests with valgrind", "no"))

+ vars.Add(BoolVariable("universal", "Create universal binaries", "no"))

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

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

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

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

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

+vars.Add(EnumVariable("tls_backend", "Choose the TLS backend", "native", ["native", "openssl", "openssl_bundled"]))

+vars.Add(BoolVariable("hunspell_enable", "Build with Hunspell support", True))

+vars.Add(BoolVariable("boost_force_bundled", "Force use of bundled Boost.", False))

+

+vars.Add(BoolVariable("libminiupnpc_force_bundled", "Force use of bundled LibMiniUPNPC", False))

+

+vars.Add(BoolVariable("libnatpmp_force_bundled", "Force use of bundled LibNATPMP", False))

+

+# Code Signing Options

+vars.Add("codesign_identity", "macOS code signing identity to be passed to codesign when building the distribution package. Must match the Commen Name of the Subject of the code signing certificate.", "")

+vars.Add("signtool_key_pfx", "The keyfile (.pfx) that will be used to sign the Windows installer.", None)

+vars.Add("signtool_timestamp_url", "The timestamp server that will be queried for a signed time stamp in the signing process.", None)

+

+# Automatic Software Update Options

+vars.Add(PathVariable("sparkle_public_dsa_key", "Optional path to a public DSA key used to verify Sparkle software updates. Without specifiying this option, the app needs to be code signed for Sparkle to work.", None, PathVariable.PathIsFile))

+

+

+ 'PATH' : os.environ['PATH'],

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

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

+ env = Environment(ENV = env_ENV, variables = vars, MSVC_VERSION = ARGUMENTS["MSVC_VERSION"], platform = ARGUMENTS.get("PLATFORM", None))

+ env = Environment(ENV = env_ENV, variables = vars, MSVC_VERSION = ARGUMENTS["MSVC_VERSION"], platform = ARGUMENTS.get("PLATFORM", None), TARGET_ARCH=env["win_target_arch"])

+ env = Environment(ENV = env_ENV, variables = vars, platform = ARGUMENTS.get("PLATFORM", None))

+ env = Environment(ENV = env_ENV, variables = vars, platform = ARGUMENTS.get("PLATFORM", None), TARGET_ARCH=env["win_target_arch"])

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

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

+ "LIBPATH": [],

+ "LIBS": [],

+ "FRAMEWORKS": [],

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

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

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

+ #So we don't need to escalate with UAC

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

+ env['ENV']['TMP'] = os.environ['TMP']

+ try :

+ import multiprocessing

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

+ except NotImplementedError :

+ pass

+ except ImportError :

+ pass

+ if "cc" not in env :

+ env["CC"] = "clang"

+ if platform.machine() == "x86_64" :

+ env["CCFLAGS"] = ["-arch", "x86_64"]

+ if "cxx" not in env :

+ env["CXX"] = "clang++"

+ if "link" not in env :

+ # Use clang++ instead of clang, otherwise XCode's clang will cause linking errors due to missing C++ standard lib.

+ env["LINK"] = "clang++"

+ if platform.machine() == "x86_64" :

+ env.Append(LINKFLAGS = ["-arch", "x86_64"])

+

+# Set QT_SELECT variable to enable building on systems that have Qt4 and Qt5 installed and use qtselect

+if env["PLATFORM"] != "darwin" and env["PLATFORM"] != "win32" :

+ if env["qt5"] :

+ env["ENV"]["QT_SELECT"] = "qt5"

+ else:

+ env["ENV"]["QT_SELECT"] = "qt4"

+ for key, value in os.environ.items() :

+ if key.startswith("CCC_") or key.startswith("CLANG") :

+ env["ENV"][key] = value

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

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

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

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

+ env["AR"] = env["ar"]

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

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

+

+# Process user-defined external flags

+ 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[flags_type.upper()] = env[flags_type]

+# Compile code as C++11

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

+ env.Append(CXXFLAGS = ["-std=c++11"])

+

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

+ env.Append(CCFLAGS = ["/O2"])

+ else :

+ env.Append(CCFLAGS = ["-O2"])

+ env.Append(CCFLAGS = ["-Os"])

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

+ env.Append(CCFLAGS = ["/Zi"])

+ env.Append(LINKFLAGS = ["/DEBUG"])

+ if GetOption("num_jobs") > 1 :

+ env["CCPDBFLAGS"] = '/Fd${TARGET}.pdb'

+ env["PDB"] = '${TARGET.base}.pdb'

+ if env["set_iterator_debug_level"] :

+ env.Append(CPPDEFINES = ["_ITERATOR_DEBUG_LEVEL=0"])

+ env.Append(LINKFLAGS = ["/OPT:NOREF"])

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

+ else :

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

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

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

+ env.Append(CCFLAGS = [

+ "-isysroot", "/Developer/SDKs/MacOSX10.4u.sdk",

+ "-arch", "i386",

+ "-arch", "ppc"])

+ env.Append(LINKFLAGS = [

+ "-mmacosx-version-min=10.4",

+ "-isysroot", "/Developer/SDKs/MacOSX10.4u.sdk",

+ "-arch", "i386",

+ "-arch", "ppc"])

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

+ env.Append(CCFLAGS = [

+ "-isysroot", "/Developer/SDKs/MacOSX10.5.sdk",

+ "-arch", "i386"])

+ env.Append(LINKFLAGS = [

+ "-mmacosx-version-min=10.5",

+ "-isysroot", "/Developer/SDKs/MacOSX10.5.sdk",

+ "-arch", "i386"])

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

+ env.Append(CCFLAGS = [

+ "-isysroot", "/Developer/SDKs/MacOSX10.6.sdk",

+ "-arch", "i386"])

+ env.Append(LINKFLAGS = [

+ "-mmacosx-version-min=10.6",

+ "-isysroot", "/Developer/SDKs/MacOSX10.6.sdk",

+ "-arch", "i386"])

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

+ env["experimental_ft"] = False

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

+ env.Append(CPPDEFINES = ["SWIFT_EXPERIMENTAL_HISTORY", "SWIFT_EXPERIMENTAL_WB"])

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

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

+ env.Append(CXXFLAGS = ["/wd4503"]) # Disable 'decorated name length exceeded, name was truncated' warning

+ if not env.get("allow_warnings", "False") :

+ env.Append(CXXFLAGS = ["/WX"])

+ # HP-UX gives a flood of minor warnings if this is enabled

+ #env.Append(CXXFLAGS = ["+w"])

+ pass

+ #env.Append(CXXFLAGS = ["-z verbose"])

+ pass

+ if os.path.basename(env["CXX"]) in ["clang", "clang++"] :

+ 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

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

+ "-Wno-exit-time-destructors", # Used a lot in e.g. CPPUnit

+ "-Wno-c++98-compat-pedantic", # We do different things that violate this, but they could be fixed

+ "-Wno-global-constructors", # We depend on this for e.g. string constants

+ "-Wno-disabled-macro-expansion", # Caused due to system headers

+ "-Wno-long-long", # We use long long

+ "-Wno-padded",

+ "-Wno-missing-variable-declarations", # Getting rid of CPPUnit warnings

+ "-Wno-direct-ivar-access", # Obj-C code warning

+ "-Wno-potentially-evaluated-expression", # Caused due to calling shared_ptr::get() inside typeid()

+ ])

+ else :

+ env.Append(CXXFLAGS = ["-Wextra", "-Wall", "-Wnon-virtual-dtor", "-Wundef", "-Wold-style-cast", "-Wno-long-long", "-Woverloaded-virtual", "-Wfloat-equal", "-Wredundant-decls", "-Wno-unknown-pragmas"])

+ gccVersion = env.get("CCVERSION", "0.0.0").split(".")

+ if gccVersion >= ["4", "5", "0"] and not "clang" in env["CC"] :

+ env.Append(CXXFLAGS = ["-Wlogical-op"])

+ if not env.get("allow_warnings", False) :

+ env.Append(CXXFLAGS = ["-Werror"])

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

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

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

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

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

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

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

+ mt = env.get('mt')

+ if not mt:

+ mt = 'mt.exe'

+ env["LINKCOM"] = [env["LINKCOM"], '%s -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;1' % mt]

+ env["SHLINKCOM"] = [env["SHLINKCOM"], '%s -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;2' % mt]

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

+ env.Append(CXXFLAGS = ["+hpxstd98", "-mt", "-AA"])

+ # FIXME: Need -AA for linking C++ but not C

+ #env.Append(LINKFLAGS = ["-AA"])

+# Code signing

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

+ env["CODE_SIGN_IDENTITY"] = env["codesign_identity"]

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

+ env["SIGNTOOL_KEY_PFX"] = env.get("signtool_key_pfx", None)

+ env["SIGNTOOL_TIMESTAMP_URL"] = env.get("signtool_timestamp_url", None)

+ env["TEST_TYPE"] = "unit"

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

+ if ARGUMENTS.get(path, "") :

+ if os.path.isabs(ARGUMENTS[path]) :

+ env[path] = Dir(ARGUMENTS[path]).abspath

+ else :

+ env[path] = Dir("#/" + ARGUMENTS[path]).abspath

+ # Extract/initialize all the information we need

+ if target == "xcode" :

+ # Get the information from the XCode environment

+ env["XCODE_PLATFORM_DEVELOPER_BIN_DIR"] = os.environ["PLATFORM_DEVELOPER_BIN_DIR"]

+ env["XCODE_SDKROOT"] = os.environ["SDKROOT"]

+ env["XCODE_ARCH_FLAGS"] = sum([["-arch", arch] for arch in os.environ["ARCHS"].split(" ")], [])

+ env["IPHONEOS_DEPLOYMENT_TARGET"] = os.environ["IPHONEOS_DEPLOYMENT_TARGET"]

+ # Use absolute path sources so Xcode can highlight compilation errors in swiften

+ env['CXXCOM'] = '$CXX -o $TARGET -c $CXXFLAGS $CCFLAGS $_CCCOMCOM ${SOURCES.abspath}'

+ else :

+ # Hard code values

+ env["XCODE_PLATFORM_DEVELOPER_BIN_DIR"] = "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin"

+ if target == "iphone-device":

+ env["XCODE_ARCH_FLAGS"] = ["-arch", "armv6", "-arch", "armv7"]

+ sdkPart = "iPhoneOS"

+ else :

+ env["XCODE_ARCH_FLAGS"] = ["-arch", "i386"]

+ sdkPart = "iPhoneSimulator"

+ sdkVer = "6.0"

+ env["XCODE_SDKROOT"] = "/Applications/Xcode.app/Contents/Developer/Platforms/" + sdkPart + ".platform/Developer/SDKs/" + sdkPart + sdkVer + ".sdk"

+ env["IPHONEOS_DEPLOYMENT_TARGET"] = "4.1"

+

+ # Set the build flags

+ env["CC"] = os.environ["DEVELOPER_BIN_DIR"] + "/gcc"

+ env["CXX"] = os.environ["DEVELOPER_BIN_DIR"] + "/g++"

+ env["OBJCCFLAGS"] = ["-fobjc-abi-version=2", "-fobjc-legacy-dispatch"]

+ env["LD"] = env["CC"]

+ 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

+ env.Append(CPPDEFINES = ["_LITTLE_ENDIAN"])

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

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

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

+ env["AR"] = "arm-linux-androideabi-ar"

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

+ env.Append(CPPDEFINES = ["ANDROID"])

+ env.Append(CPPDEFINES = ["_REENTRANT", "_GLIBCXX__PTHREADS"])

+ env["ENV"]["HOME"] = os.environ["HOME"]

+ for var in os.environ :

+ if var.startswith("CCACHE_") :

+ env["ENV"][var] = os.environ[var]

+ if env.get("CC", "") != "" :

+ env["CC"] = "ccache " + env["CC"]

+ else :

+ env["CC"] = "ccache gcc"

+ if env.get("CXX", "") != "" :

+ env["CXX"] = "ccache " + env["CXX"]

+ else :

+ env["CC"] = "ccache g++"

+

+# distcc

+if env.get("distcc", False) :

+ env["ENV"]["HOME"] = os.environ["HOME"]

+ for var in os.environ :

+ if var.startswith("DISTCC_") :

+ env["ENV"][var] = os.environ[var]

+ fingerprint = ",".join([flag for flag in env["CXXFLAGS"] + env["CCFLAGS"] if not flag.startswith("-W") and not flag.startswith("-fvisibility")])

+ variant = "build/" + fingerprint

+ if not os.path.exists(Dir("#/build").abspath) :

+ os.mkdir(Dir("#/build").abspath)

+ if os.path.exists(Dir("#/build/current").abspath) :

+ os.unlink(Dir("#/build/current").abspath)

+ os.symlink(os.path.basename(variant), Dir("#/build/current").abspath)

+ if not keywords.get("test_only", False) or env["TEST"] :

+ return apply(oldSConscript, arguments, keywords)

+# env["MSVC_BATCH"] = 1

+ colors = { "red": "31", "green": "32", "yellow": "33", "blue": "34" }

+ prefix = ""

+ suffix = ""

+ if sys.stdout.isatty() and env["PLATFORM"] != "win32":

+ prefix = "\033[0;" + colors[color] + ";140m"

+ suffix = "\033[0m"

+ return " " + prefix + command + suffix + " " + target

+ env["CCCOMSTR"] = colorize("CC", "$TARGET", "green")

+ env["SHCCCOMSTR"] = colorize("CC", "$TARGET", "green")

+ env["CXXCOMSTR"] = colorize("CXX", "$TARGET", "green")

+ env["SHCXXCOMSTR"] = colorize("CXX", "$TARGET", "green")

+ env["LINKCOMSTR"] = colorize("LINK", "$TARGET", "red")

+ env["SHLINKCOMSTR"] = colorize("LINK", "$TARGET", "red")

+ env["ARCOMSTR"] = colorize("AR", "$TARGET", "red")

+ env["RANLIBCOMSTR"] = colorize("RANLIB", "$TARGET", "red")

+ env["PCHCOMSTR"] = colorize("PCH", "$TARGET", "blue")

+ env["QT4_RCCCOMSTR"] = colorize("RCC", "$TARGET", "blue")

+ env["QT4_UICCOMSTR"] = colorize("UIC", "$TARGET", "blue")

+ env["QT4_MOCFROMHCOMSTR"] = colorize("MOC", "$TARGET", "blue")

+ env["QT4_MOCFROMCXXCOMSTR"] = colorize("MOC", "$TARGET", "blue")

+ env["QT4_LRELEASECOMSTR"] = colorize("LRELEASE", "$TARGET", "blue")

+ env["QT4_LUPDATECOMSTR"] = colorize("LUPDATE", "$TARGET", "blue")

+ env["GENCOMSTR"] = colorize("GEN", "$TARGET", "blue")

+ env["RCCOMSTR"] = colorize("RC", "$TARGET", "blue")

+ env["BUNDLECOMSTR"] = colorize("BUNDLE", "$TARGET", "blue")

+ env["NIBCOMSTR"] = colorize("NIB", "$TARGET", "blue")

+ env["NSISCOMSTR"] = colorize("NSIS", "$TARGET", "blue")

+ env["INSTALLSTR"] = colorize("INSTALL", "$TARGET", "blue")

+ env["TESTCOMSTR"] = colorize("TEST", "$SOURCE", "yellow")

+ env["FOCOMSTR"] = colorize("FO", "$TARGET", "blue")

+ env["XSLTCOMSTR"] = colorize("XSLT", "$TARGET", "blue")

+ env["XMLLINTCOMSTR"] = colorize("XMLLINT", "$SOURCE", "blue")

+ env["DOXYCOMSTR"] = colorize("DOXY", "$SOURCE", "blue")

+ #Progress(colorize("DEP", "$TARGET", "red")

+ context.Message("Checking for Objective-C header " + header + " ... ")

+ ret = context.TryCompile("#include <Cocoa/Cocoa.h>\n#include <" + header + ">", ".m")

+ context.Result(ret)

+ return ret

+

+def checkForCpp11Support(context) :

+ context.Message('Checking whether the C++ compiler supports C++11... ')

+ result = context.TryLink(

+ """

+#include <memory>

+

+int main(int, char **) {

+ // shared_ptr test

+ std::shared_ptr<int> intPtr = std::make_shared<int>();

+

+ // unique_ptr test

+ std::unique_ptr<int> intPtrUnique = std::unique_ptr<int>(new int(1));

+

+ // auto test

+ auto otherIntPtr = intPtr;

+ std::shared_ptr<int> fooIntPtr = otherIntPtr;

+

+ // lambda test

+ auto someFunction = [](int i){ i = i * i; };

+ someFunction(2);

+

+ // nullptr test

+ double* fooDouble = nullptr;

+ double bazDouble = 8.0;

+ fooDouble = &bazDouble;

+ bazDouble = *fooDouble;

+

+ return 0;

+}

+""", '.cpp')

+ context.Result(result)

+ return result

+

+ SCons.SConf.SetCacheMode("force")

+ context.Message( 'Checking for package %s... ' % name )

+ ret = context.TryAction('pkg-config --exists \'%s\'' % name)[0]

+ context.Result( ret )

+ return ret

+ context.Message("Checking " + library + " version (>= " + version + ") ...")

+ version = GetVersion(context, define, header)

+ ok = version >= value

+ context.Result(ok)

+ return ok

+ ret = context.TryRun("""

+ printf("%%d\\n", %(define)s);

+ return 0;

+ if ret[0] :

+ return int(ret[1])

+ else :

+ return -1

+conf = Configure(conf_env, custom_tests = {

+ 'CheckCpp11Support' : checkForCpp11Support,

+ })

+ print "Error: You need a working compiler"

+ Exit(1)

+

+if not conf.CheckCpp11Support() :

+ print "Error: You need a compiler with support for the C++11 standard"

+ Exit(1)

+

+ zlib_flags["LIBPATH"] = [env["zlib_libdir"]]

+ zlib_okay = True

+ zlib_flags["CPPPATH"] = [env["zlib_includedir"]]

+ zlib_okay = True

+ zlib_flags["LIBS"] = [File(env["zlib_libfile"])]

+ zlib_okay = True

+ zlib_flags["LIBS"] = ["z"]

+ zlib_flags["LIBS"] = ["z"]

+ zlib_okay = True

+ env["ZLIB_FLAGS"] = zlib_flags

+ print "Error: Zlib not found and zlib_bundled_enable is false"

+ Exit(1)

+ env["ZLIB_BUNDLED"] = True

+ env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["resolv"]

+ if conf.CheckLib("pthread") :

+ env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["pthread"]

+ env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["dl"]

+ env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["m"]

+ env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["c"]

+ if conf.CheckLib("stdc++", language='CXX') :

+ env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["stdc++"]

+ boost_flags["LIBPATH"] = [env["boost_libdir"]]

+ if env["PLATFORM"] == "win32" or env["PLATFORM"] == "hpux" or env["PLATFORM"] == "sunos" :

+ boost_flags["CPPPATH"] = [env["boost_includedir"]]

+ else :

+ # Using isystem to avoid getting warnings from a system boost

+ # Unfortunately, this also disables dependency tracking

+ boost_flags["CPPFLAGS"] = [("-isystem", env["boost_includedir"])]

+boostLibs = [(None, "signals2.hpp"), ("system", "system/system_error.hpp"), ("thread", None), ("regex", None), ("program_options", None), ("filesystem", None), ("serialization", "archive/text_oarchive.hpp"), ("date_time", "date_time/date.hpp")]

+ if header :

+ header = "boost/" + header

+ else :

+ header = "boost/" + lib + ".hpp"

+ if not conf.CheckCXXHeader(header) :

+ allLibsPresent = False

+ break

+ if lib and env["PLATFORM"] != "win32" :

+ libName = "boost_" + lib

+ if not conf.CheckLib(libName, language='CXX') :

+ libName += "-mt"

+ if not conf.CheckLib(libName, language='CXX') :

+ allLibsPresent = False

+ break

+ libNames.append(libName)

+if not env.get("boost_force_bundled") and allLibsPresent :

+ env["BOOST_FLAGS"] = boost_flags

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

+ env["BOOST_FLAGS"].update({"LIBS": libNames})

+ if not conf.CheckCXXHeader("boost/uuid/uuid.hpp") :

+ # FIXME: Remove this workaround when UUID is available in most distros

+ env["BOOST_BUNDLED_UUID_ONLY"] = True

+ print "Error: Boost not found and boost_bundled_enable is false"

+ Exit(1)

+ env["BOOST_BUNDLED"] = True

+ xss_flags = {

+ "LIBPATH": ["/usr/X11R6/lib"],

+ "LIBS": ["Xss"]

+ }

+ xss_env = conf_env.Clone()

+ xss_env.MergeFlags(xss_flags)

+ conf = Configure(xss_env)

+ if conf.CheckFunc("XScreenSaverQueryExtension") :

+ env["HAVE_XSS"] = 1

+ env["XSS_FLAGS"] = xss_flags

+ conf.Finish()

+ gconf_env = conf_env.Clone()

+ conf = Configure(gconf_env, custom_tests = {"CheckPKG": CheckPKG})

+ if conf.CheckPKG("gconf-2.0") :

+ gconf_bare_env = Environment()

+ gconf_bare_env.ParseConfig('pkg-config --cflags gconf-2.0 gobject-2.0 --libs gconf-2.0 gobject-2.0')

+ gconf_flags = {

+ "LIBS": gconf_bare_env["LIBS"],

+ "CCFLAGS": gconf_bare_env["CCFLAGS"],

+ "CPPPATH": gconf_bare_env["CPPPATH"],

+ "CPPDEFINES": gconf_bare_env.get("CPPDEFINES", []),

+ }

+ gconf_env.MergeFlags(gconf_flags)

+ if conf.CheckCHeader("gconf/gconf-client.h") and conf.CheckLib("gconf-2") :

+ env["HAVE_GCONF"] = 1

+ env["GCONF_FLAGS"] = {

+ "LIBS": gconf_env["LIBS"],

+ "CCFLAGS": gconf_env["CCFLAGS"],

+ "CPPPATH": gconf_env["CPPPATH"],

+ "CPPDEFINES": gconf_env.get("CPPDEFINES", []),

+ }

+ conf.Finish()

+ sparkle_flags = {

+ "FRAMEWORKPATH": ["3rdParty/Sparkle/Sparkle-1.14.0"],

+ "FRAMEWORKS": ["Sparkle"]

+ }

+ sparkle_env = conf_env.Clone()

+ sparkle_env.MergeFlags(sparkle_flags)

+ conf = Configure(sparkle_env, custom_tests = { "CheckObjCHeader" : checkObjCHeader })

+ if conf.CheckObjCHeader("Sparkle/Sparkle.h") :

+ env["HAVE_SPARKLE"] = 1

+ env["SPARKLE_FLAGS"] = sparkle_flags

+ env["SPARKLE_FRAMEWORK"] = Dir("../../3rdParty/Sparkle/Sparkle-1.14.0/Sparkle.framework")

+ conf.Finish()

+

+ if env.get("sparkle_public_dsa_key", None) != None :

+ env["SWIFT_SPARKLE_PUBLIC_DSA_KEY"] = File(env.get("sparkle_public_dsa_key"))

+ else :

+ env["SWIFT_SPARKLE_PUBLIC_DSA_KEY"] = None

+ growl_flags = {

+ "FRAMEWORKPATH": ["/Library/Frameworks"],

+ "FRAMEWORKS": ["Growl"]

+ }

+ growl_env = conf_env.Clone()

+ growl_env.MergeFlags(growl_flags)

+ conf = Configure(growl_env, custom_tests = { "CheckObjCHeader" : checkObjCHeader })

+ if conf.CheckObjCHeader("Growl/Growl.h") :

+ env["HAVE_GROWL"] = 1

+ env["GROWL_FLAGS"] = growl_flags

+ env["GROWL_FRAMEWORK"] = "/Library/Frameworks/Growl.framework"

+ conf.Finish()

+ env["HAVE_LIBXML"] = 1

+ env["LIBXML_FLAGS"] = { "LIBS": ["xml2"] }

+ libxml_env = conf_env.Clone()

+ libxml_env.Append(CPPPATH = ["/usr/include/libxml2"])

+ conf = Configure(libxml_env, custom_tests = {"CheckVersion": CheckVersion})

+ if conf.CheckCHeader("libxml/parser.h") and conf.CheckLib("xml2") :

+# and conf.CheckVersion("LibXML", "2.6.23", "LIBXML_VERSION", "libxml/xmlversion.h", 20623):

+ env["HAVE_LIBXML"] = 1

+ libxml_env.Append()

+ if os.path.basename(env["CC"]) in ("clang", "gcc"):

+ env["LIBXML_FLAGS"] = { "CXXFLAGS": ["-isystem/usr/include/libxml2"], "LIBS": ["xml2"] }

+ else:

+ env["LIBXML_FLAGS"] = { "CPPPATH": ["/usr/include/libxml2"], "LIBS": ["xml2"] }

+ conf.Finish()

+ expat_conf_env = conf_env.Clone()

+ expat_flags = {}

+ if env.get("expat_libdir", None) :

+ expat_flags["LIBPATH"] = [env["expat_libdir"]]

+ if env.get("expat_includedir", None) :

+ expat_flags["CPPPATH"] = [env["expat_includedir"]]

+ expat_conf_env.MergeFlags(expat_flags)

+ conf = Configure(expat_conf_env)

+ if conf.CheckCHeader("expat.h") and conf.CheckLib(env["expat_libname"]) :

+ env["HAVE_EXPAT"] = 1

+ env["EXPAT_FLAGS"] = { "LIBS": [env["expat_libname"]] }

+ env["EXPAT_FLAGS"].update(expat_flags)

+ conf.Finish()

+ print "Expat or LibXML not found. Using bundled Expat"

+ SConscript("#/3rdParty/Expat/SConscript")

+ env["HAVE_EXPAT"] = 1

+ env["EXPAT_BUNDLED"] = True

+ icu_prefix = env["icu"]

+ icu_flags = { "CPPPATH": [os.path.join(icu_prefix, "include")] }

+ icu_flags["LIBPATH"] = [os.path.join(icu_prefix, "lib")]

+ icu_env.MergeFlags(icu_flags)

+ env["HAVE_ICU"] = 1

+ env["ICU_FLAGS"] = icu_flags

+ env["ICU_FLAGS"]["LIBS"] = ["icuuc"]

+ libidn_flags["LIBPATH"] = [env["libidn_libdir"]]

+ libidn_flags["CPPPATH"] = [env["libidn_includedir"]]

+ env["HAVE_LIBIDN"] = 1

+ env["LIBIDN_FLAGS"] = { "LIBS": [env["libidn_libname"]] }

+ env["LIBIDN_FLAGS"].update(libidn_flags)

+ if env.get("libidn_bundled_enable", True) :

+ env["HAVE_LIBIDN"] = 1

+ env["LIBIDN_BUNDLED"] = 1

+ elif env.get("need_idn", True):

+ print "Error: ICU and LIBIDN not found, and libidn_bundled_enable is false"

+ Exit(1)

+ else:

+ print "Proceeding without an IDN library because need_idn was false. This will break all internal binaries"

+ env["LDNS_BUNDLED"] = 1

+ env["UNBOUND_BUNDLED"] = 1

+ env["LDNS_FLAGS"] = {}

+ env["UNBOUND_FLAGS"] = {}

+ libminiupnpc_flags = {"CPPPATH": ["/usr/include/miniupnpc/"]}

+ libminiupnpc_conf_env = conf_env.Clone()

+ if env.get("libminiupnpc_libdir", None) :

+ libminiupnpc_flags["LIBPATH"] = [env["libminiupnpc_libdir"]]

+ if env.get("libminiupnpc_includedir", None) :

+ libminiupnpc_flags["CPPPATH"] = [env["libminiupnpc_includedir"]]

+ libminiupnpc_conf_env.MergeFlags(libminiupnpc_flags)

+ conf = Configure(libminiupnpc_conf_env)

+ if not env.get("libminiupnpc_force_bundled") and conf.CheckCHeader("miniupnpc.h") and conf.CheckLib(env["libminiupnpc_libname"]) :

+ env["HAVE_LIBMINIUPNPC"] = 1

+ env["LIBMINIUPNPC_FLAGS"] = { "LIBS": ["miniupnpc"] }

+ env["LIBMINIUPNPC_FLAGS"].update(libminiupnpc_flags)

+ else :

+ env["LIBMINIUPNPC_BUNDLED"] = 1

+ conf.Finish()

+ env["LIBMINIUPNPC_FLAGS"] = {}

+ libnatpmp_flags = {}

+ libnatpmp_conf_env = conf_env.Clone()

+ if env.get("libnatpmp_libdir", None) :

+ libnatpmp_flags["LIBPATH"] = [env["libnatpmp_libdir"]]

+ if env.get("libnatpmp_includedir", None) :

+ libnatpmp_flags["CPPPATH"] = [env["libnatpmp_includedir"]]

+ libnatpmp_conf_env.MergeFlags(libnatpmp_flags)

+ conf = Configure(libnatpmp_conf_env)

+ if not env.get("libnatpmp_force_bundled") and conf.CheckCHeader("natpmp.h") and conf.CheckLib(env["libnatpmp_libname"]) :

+ env["HAVE_LIBNATPMP"] = 1

+ env["LIBNATPMP_FLAGS"] = { "LIBS": ["natpmp"] }

+ env["LIBNATPMP_FLAGS"].update(libnatpmp_flags)

+ else :

+ env["LIBNATPMP_BUNDLED"] = 1

+ conf.Finish()

+ env["LIBNATPMP_FLAGS"] = {}

+ sqlite_conf_env = conf_env.Clone()

+ sqlite_flags = {}

+ if env.get("sqlite_libdir", None) :

+ sqlite_flags["LIBPATH"] = [env["sqlite_libdir"]]

+ if env.get("sqlite_includedir", None) :

+ sqlite_flags["CPPPATH"] = [env["sqlite_includedir"]]

+ sqlite_conf_env.MergeFlags(sqlite_flags)

+ conf = Configure(sqlite_conf_env)

+ if conf.CheckCHeader("sqlite3.h") and conf.CheckLib(env["sqlite_libname"]) and not env.get("sqlite_force_bundled", False):

+ env["HAVE_SQLITE"] = 1

+ env["SQLITE_FLAGS"] = { "LIBS": [env["sqlite_libname"]] }

+ env["SQLITE_FLAGS"].update(sqlite_flags)

+ else :

+ env["SQLITE_BUNDLED"] = 1

+ conf.Finish()

+ env["SQLITE_FLAGS"] = {}

+ lua_flags["LIBPATH"] = [env["lua_libdir"]]

+ lua_flags["CPPPATH"] = [env["lua_includedir"]]

+ env["HAVE_LUA"] = 1

+ env["LUA_FLAGS"] = { "LIBS": [env["lua_libname"]] }

+ lua_version = GetVersion(conf, "LUA_VERSION_NUM", "lua.h")

+ if lua_version > 0 :

+ env["LUA_FLAGS"]["LUA_VERSION"] = str(lua_version // 100) + "." + str(lua_version % 100)

+ else :

+ print "Warning: Unable to determine Lua version. Not installing Lua libraries."

+ env["LUA_FLAGS"].update(lua_flags)

+ env["LUA_BUNDLED"] = 1

+ editline_flags["LIBPATH"] = [env["editline_libdir"]]

+ editline_flags["CPPPATH"] = [env["editline_includedir"]]

+ env["HAVE_EDITLINE"] = 1

+ env["EDITLINE_FLAGS"] = { "LIBS": [env["editline_libname"]] }

+ env["EDITLINE_FLAGS"].update(editline_flags)

+ avahi_flags["LIBPATH"] = [env["avahi_libdir"]]

+ avahi_flags["CPPPATH"] = [env["avahi_includedir"]]

+ env["HAVE_AVAHI"] = True

+ env["AVAHI_FLAGS"] = { "LIBS": ["avahi-client", "avahi-common"] }

+ env["AVAHI_FLAGS"].update(avahi_flags)

+ env["QTDIR"] = env["qt"]

+################################################################################

+# TLS backend selection

+################################################################################

+env["OPENSSL_FLAGS"] = {}

+if env.get("tls_backend") == "native" :

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

+ env["HAVE_SCHANNEL"] = True

+ elif env["PLATFORM"] == "darwin" and env["target"] == "native":

+ env["HAVE_SECURETRANSPORT"] = True

+ elif env["target"] in ("iphone-device", "iphone-simulator", "xcode", "android") :

+ env["tls_backend"] = "openssl_bundled"

+ else :

+ env["tls_backend"] = "openssl"

+if env.get("tls_backend") == "openssl_bundled" :

+ env["OPENSSL_BUNDLED"] = True

+ env["HAVE_OPENSSL"] = True

+elif env.get("tls_backend") == "openssl" :

+ openssl_env = conf_env.Clone()

+ use_openssl = bool(env["openssl"])

+ openssl_prefix = ""

+ if isinstance(env["openssl"], str) :

+ openssl_prefix = env["openssl"]

+ openssl_flags = {}

+ if openssl_prefix :

+ openssl_include = env.get("openssl_include")

+ openssl_libdir = env.get("openssl_libdir")

+ if openssl_include:

+ openssl_flags = {"CPPPATH":[openssl_include]}

+ else:

+ openssl_flags = { "CPPPATH": [os.path.join(openssl_prefix, "include")] }

+ if openssl_libdir:

+ openssl_flags["LIBPATH"] = [openssl_libdir]

+ env["OPENSSL_DIR"] = openssl_prefix

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

+ openssl_flags["LIBPATH"] = [os.path.join(openssl_prefix, "lib", "VC")]

+ env["OPENSSL_DIR"] = openssl_prefix

+ else :

+ openssl_flags["LIBPATH"] = [os.path.join(openssl_prefix, "lib")]

+ openssl_env.MergeFlags(openssl_flags)

+

+ openssl_conf = Configure(openssl_env)

+ if use_openssl and openssl_conf.CheckCHeader("openssl/ssl.h") :

+ env["HAVE_OPENSSL"] = 1

+ env["OPENSSL_FLAGS"] = openssl_flags

+ openssl_libnames = env.get("openssl_libnames")

+ if openssl_libnames:

+ env["OPENSSL_FLAGS"]["LIBS"] = openssl_libnames.split(',')

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

+ env["OPENSSL_FLAGS"]["LIBS"] = ["libeay32MD", "ssleay32MD"]

+ else:

+ env["OPENSSL_FLAGS"]["LIBS"] = ["ssl", "crypto"]

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

+ if platform.mac_ver()[0].startswith("10.5") :

+ env["OPENSSL_FLAGS"]["FRAMEWORKS"] = ["Security"]

+ openssl_conf.Finish()

+ # On Windows link to secur32. It is needed by Swiften/SASL/WindowsAuthentication

+ env.Append(LIBS = ["secur32"])

+ hunspell_flags = {"CPPPATH":[os.path.join(hunspell_prefix, "include")], "LIBPATH":[os.path.join(hunspell_prefix, "lib")]}

+ hunspell_conf = Configure(hunspell_env)

+ if hunspell_conf.CheckCXXHeader("hunspell/hunspell.hxx") and hunspell_conf.CheckLib("hunspell") :

+ env["HAVE_HUNSPELL"] = 1

+ hunspell_flags["LIBS"] = ["hunspell"]

+ env["HUNSPELL_FLAGS"] = hunspell_flags

+ hunspell_conf.Finish()

+ env["HAVE_BONJOUR"] = 1

+ bonjour_env = conf_env.Clone()

+ bonjour_conf = Configure(bonjour_env)

+ bonjour_flags = {}

+ if env.get("bonjour") != True :

+ bonjour_prefix = env["bonjour"]

+ bonjour_flags["CPPPATH"] = [os.path.join(bonjour_prefix, "include")]

+ bonjour_flags["LIBPATH"] = [os.path.join(bonjour_prefix, "lib", "win32")]

+ bonjour_env.MergeFlags(bonjour_flags)

+ if bonjour_conf.CheckCHeader("dns_sd.h") and bonjour_conf.CheckLib("dnssd") :

+ env["HAVE_BONJOUR"] = 1

+ env["BONJOUR_FLAGS"] = bonjour_flags

+ env["BONJOUR_FLAGS"]["LIBS"] = ["dnssd"]

+ bonjour_conf.Finish()

+ cocoa_conf = Configure(conf_env)

+ if cocoa_conf.CheckCHeader("IOKit/IOKitLib.h") :

+ env["HAVE_IOKIT"] = True

+ cocoa_conf.Finish()

+ myenv = env.Clone()

+ myenv.Tool("qt4", toolpath = ["#/BuildTools/SCons/Tools"])

+ env["HAVE_QT"] = True

+ env["HAVE_QT"] = False

+ print "Info: %s" % str(e)

+ env["HAVE_QT"] = False

+ env["DOCBOOK_XML_DIR"] = env["docbook_xml"]

+ env["DOCBOOK_XSL_DIR"] = env["docbook_xsl"]

+ if env.Dir("#/.git").exists() :

+ if not env.GetOption("clean") and env.get("install_git_hooks", True) :

+ env.Install("#/.git/hooks", Glob("#/BuildTools/Git/Hooks/*"))

+ print "You seem to be using Swift in a Git submodule. Not installing hooks."

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

+

+ def relpath(path, start) :

+ i = len(os.path.commonprefix([path, start]))

+ return path[i+1:]

+

+ for actual_root, dirs, files in os.walk(root) :

+ if "3rdParty" in actual_root :

+ continue

+ for file in files :

+ if not file.endswith(".h") :

+ continue

+ include = relpath(os.path.join(actual_root, file), root)

+ env.ReplacePragmaOnce("#/include/" + include, "#/" + include)

+ env.Append(CPPPATH = ["#/include"])

+ env.Append(CPPPATH = [root])

+ env.SetOption("no_exec", True)

+ env["TEST"] = True

+ env["BOOST_BUILD_BCP"] = True

+ env.Decider(lambda x, y, z : True)

+ SCons.Node.Python.Value.changed_since_last_build = (lambda x, y, z: True)

+ for dir in os.listdir(Dir("#/3rdParty").abspath) :

+ full_dir = os.path.join(Dir("#/3rdParty").abspath, dir)

+ if not os.path.isdir(full_dir) :

+ continue

+ sconscript = os.path.join(full_dir, "SConscript")

+ if os.path.isfile(sconscript) :

+ modules.append("3rdParty/" + dir)

+ full_dir = os.path.join(Dir("#").abspath, dir)

+ if not os.path.isdir(full_dir) :

+ continue

+ sconscript = os.path.join(full_dir, "SConscript")

+ if os.path.isfile(sconscript) :

+ modules.append(dir)

+ env["SCONS_STAGE"] = stage

+ SConscript(dirs = map(lambda x : root + "/" + x, modules))

+ for project in env["PROJECTS"] :

+ env.SLOCCount("#/" + project)

+ parsers.append("LibXML")

+ parsers.append("Expat")

+ if env.get("EXPAT_BUNDLED", False) :

+ parsers.append("(Bundled)")

+

+if not GetOption("help") and not env.get("HAVE_OPENSSL", 0) and not env.get("HAVE_SCHANNEL", 0) and not env.get("HAVE_SECURETRANSPORT", 0):

+ print "Error: A working TLS backend is required. Please check the documentation for more information."

+ Exit(1)

+

+from datetime import date

+ def createAppBundle(env, bundle, version = "1.0", resources = [], frameworks = [], info = {}, handlesXMPPURIs = False, sparklePublicDSAKey = None) :

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

+ bundleDir = bundle + ".app"

+ bundleContentsDir = bundleDir + "/Contents"

+ resourcesDir = bundleContentsDir + "/Resources"

+ frameworksDir = bundleContentsDir + "/Frameworks"

+ env.Install(bundleContentsDir + "/MacOS", bundle)

+ env.WriteVal(bundleContentsDir + "/PkgInfo", env.Value("APPL\77\77\77\77"))

+ infoDict = {

+ "CFBundleDevelopmentRegion" : "English",

+ "CFBundleExecutable" : bundle,

+ "CFBundleIdentifier" : "im.swift." + bundle,

+ "CFBundleInfoDictionaryVersion" : "6.0",

+ "CFBundleName" : bundle,

+ "CFBundlePackageType" : "APPL",

+ "CFBundleSignature": "\77\77\77\77",

+ "CFBundleVersion" : version,

+ "CFBundleIconFile" : bundle,

+ "NSPrincipalClass" : "NSApplication",

+ "NSHumanReadableCopyright" : "(c) 2010-%d Isode Ltd.\nAll Rights Reserved." % date.today().year

+ }

+ infoDict.update(info)

+

+ plist = """<?xml version="1.0" encoding="UTF-8"?>

+ <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

+ <plist version="1.0">

+ <dict>

+ """

+ for key, value in infoDict.items() :

+ plist += "<key>" + key + "</key>\n"

+ plist += "<string>" + value.encode("utf-8") + "</string>\n"

+ if handlesXMPPURIs :

+ plist += """<key>CFBundleURLTypes</key>

+ <dict>

+ <key>CFBundleURLName</key>

+ <string>XMPP URL</string>

+ <key>CFBundleURLSchemes</key>

+ <array>

+ <string>xmpp</string>

+ </array>

+ </dict>

+ if sparklePublicDSAKey :

+ plist += "<key>SUPublicDSAKeyFile</key>"

+ plist += "<string>" + sparklePublicDSAKey.name.encode("utf-8") + "</string>"

+ env.Install(resourcesDir, sparklePublicDSAKey)

+ plist += """</dict>

+ </plist>

+ """

+ env.WriteVal(bundleContentsDir + "/Info.plist", env.Value(plist))

+

+ for (target, resource) in resources.items() :

+ env.Install(os.path.join(resourcesDir, target), resource)

+ for framework in frameworks :

+ env.InstallWithSymLinks(frameworksDir, framework)

+ return env.Dir(bundleDir)

+ env.AddMethod(createAppBundle, "AppBundle")

+ return env["PLATFORM"] == "darwin"

+ def createBuildVersion(env, target, project) :

+ buildVersion = """#pragma once

+ env.WriteVal(target, env.Value(buildVersion))

+ env.AddMethod(createBuildVersion, "BuildVersion")

+ return true

+ def modify_targets(target, source, env) :

+ target = [env.File("html/index.html")]

+ return target, source

+ def generate_actions(source, target, env, for_signature) :

+ if env.WhereIs("$DOXYGEN") and env.WhereIs("$DOT") :

+ return [SCons.Action.Action("$DOXYGEN $SOURCE", cmdstr = "$DOXYCOMSTR")]

+ else :

+ return []

+ env["DOXYGEN"] = "doxygen"

+ # FIXME: For some reason, things go incredibly slow (at least on OS X)

+ # when not doing this. Some environment flag is having an effect on

+ # this; find out which

+ env["ENV"] = os.environ

+ env["DOT"] = "dot"

+ env["BUILDERS"]["DoxyGen"] = SCons.Builder.Builder(

+ emitter = modify_targets,

+ generator = generate_actions,

+ single_source = True)

+ return True

+ def useFlags(env, flags) :

+ for flag in flags :

+ if flag in env :

+ env[flag] = env[flag] + flags[flag]

+ else :

+ env[flag] = flags[flag]

+ env.AddMethod(useFlags, "UseFlags")

+ return True

+"""SCons.Tool.install

+

+Tool-specific initialization for the install tool.

+

+There normally shouldn't be any need to import this module directly.

+It will usually be imported through the generic SCons.Tool.Tool()

+selection method.

+"""

+

+#

+# Copyright (c) 2001 - 2015 The SCons Foundation

+#

+# Permission is hereby granted, free of charge, to any person obtaining

+# a copy of this software and associated documentation files (the

+# "Software"), to deal in the Software without restriction, including

+# without limitation the rights to use, copy, modify, merge, publish,

+# distribute, sublicense, and/or sell copies of the Software, and to

+# permit persons to whom the Software is furnished to do so, subject to

+# the following conditions:

+#

+# The above copyright notice and this permission notice shall be included

+# in all copies or substantial portions of the Software.

+#

+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+#

+

+from SCons.Script import Action, Builder

+from SCons.Node import FS

+import shutil

+import stat

+import os

+from os import path

+

+class CopytreeError(EnvironmentError):

+ pass

+

+# This is a patched version of shutil.copytree from python 2.5. It

+# doesn't fail if the dir exists, which regular copytree does

+# (annoyingly). Note the XXX comment in the docstring.

+def scons_copytree(src, dst, symlinks=False):

+ """Recursively copy a directory tree using copy2().

+

+ The destination directory must not already exist.

+ If exception(s) occur, an CopytreeError is raised with a list of reasons.

+

+ If the optional symlinks flag is true, symbolic links in the

+ source tree result in symbolic links in the destination tree; if

+ it is false, the contents of the files pointed to by symbolic

+ links are copied.

+

+ XXX Consider this example code rather than the ultimate tool.

+

+ """

+ names = os.listdir(src)

+ # garyo@genarts.com fix: check for dir before making dirs.

+ if not os.path.exists(dst):

+ os.makedirs(dst)

+ errors = []

+ for name in names:

+ srcname = os.path.join(src, name)

+ dstname = os.path.join(dst, name)

+ try:

+ if symlinks and os.path.islink(srcname):

+ linkto = os.readlink(srcname)

+ os.symlink(linkto, dstname)

+ elif os.path.isdir(srcname):

+ scons_copytree(srcname, dstname, symlinks)

+ else:

+ shutil.copy2(srcname, dstname)

+ # XXX What about devices, sockets etc.?

+ except (IOError, os.error), why:

+ errors.append((srcname, dstname, str(why)))

+ # catch the CopytreeError from the recursive copytree so that we can

+ # continue with other files

+ except CopytreeError, err:

+ errors.extend(err.args[0])

+ try:

+ shutil.copystat(src, dst)

+ except WindowsError:

+ # can't copy file access times on Windows

+ pass

+ except OSError, why:

+ errors.extend((src, dst, str(why)))

+ if errors:

+ raise CopytreeError, errors

+

+

+def symlinkBuilderImpl(target, source, env):

+ lnk = target[0].abspath

+ src = source[0].abspath

+ lnkdir,lnkname = path.split(lnk)

+ srcdir,srcname = path.split(src)

+

+ scons_copytree(src, os.path.join(lnk, srcname), True)

+

+ return None

+

+def symlinkBuilderPrinter(target, source, env):

+ lnk = path.basename(target[0].abspath)

+ src = path.basename(source[0].abspath)

+ return 'INSTALL PRESERVING SYMLINKS ' + target[0].get_internal_path()

+

+def generate(env) :

+ symlinkBuilder = Builder(action = Action(symlinkBuilderImpl, symlinkBuilderPrinter), target_factory = FS.Entry, source_factory = FS.Entry)

+ env.Append(BUILDERS = {'InstallWithSymLinks' : symlinkBuilder})

+

+def exists(env) :

+ return True \ No newline at end of file

+ env["IBTOOL"] = "ibtool"

+ env["BUILDERS"]["Nib"] = SCons.Builder.Builder(

+ action = SCons.Action.Action("$IBTOOL --errors --warnings --notices --output-format human-readable-text --compile $TARGET $SOURCE", cmdstr = "$NIBCOMSTR"),

+ suffix = ".nib",

+ src_suffix = ".xib",

+ single_source = True)

+ return env["PLATFORM"] == "darwin"

+ root = env.Dir("#").abspath

+ def relpath(path, start) :

+ i = len(os.path.commonprefix([path, start]))

+ return path[i+1:]

+ def replacePragmaOnce(env, target, source) :

+ guard = relpath(source[0].abspath, root).replace("/", "_").replace(".", "_").upper()

+ data = source[0].get_contents()

+ f = open(str(target[0]), 'wb')

+ if "#pragma once" in data :

+ f.write(data.replace("#pragma once", "#ifndef %(guard)s\n#define %(guard)s" % {"guard": guard}))

+ f.write("\n#endif\n")

+ else :

+ f.write(data)

+ f.close()

+ env["BUILDERS"]["ReplacePragmaOnce"] = SCons.Builder.Builder(

+ action = SCons.Action.Action(replacePragmaOnce, cmdstr = "$GENCOMSTR"),

+ single_source = True)

+ return True

+ def createSLOCCount(env, source) :

+ myenv = env.Clone()

+ myenv["ENV"]["HOME"] = os.environ["HOME"]

+ source = myenv.Dir(source)

+ target = myenv.File("#/" + source.path + ".sloccount")

+ # FIXME: There's probably a better way to force building the .sc

+ if os.path.exists(target.abspath) :

+ os.unlink(target.abspath)

+ return myenv.Command(target, source, [SCons.Action.Action("sloccount --duplicates --wide --details " + source.path + " | grep -v qrc_ > $TARGET", cmdstr = "$GENCOMSTR")])

+ env.AddMethod(createSLOCCount, "SLOCCount")

+ return True

+ def registerTest(env, target, type = "unit", is_checker = False) :

+ if env["TEST_TYPE"] == "all" or env["TEST_TYPE"] == type :

+ if SCons.Util.is_List(target) :

+ cmd = target[0].abspath

+ else :

+ cmd = target.abspath

+ params = ""

+

+ # Special support for unittest checker

+ if is_checker and env.get("checker_report", False) :

+ params = " --xml > " + os.path.join(target[0].dir.path, "checker-report.xml")

+

+ ignore_prefix = ""

+ if env.get("TEST_IGNORE_RESULT", False) :

+ ignore_prefix = "-"

+

+ # Set environment variables for running the test

+ test_env = env.Clone()

+ for i in ["HOME", "USERPROFILE", "APPDATA", "ASAN_OPTIONS", "LSAN_OPTIONS", "SWIFT_NETWORK_TEST_IPV4", "SWIFT_NETWORK_TEST_IPV6"]:

+ if os.environ.get(i, "") :

+ test_env["ENV"][i] = os.environ[i]

+ if env["target"] == "android" :

+ test_env["ENV"]["PATH"] = env["android_sdk_bin"] + ";" + test_env["ENV"]["PATH"]

+ else :

+ if test_env["PLATFORM"] == "darwin" :

+ test_env["ENV"]["DYLD_FALLBACK_LIBRARY_PATH"] = ":".join(map(lambda x : str(x), test_env.get("LIBPATH", [])))

+ elif test_env["PLATFORM"] == "win32" :

+ test_env["ENV"]["PATH"] = ";".join(map(lambda x : str(x), test_env.get("LIBRUNPATH", []))) + ";" + test_env["ENV"]["PATH"]

+

+

+ # Run the test

+ if env["target"] == "android":

+ exec_name = os.path.basename(cmd)

+ test_env.Command("**dummy**", target, SCons.Action.Action(

+ ["adb shell mount -o rw,remount /system",

+ "adb push " + cmd + " /system/bin/" + exec_name,

+ "adb shell SWIFT_CLIENTTEST_JID=\"" + os.getenv("SWIFT_CLIENTTEST_JID") + "\" SWIFT_CLIENTTEST_PASS=\"" + os.getenv("SWIFT_CLIENTTEST_PASS") + "\" " + env.get("TEST_RUNNER", "") + "/system/bin/" + exec_name], cmdstr = "$TESTCOMSTR"))

+ else :

+ test_env.Command("**dummy**", target,

+ SCons.Action.Action(ignore_prefix + env.get("TEST_RUNNER", "") + cmd + " " + params, cmdstr = "$TESTCOMSTR"))

+

+ def registerScriptTests(env, scripts, name, type) :

+ if env["TEST_TYPE"] == "all" or env["TEST_TYPE"] == type :

+ pass

+

+ env.AddMethod(registerTest, "Test")

+ env.AddMethod(registerScriptTests, "ScriptTests")

+ return True

+ if hasattr(shutil, "which"):

+ return shutil.which(program_name)

+ else:

+ path = os.getenv('PATH')

+ for p in path.split(os.path.pathsep):

+ p = os.path.join(p,program_name)

+ if os.path.exists(p) and os.access(p,os.X_OK):

+ return p

+ def captureWinDeployQtMapping(release = True):

+ p = False

+

+ qt_bin_folder = ""

+ if "QTDIR" in env:

+ qt_bin_folder = env["QTDIR"] + "\\bin;"

+

+ environ = {"PATH": qt_bin_folder + os.getenv("PATH"), "TEMP": os.getenv("TEMP"), "TMP": os.getenv("TMP")}

+

+ if release:

+ p = subprocess.Popen(['windeployqt', '--release', '--dry-run', '--list', 'mapping', 'Swift.exe'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=environ)

+ else:

+ p = subprocess.Popen(['windeployqt', '--debug', '--dry-run', '--list', 'mapping', 'Swift.exe'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=environ)

+

+ if p:

+ stdout, stderr = p.communicate()

+

+ mappings = []

+

+ p = re.compile(ur'"([^\"]*)" "([^\"]*)"')

+

+ matches = re.findall(p, stdout)

+ for match in matches:

+ mappings.append(match)

+ return mappings

+ else:

+ return False

+

+ def createWindowsBundleManual(env, bundle, resources = {}, qtplugins = {}, qtlibs = [], qtversion = '4') :

+ all_files = []

+ all_files += env.Install(bundle, bundle + ".exe")

+ for lib in qtlibs :

+ all_files += env.Install(bundle, os.path.join(env["QTDIR"], "bin", lib + ".dll"))

+ plugins_suffix = '4'

+ if qtversion == '5' :

+ plugins_suffix = ''

+ for plugin_type in qtplugins:

+ all_files += env.Install(os.path.join(bundle, plugin_type), [os.path.join(env["QTDIR"], "plugins", plugin_type, "q" + plugin + plugins_suffix + ".dll") for plugin in qtplugins[plugin_type]])

+ for dir, resourceFiles in resources.items() :

+ for resource in resourceFiles :

+ e = env.Entry(resource)

+ if e.isdir() :

+ for subresource in env.Glob(str(e) + "/*") :

+ all_files += env.Install(os.path.join(bundle, dir, e.name), subresource)

+ else :

+ all_files += env.Install(os.path.join(bundle, dir), resource)

+ return all_files

+

+ # This version of uses windeployqt tool

+ def createWindowsBundleWithWinDeployQt(env, bundle, resources = {}, qtplugins = {}, qtlibs = [], qtversion = '4') :

+ assert(qtversion == '5')

+ all_files = []

+

+ # add swift executable

+ all_files += env.Install(bundle, bundle + ".exe")

+

+ # adding resources (swift sounds/images/translations)

+ for dir, resourceFiles in resources.items() :

+ for resource in resourceFiles :

+ e = env.Entry(resource)

+ if e.isdir() :

+ for subresource in env.Glob(str(e) + "/*") :

+ all_files += env.Install(os.path.join(bundle, dir, e.name), subresource)

+ else :

+ all_files += env.Install(os.path.join(bundle, dir), resource)

+

+ qtmappings = captureWinDeployQtMapping()

+ assert(qtmappings)

+

+ # handle core DLLs

+ qt_corelib_regex = re.compile(ur".*bin.*\\(.*)\.dll")

+

+ for qtlib in qtlibs:

+ if qtlib.startswith("Qt5"):

+ (src_path, target_path) = next(((src_path, target_path) for (src_path, target_path) in qtmappings if qt_corelib_regex.match(src_path) and qt_corelib_regex.match(src_path).group(1) == qtlib), (None, None))

+ if src_path != None:

+ all_files += env.Install(bundle, src_path)

+

+ # handle core dependencies

+ for (src_path, target_path) in qtmappings:

+ if qt_corelib_regex.match(src_path) and not qt_corelib_regex.match(src_path).group(1).startswith("Qt5"):

+ all_files += env.Install(bundle, src_path)

+

+ # handle plugins

+ qt_plugin_regex = re.compile(ur".*plugins.*\\(.*)\\(.*)\.dll")

+ for (src_path, target_path) in qtmappings:

+ if qt_plugin_regex.match(src_path):

+ plugin_folder, filename = qt_plugin_regex.match(src_path).groups()

+ try:

+ if plugin_folder in ["audio"] or filename[1:] in qtplugins[plugin_folder]:

+ all_files += env.Install(os.path.join(bundle, plugin_folder), src_path)

+ except:

+ pass

+ return all_files

+

+ def createWindowsBundle(env, bundle, resources = {}, qtplugins = {}, qtlibs = [], qtversion = '4'):

+ if which("windeployqt.exe"):

+ return createWindowsBundleWithWinDeployQt(env, bundle, resources, qtplugins, qtlibs, qtversion)

+ else:

+ return createWindowsBundleManual(env, bundle, resources, qtplugins, qtlibs, qtversion)

+

+ env.AddMethod(createWindowsBundle, "WindowsBundle")

+ return env["PLATFORM"] == "win32"

+ def replacePragmaOnce(env, target, source) :

+ f = open(str(target[0]), 'wb')

+ f.write(source[0].get_contents())

+ f.close()

+ env["BUILDERS"]["WriteVal"] = SCons.Builder.Builder(

+ action = SCons.Action.Action(replacePragmaOnce, cmdstr = "$GENCOMSTR"),

+ single_source = True)

+ return True

+ - Extract the target from the nsis file

+ - When a target is provided use the output function

+ """Add Builders and construction variables for qt to an Environment."""

+ Builder = SCons.Builder.Builder

+ env['NSIS_MAKENSIS'] = 'makensis'

+ env['NSIS_OPTIONS'] = ["/V2"]

+ def winToLocalReformat(path) :

+ return os.path.join(*path.split("\\"))

+ def scanNsisContent(node, env, path, arg):

+ contents = node.get_contents()

+ includes = nsisFiles_re.findall(contents) + nsisIncludes_re.findall(contents)

+ includes = [ winToLocalReformat(include) for include in includes ]

+ return filter(lambda x: x.rfind('*')==-1, includes)

+ nsisscanner = env.Scanner(name = 'nsisfile',

+ function = scanNsisContent,

+ argument = None,

+ skeys = ['.nsi'])

+ nsisbuilder = Builder(

+ action = SCons.Action.Action('$NSIS_MAKENSIS $NSIS_OPTIONS $SOURCE', cmdstr = '$NSISCOMSTR'),

+ source_scanner = nsisscanner,

+ single_source = True

+ )

+ env.Append( BUILDERS={'Nsis' : nsisbuilder} )

+ return True

+ pass

+ pass

+ pass

+ return os.popen('winepath -w "%s"'%path).read().strip().replace('\\','/')

+ header_extensions.append('.H')

+ moc = target[0]

+ cpp = source[0]

+ # looks like cpp.includes is cleared before the build stage :-(

+ # not really sure about the path transformations (moc.cwd? cpp.cwd?) :-/

+ path = SCons.Defaults.CScan.path_function(env, moc.cwd)

+ includes = SCons.Defaults.CScan(cpp, env, path)

+ if not moc in includes:

+ SCons.Warnings.warn(

+ GeneratedMocFileNotIncluded,

+ "Generated moc file '%s' is not included by '%s'" %

+ (str(moc), str(cpp)))

+ for dir in paths:

+ node = node_factory(filename, dir)

+ if node.rexists():

+ return node

+ return None

+ """

+ Callable class, which works as an emitter for Programs, SharedLibraries and

+ StaticLibraries.

+ """

+

+ def __init__(self, objBuilderName):

+ self.objBuilderName = objBuilderName

+

+ def __call__(self, target, source, env):

+ """

+ Smart autoscan function. Gets the list of objects for the Program

+ or Lib. Adds objects and builders for the special qt files.

+ """

+ try:

+ if int(env.subst('$QT4_AUTOSCAN')) == 0:

+ return target, source

+ except ValueError:

+ pass

+ try:

+ debug = int(env.subst('$QT4_DEBUG'))

+ except ValueError:

+ debug = 0

+

+ # some shortcuts used in the scanner

+ splitext = SCons.Util.splitext

+ objBuilder = getattr(env, self.objBuilderName)

+

+ # some regular expressions:

+ # Q_OBJECT detection

+ q_object_search = re.compile(r'[^A-Za-z0-9]Q_OBJECT[^A-Za-z0-9]')

+ # cxx and c comment 'eater'

+ #comment = re.compile(r'(//.*)|(/\*(([^*])|(\*[^/]))*\*/)')

+ # CW: something must be wrong with the regexp. See also bug #998222

+ # CURRENTLY THERE IS NO TEST CASE FOR THAT

+

+ # The following is kind of hacky to get builders working properly (FIXME)

+ objBuilderEnv = objBuilder.env

+ objBuilder.env = env

+ mocBuilderEnv = env.Moc4.env

+ env.Moc4.env = env

+

+ # make a deep copy for the result; MocH objects will be appended

+ out_sources = source[:]

+

+ for obj in source:

+ if isinstance(obj,basestring): # big kludge!

+ print "scons: qt4: '%s' MAYBE USING AN OLD SCONS VERSION AND NOT CONVERTED TO 'File'. Discarded." % str(obj)

+ continue

+ if not obj.has_builder():

+ # binary obj file provided

+ if debug:

+ print "scons: qt: '%s' seems to be a binary. Discarded." % str(obj)

+ continue

+ cpp = obj.sources[0]

+ if not splitext(str(cpp))[1] in cxx_suffixes:

+ if debug:

+ print "scons: qt: '%s' is no cxx file. Discarded." % str(cpp)

+ # c or fortran source

+ continue

+ #cpp_contents = comment.sub('', cpp.get_contents())

+ try:

+ cpp_contents = cpp.get_contents()

+ except: continue # may be an still not generated source

+ h=None

+ for h_ext in header_extensions:

+ # try to find the header file in the corresponding source

+ # directory

+ hname = splitext(cpp.name)[0] + h_ext

+ h = find_file(hname, (cpp.get_dir(),), env.File)

+ if h:

+ if debug:

+ print "scons: qt: Scanning '%s' (header of '%s')" % (str(h), str(cpp))

+ #h_contents = comment.sub('', h.get_contents())

+ h_contents = h.get_contents()

+ break

+ if not h and debug:

+ print "scons: qt: no header for '%s'." % (str(cpp))

+ if h and q_object_search.search(h_contents):

+ # h file with the Q_OBJECT macro found -> add moc_cpp

+ moc_cpp = env.Moc4(h)

+ moc_o = objBuilder(moc_cpp)

+ out_sources.append(moc_o)

+ #moc_cpp.target_scanner = SCons.Defaults.CScan

+ if debug:

+ print "scons: qt: found Q_OBJECT macro in '%s', moc'ing to '%s'" % (str(h), str(moc_cpp))

+ if cpp and q_object_search.search(cpp_contents):

+ # cpp file with Q_OBJECT macro found -> add moc

+ # (to be included in cpp)

+ moc = env.Moc4(cpp)

+ env.Ignore(moc, moc)

+ if debug:

+ print "scons: qt: found Q_OBJECT macro in '%s', moc'ing to '%s'" % (str(cpp), str(moc))

+ #moc.source_scanner = SCons.Defaults.CScan

+ # restore the original env attributes (FIXME)

+ objBuilder.env = objBuilderEnv

+ env.Moc4.env = mocBuilderEnv

+

+ return (target, out_sources)

+ """Not really safe, but fast method to detect the QT library"""

+ if 'QTDIR' in env :

+ return env['QTDIR']

+

+ if 'QTDIR' in os.environ :

+ return os.environ['QTDIR']

+

+ moc = None

+ if env["qt5"]:

+ moc = env.WhereIs('moc-qt5') or env.WhereIs('moc5') or env.WhereIs('moc')

+ else :

+ moc = env.WhereIs('moc-qt4') or env.WhereIs('moc4') or env.WhereIs('moc')

+ if moc:

+ # Test whether the moc command we found is real, or whether it is just the qtchooser dummy.

+ p = subprocess.Popen([moc, "-v"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env["ENV"])

+ p.communicate()

+ if p.returncode == 0:

+ import sys

+ if sys.platform == "darwin" :

+ return ""

+ QTDIR = os.path.dirname(os.path.dirname(moc))

+ return QTDIR

+

+ raise SCons.Errors.StopError(

+ QtdirNotFound,

+ "Could not detect Qt 4 installation")

+ return None

+ """Add Builders and construction variables for qt to an Environment."""

+

+ def locateQt4Command(env, command, qtdir) :

+ if len(qtdir) == 0 :

+ qtdir = "/usr"

+ if env["qt5"]:

+ suffixes = [

+ '-qt5',

+ '-qt5.exe',

+ '5',

+ '5.exe',

+ '',

+ '.exe',

+ ]

+ else :

+ suffixes = [

+ '-qt4',

+ '-qt4.exe',

+ '4',

+ '4.exe',

+ '',

+ '.exe',

+ ]

+ triedPaths = []

+ for suffix in suffixes :

+ fullpath = os.path.join(qtdir,'bin',command + suffix)

+ if os.access(fullpath, os.X_OK) :

+ return fullpath

+ triedPaths.append(fullpath)

+

+ fullpath = env.Detect([command+'-qt4', command+'4', command])

+ if not (fullpath is None) : return fullpath

+

+ raise Exception("Qt4 command '" + command + "' not found. Tried: " + ', '.join(triedPaths))

+

+

+ CLVar = SCons.Util.CLVar

+ Action = SCons.Action.Action

+ Builder = SCons.Builder.Builder

+ splitext = SCons.Util.splitext

+

+ env['QTDIR'] = _detect(env)

+ # TODO: 'Replace' should be 'SetDefault'

+# env.SetDefault(

+ env.Replace(

+ QTDIR = _detect(env),

+ # TODO: This is not reliable to QTDIR value changes but needed in order to support '-qt4' variants

+ QT4_MOC = locateQt4Command(env,'moc', env['QTDIR']),

+ QT4_UIC = locateQt4Command(env,'uic', env['QTDIR']),

+ QT4_RCC = locateQt4Command(env,'rcc', env['QTDIR']),

+ QT4_LUPDATE = locateQt4Command(env,'lupdate', env['QTDIR']),

+ QT4_LRELEASE = locateQt4Command(env,'lrelease', env['QTDIR']),

+ QT4_LIB = '', # KLUDGE to avoid linking qt3 library

+

+ QT4_AUTOSCAN = 1, # Should the qt tool try to figure out, which sources are to be moc'ed?

+

+ # Some QT specific flags. I don't expect someone wants to

+ # manipulate those ...

+ QT4_UICFLAGS = CLVar(''),

+ QT4_MOCFROMHFLAGS = CLVar(''),

+ QT4_MOCFROMCXXFLAGS = CLVar('-i'),

+ QT4_QRCFLAGS = '--compress 9 --threshold 5',

+

+ # suffixes/prefixes for the headers / sources to generate

+ QT4_UISUFFIX = '.ui',

+ QT4_UICDECLPREFIX = 'ui_',

+ QT4_UICDECLSUFFIX = '.h',

+ QT4_MOCHPREFIX = 'moc_',

+ QT4_MOCHSUFFIX = '$CXXFILESUFFIX',

+ QT4_MOCCXXPREFIX = '',

+ QT4_MOCCXXSUFFIX = '.moc',

+ QT4_QRCSUFFIX = '.qrc',

+ QT4_QRCCXXSUFFIX = '$CXXFILESUFFIX',

+ QT4_QRCCXXPREFIX = 'qrc_',

+ QT4_MOCCPPPATH = [],

+ QT4_MOCINCFLAGS = '$( ${_concat("-I", QT4_MOCCPPPATH, INCSUFFIX, __env__, RDirs)} $)',

+

+ # Commands for the qt support ...

+ QT4_UICCOM = '$QT4_UIC $QT4_UICFLAGS -o $TARGET $SOURCE',

+ # FIXME: The -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED flag is a hack to work

+ # around an issue in Qt

+ # See https://bugreports.qt-project.org/browse/QTBUG-22829

+ QT4_MOCFROMHCOM = '$QT4_MOC -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED $QT4_MOCFROMHFLAGS $QT4_MOCINCFLAGS -o $TARGET $SOURCE',

+ QT4_MOCFROMCXXCOM = [

+ '$QT4_MOC -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED $QT4_MOCFROMCXXFLAGS $QT4_MOCINCFLAGS -o $TARGET $SOURCE',

+ Action(checkMocIncluded,None)],

+ QT4_LUPDATECOM = '$QT4_LUPDATE $SOURCE -ts $TARGET',

+ QT4_LRELEASECOM = '$QT4_LRELEASE -silent $SOURCE -qm $TARGET',

+ QT4_RCCCOM = '$QT4_RCC $QT4_QRCFLAGS -name $SOURCE $SOURCE -o $TARGET',

+ )

+ if len(env["QTDIR"]) > 0 :

+ env.Replace(QT4_LIBPATH = os.path.join('$QTDIR', 'lib'))

+

+ # Translation builder

+ tsbuilder = Builder(

+ action = SCons.Action.Action('$QT4_LUPDATECOM'), #,'$QT4_LUPDATECOMSTR'),

+ multi=1

+ )

+ env.Append( BUILDERS = { 'Ts': tsbuilder } )

+ qmbuilder = Builder(

+ action = SCons.Action.Action('$QT4_LRELEASECOM', cmdstr = '$QT4_LRELEASECOMSTR'),

+ src_suffix = '.ts',

+ suffix = '.qm',

+ single_source = True

+ )

+ env.Append( BUILDERS = { 'Qm': qmbuilder } )

+

+ # Resource builder

+ def scanResources(node, env, path, arg):

+ # I've being careful on providing names relative to the qrc file

+ # If that was not needed that code could be simplified a lot

+ def recursiveFiles(basepath, path) :

+ result = []

+ for item in os.listdir(os.path.join(basepath, path)) :

+ itemPath = os.path.join(path, item)

+ if os.path.isdir(os.path.join(basepath, itemPath)) :

+ result += recursiveFiles(basepath, itemPath)

+ else:

+ result.append(itemPath)

+ return result

+ contents = node.get_contents()

+ includes = [included[1] for included in qrcinclude_re.findall(contents)]

+ qrcpath = os.path.dirname(node.path)

+ dirs = [included for included in includes if os.path.isdir(os.path.join(qrcpath,included))]

+ # dirs need to include files recursively

+ for dir in dirs :

+ includes.remove(dir)

+ includes+=recursiveFiles(qrcpath,dir)

+ return includes

+ qrcscanner = SCons.Scanner.Scanner(name = 'qrcfile',

+ function = scanResources,

+ argument = None,

+ skeys = ['.qrc'])

+ qrcbuilder = Builder(

+ action = SCons.Action.Action('$QT4_RCCCOM', cmdstr = '$QT4_RCCCOMSTR'),

+ source_scanner = qrcscanner,

+ src_suffix = '$QT4_QRCSUFFIX',

+ suffix = '$QT4_QRCCXXSUFFIX',

+ prefix = '$QT4_QRCCXXPREFIX',

+ single_source = True

+ )

+ env.Append( BUILDERS = { 'Qrc': qrcbuilder } )

+

+ # Interface builder

+ uic4builder = Builder(

+ action = SCons.Action.Action('$QT4_UICCOM', cmdstr = '$QT4_UICCOMSTR'),

+ src_suffix='$QT4_UISUFFIX',

+ suffix='$QT4_UICDECLSUFFIX',

+ prefix='$QT4_UICDECLPREFIX',

+ single_source = True

+ #TODO: Consider the uiscanner on new scons version

+ )

+ env['BUILDERS']['Uic4'] = uic4builder

+

+ # Metaobject builder

+ mocBld = Builder(action={}, prefix={}, suffix={})

+ for h in header_extensions:

+ act = SCons.Action.Action('$QT4_MOCFROMHCOM', cmdstr = '$QT4_MOCFROMHCOMSTR')

+ mocBld.add_action(h, act)

+ mocBld.prefix[h] = '$QT4_MOCHPREFIX'

+ mocBld.suffix[h] = '$QT4_MOCHSUFFIX'

+ for cxx in cxx_suffixes:

+ act = SCons.Action.Action('$QT4_MOCFROMCXXCOM', cmdstr = '$QT4_MOCFROMCXXCOMSTR')

+ mocBld.add_action(cxx, act)

+ mocBld.prefix[cxx] = '$QT4_MOCCXXPREFIX'

+ mocBld.suffix[cxx] = '$QT4_MOCCXXSUFFIX'

+ env['BUILDERS']['Moc4'] = mocBld

+

+ # er... no idea what that was for

+ static_obj, shared_obj = SCons.Tool.createObjBuilders(env)

+ static_obj.src_builder.append('Uic4')

+ shared_obj.src_builder.append('Uic4')

+

+ # We use the emitters of Program / StaticLibrary / SharedLibrary

+ # to scan for moc'able files

+ # We can't refer to the builders directly, we have to fetch them

+ # as Environment attributes because that sets them up to be called

+ # correctly later by our emitter.

+ env.AppendUnique(PROGEMITTER =[AutomocStatic],

+ SHLIBEMITTER=[AutomocShared],

+ LIBEMITTER =[AutomocStatic],

+ # Of course, we need to link against the qt libraries

+ LIBPATH=["$QT4_LIBPATH"],

+ LIBS=['$QT4_LIB'])

+

+ # TODO: Does dbusxml2cpp need an adapter

+ env.AddMethod(enable_modules, "EnableQt4Modules")

+ import sys

+

+ validModules = [

+ 'QtCore',

+ 'QtGui',

+ 'QtOpenGL',

+ 'Qt3Support',

+ 'QtAssistant',

+ 'QtScript',

+ 'QtDBus',

+ 'QtSql',

+ # The next modules have not been tested yet so, please

+ # maybe they require additional work on non Linux platforms

+ 'QtNetwork',

+ 'QtSvg',

+ 'QtTest',

+ 'QtXml',

+ 'QtXmlPatterns',

+ 'QtUiTools',

+ 'QtDesigner',

+ 'QtDesignerComponents',

+ 'QtWebKit',

+ 'QtHelp',

+ 'QtScript',

+

+ # Qt5 modules

+ 'QtWidgets',

+ 'QtMultimedia',

+ 'QtWebKitWidgets',

+ 'QtWebChannel',

+ ]

+ if sys.platform != "win32" and sys.platform != "darwin" and not crosscompiling :

+ validModules += ['QtX11Extras']

+ staticModules = [

+ 'QtUiTools',

+ ]

+ invalidModules=[]

+ for module in modules:

+ if module not in validModules :

+ invalidModules.append(module)

+ if invalidModules :

+ raise Exception("Modules %s are not Qt4 modules. Valid Qt4 modules are: %s"% (

+ str(invalidModules),str(validModules)))

+

+ moduleDefines = {

+ 'QtScript' : ['QT_SCRIPT_LIB'],

+ 'QtSvg' : ['QT_SVG_LIB'],

+ 'Qt3Support' : ['QT_QT3SUPPORT_LIB','QT3_SUPPORT'],

+ 'QtSql' : ['QT_SQL_LIB'],

+ 'QtXml' : ['QT_XML_LIB'],

+ 'QtOpenGL' : ['QT_OPENGL_LIB'],

+ 'QtGui' : ['QT_GUI_LIB'],

+ 'QtWidgets' : ['QT_WIDGETS_LIB'],

+ 'QtWebKitWidgets' : [],

+ 'QtNetwork' : ['QT_NETWORK_LIB'],

+ 'QtCore' : ['QT_CORE_LIB'],

+ }

+ for module in modules :

+ try : self.AppendUnique(CPPDEFINES=moduleDefines[module])

+ except: pass

+ debugSuffix = ''

+

+

+ include_flag = "-I"

+ if os.path.basename(self["CC"]) in ("gcc", "clang"):

+ include_flag = "-isystem"

+

+

+ if sys.platform != "win32" and sys.platform != "darwin" and not crosscompiling :

+ if self["qt"]:

+ # The user specified qt path in config.py and we are going to use the

+ # installation under that location.

+ UsePkgConfig = False

+ else:

+ # The user did not specify a qt path in config py and we are going to

+ # ask pkg-config for the correct flags.

+ UsePkgConfig = True

+ if not UsePkgConfig:

+ if debug : debugSuffix = '_debug'

+ if version == '4' :

+ self.AppendUnique(CPPFLAGS = [include_flag + os.path.join("$QTDIR", "include", "phonon")])

+ for module in modules :

+ module_str = module

+ if not version == '4' :

+ module_str = module_str.replace('Qt', 'Qt5')

+ self.AppendUnique(LIBS=[module_str+debugSuffix])

+ self.AppendUnique(LIBPATH=[os.path.join("$QTDIR","lib")])

+ self.AppendUnique(CPPFLAGS = [include_flag + os.path.join("$QTDIR","include")])

+ self.AppendUnique(CPPFLAGS = [include_flag + os.path.join("$QTDIR","include", module)])

+ self["QT4_MOCCPPPATH"] = self["CPPPATH"]

+ return

+ else:

+ test_conf = self.Configure()

+ modules_str = " ".join(modules)

+ if not version == '4' :

+ modules_str = modules_str.replace('Qt', 'Qt5')

+

+ # Check if Qt is registered at pkg-config

+ ret = test_conf.TryAction('pkg-config --exists \'%s\'' % modules_str)[0]

+ if ret != 1:

+ test_conf.Finish()

+ raise Exception('Qt installation is missing packages. The following are required: %s' % modules_str)

+ return

+

+ def parse_conf_as_system(env, cmd, unique=1):

+ return env.MergeFlags(cmd.replace("-I/", include_flag + "/"), unique)

+

+ test_conf.env.ParseConfig("pkg-config --cflags --libs " + modules_str, parse_conf_as_system)

+ self["QT4_MOCCPPPATH"] = self["CPPPATH"]

+ test_conf.Finish()

+ return

+

+ if sys.platform == "win32" or crosscompiling :

+ if crosscompiling:

+ transformedQtdir = transformToWinePath(self['QTDIR'])

+ self['QT4_MOC'] = "QTDIR=%s %s"%( transformedQtdir, self['QT4_MOC'])

+ self.AppendUnique(CPPPATH=[os.path.join("$QTDIR","include")])

+ try: modules.remove("QtDBus")

+ except: pass

+ if debug : debugSuffix = 'd'

+ if "QtAssistant" in modules:

+ self.AppendUnique(CPPPATH=[os.path.join("$QTDIR","include","QtAssistant")])

+ modules.remove("QtAssistant")

+ modules.append("QtAssistantClient")

+ if version == '4' :

+ # FIXME: Phonon Hack

+ self.AppendUnique(LIBS=['phonon'+debugSuffix+version])

+ self.AppendUnique(LIBS=[lib+debugSuffix+version for lib in modules if lib not in staticModules])

+ else :

+ self.AppendUnique(LIBS=[lib.replace('Qt', 'Qt5') + debugSuffix for lib in modules if lib not in staticModules])

+ self.PrependUnique(LIBS=[lib+debugSuffix for lib in modules if lib in staticModules])

+ if 'QtOpenGL' in modules:

+ self.AppendUnique(LIBS=['opengl32'])

+ elif version == '5' :

+ self.Append(CPPDEFINES = ["QT_NO_OPENGL"])

+ self.AppendUnique(CPPPATH=[ '$QTDIR/include/'])

+ self.AppendUnique(CPPPATH=[ '$QTDIR/include/'+module for module in modules])

+ if crosscompiling :

+ self["QT4_MOCCPPPATH"] = [

+ path.replace('$QTDIR', transformedQtdir)

+ for path in self['CPPPATH'] ]

+ else :

+ self["QT4_MOCCPPPATH"] = self["CPPPATH"]

+ self.AppendUnique(LIBPATH=[os.path.join('$QTDIR','lib')])

+ self.PrependUnique(LIBS=["shell32"])

+ return

+

+ if sys.platform=="darwin" :

+ if debug : debugSuffix = 'd'

+

+ if len(self["QTDIR"]) > 0 :

+ self.AppendUnique(LIBPATH=[os.path.join('$QTDIR','lib')])

+ self.AppendUnique(LINKFLAGS="-F$QTDIR/lib")

+ self.AppendUnique(CPPFLAGS=["-iframework$QTDIR/lib", include_flag + os.path.join("$QTDIR", "include")])

+ self.Append(LINKFLAGS="-Wl,-rpath,$QTDIR/lib")

+

+ # FIXME: Phonon Hack

+ if version == '4' :

+ self.Append(LINKFLAGS=['-framework', "phonon"])

+

+ for module in modules :

+ if module in staticModules :

+ self.AppendUnique(LIBS=[module+debugSuffix]) # TODO: Add the debug suffix

+ self.AppendUnique(LIBPATH=[os.path.join("$QTDIR","lib")])

+ else :

+ if len(self["QTDIR"]) > 0 :

+ self.Append(CPPFLAGS = [include_flag + os.path.join("$QTDIR", "lib", module + ".framework", "Headers")])

+ else :

+ self.Append(CPPFLAGS = [include_flag + os.path.join("/Library/Frameworks", module + ".framework", "Headers")])

+ self.Append(LINKFLAGS=['-framework', module])

+ if 'QtOpenGL' in modules:

+ self.AppendUnique(LINKFLAGS="-F/System/Library/Frameworks")

+ self.Append(LINKFLAGS=['-framework', 'AGL']) #TODO ughly kludge to avoid quotes

+ self.Append(LINKFLAGS=['-framework', 'OpenGL'])

+ self["QT4_MOCCPPPATH"] = self["CPPPATH"]

+ return _detect(env)

+ Create file 'target' which typically is a textfile. The 'source'

+ may be any combination of strings, Nodes, or lists of same. A

+ 'linesep' will be put between any part written and defaults to

+ os.linesep.

+

+ The only difference between the Textfile builder and the Substfile

+ builder is that strings are converted to Value() nodes for the

+ former and File() nodes for the latter. To insert files in the

+ former or strings in the latter, wrap them in a File() or Value(),

+ respectively.

+

+ The values of SUBST_DICT first have any construction variables

+ expanded (its keys are not expanded). If a value of SUBST_DICT is

+ a python callable function, it is called and the result is expanded

+ as the value. Values are substituted in a "random" order; if any

+ substitution could be further expanded by another subsitition, it

+ is unpredictible whether the expansion will occur.

+ """

+ Fetch the node contents and replace all instances of the keys with

+ their values. For example, if subs is

+ {'%VERSION%': '1.2345', '%BASE%': 'MyProg', '%prefix%': '/bin'},

+ then all instances of %VERSION% in the file will be replaced with

+ 1.2345 and so forth.

+ """

+ contents = node.get_text_contents()

+ if not subs: return contents

+ for (k,v) in subs:

+ contents = re.sub(k, v, contents)

+ return contents

+ # prepare the line separator

+ linesep = env['LINESEPARATOR']

+ if linesep is None:

+ linesep = os.linesep

+ elif is_String(linesep):

+ pass

+ elif isinstance(linesep, Value):

+ linesep = linesep.get_text_contents()

+ else:

+ raise SCons.Errors.UserError(

+ 'unexpected type/class for LINESEPARATOR: %s'

+ % repr(linesep), None)

+

+ # create a dictionary to use for the substitutions

+ if 'SUBST_DICT' not in env:

+ subs = None # no substitutions

+ else:

+ d = env['SUBST_DICT']

+ if is_Dict(d):

+ d = list(d.items())

+ elif is_Sequence(d):

+ pass

+ else:

+ raise SCons.Errors.UserError('SUBST_DICT must be dict or sequence')

+ subs = []

+ for (k,v) in d:

+ if callable(v):

+ v = v()

+ if is_String(v):

+ v = env.subst(v)

+ else:

+ v = str(v)

+ subs.append((k,v))

+

+ # write the file

+ try:

+ fd = open(target[0].get_path(), "wb")

+ except (OSError,IOError), e:

+ raise SCons.Errors.UserError("Can't write target file %s" % target[0])

+ # separate lines by 'linesep' only if linesep is not empty

+ lsep = None

+ for s in source:

+ if lsep: fd.write(lsep)

+ fd.write(_do_subst(s, subs))

+ lsep = linesep

+ fd.close()

+ return "Creating '%s'" % target[0]

+ for elem in sources:

+ if is_Sequence(elem):

+ _convert_list_R(newlist, elem)

+ elif isinstance(elem, Node):

+ newlist.append(elem)

+ else:

+ newlist.append(Value(elem))

+ if len(target) != 1:

+ raise SCons.Errors.UserError("Only one target file allowed")

+ newlist = []

+ _convert_list_R(newlist, source)

+ return target, newlist

+ action = SCons.Action.Action(_action, _strfunc, varlist = _text_varlist),

+ source_factory = Value,

+ emitter = _convert_list,

+ prefix = '$TEXTFILEPREFIX',

+ suffix = '$TEXTFILESUFFIX',

+ )

+ action = SCons.Action.Action(_action, _strfunc, varlist = _subst_varlist),

+ source_factory = SCons.Node.FS.File,

+ emitter = _convert_list,

+ prefix = '$SUBSTFILEPREFIX',

+ suffix = '$SUBSTFILESUFFIX',

+ src_suffix = ['.in'],

+ )

+ env['LINESEPARATOR'] = os.linesep

+ env['BUILDERS']['MyTextfile'] = _text_builder

+ env['TEXTFILEPREFIX'] = ''

+ env['TEXTFILESUFFIX'] = '.txt'

+ env['BUILDERS']['MySubstfile'] = _subst_builder

+ env['SUBSTFILEPREFIX'] = ''

+ env['SUBSTFILESUFFIX'] = ''

+ return 1

+ wixPath = env.get("wix_bindir", "")

+ if len(wixPath) > 0 and wixPath[-1] != "\\":

+ wixPath += "\\"

+ env['WIX_HEAT'] = wixPath + 'heat.exe'

+ env['WIX_HEAT_OPTIONS'] = '-nologo -ag -sfrag -suid -template fragment -dr ProgramFilesFolder'

+ env['WIX_CANDLE'] = wixPath + 'candle.exe'

+ env['WIX_CANDLE_OPTIONS'] = '-nologo'

+ env['WIX_LIGHT'] = wixPath + 'light.exe'

+ env['WIX_LIGHT_OPTIONS'] = '-nologo -ext WixUIExtension'

+

+ def WiX_IncludeScanner(source, env, path, arg):

+ wixIncludeRegexp = re.compile(r'^\s*\<\?include (\S+.wxs)\s*\?\>\S*', re.M)

+ contents = source.get_contents()

+ includes = wixIncludeRegexp.findall(contents)

+ return [ "" + include for include in includes ]

+

+ heat_builder = SCons.Builder.Builder(

+ action = '"$WIX_HEAT" dir "$WIX_SOURCE_OBJECT_DIR" -cg Files $WIX_HEAT_OPTIONS -o ${TARGET} -t Swift\\Packaging\\WiX\\include.xslt',

+ suffix = '.wxi')

+

+

+ candle_scanner = env.Scanner(name = 'wixincludefile',

+ function = WiX_IncludeScanner,

+ argument = None,

+ skeys = ['.wxs'])

+

+ candle_builder = SCons.Builder.Builder(

+ action = '"$WIX_CANDLE" $WIX_CANDLE_OPTIONS ${SOURCES} -o ${TARGET}',

+ src_suffix = '.wxs',

+ suffix = '.wixobj',

+ source_scanner = candle_scanner,

+ src_builder = heat_builder)

+

+

+ light_builder = SCons.Builder.Builder(

+ action = '"$WIX_LIGHT" $WIX_LIGHT_OPTIONS -b "$WIX_SOURCE_OBJECT_DIR" ${SOURCES} -o ${TARGET}',

+ src_suffix = '.wixobj',

+ src_builder = candle_builder)

+

+ env['BUILDERS']['WiX_Heat'] = heat_builder

+ env['BUILDERS']['WiX_Candle'] = candle_builder

+ env['BUILDERS']['WiX_Light'] = light_builder

+ return True

+ tag = git("describe --tags --exact --match \"" + project + "-*\"", root)

+ if tag :

+ return tag.rstrip()[len(project)+1:]

+ tag = git("describe --tags --match \"" + project + "-*\"", root)

+ if tag :

+ m = re.match(project + "-(.*)-(.*)-(.*)", tag)

+ if m :

+ return m.group(1) + "-dev" + m.group(2)

+ return None

+ full_cmd = "git " + cmd

+ p = subprocess.Popen(full_cmd, cwd=root, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=(os.name != "nt"))

+ gitVersion = p.stdout.read()

+ # error = p.stderr.read()

+ # if error:

+ # print "Git error: " + error

+ p.stdin.close()

+ if p.wait() == 0 :

+ return gitVersion

+ return None

+ versionFilename = os.path.join(root, "VERSION." + project)

+ if os.path.isfile(versionFilename) :

+ f = open(versionFilename)

+ version = f.read().strip()

+ f.close()

+ return version

+ gitVersion = getGitBuildVersion(root, project)

+ if gitVersion :

+ return gitVersion

+ return datetime.date.today().strftime("%Y%m%d")

+ version_match = re.match("(\d+)\.(\d+)(.*)", version)

+ major = version_match and int(version_match.group(1)) or 0

+ minor = version_match and int(version_match.group(2)) or 0

+ if version_match and len(version_match.group(3)) == 0 :

+ patch = 60000

+ else :

+ match = re.match("^beta(\d+)(.*)", version_match.group(3))

+ build_string = ""

+ if match :

+ patch = 1000*int(match.group(1))

+ build_string = match.group(2)

+ else :

+ rc_match = re.match("^rc(\d+)(.*)", version_match.group(3))

+ if rc_match :

+ patch = 10000*int(rc_match.group(1))

+ build_string = rc_match.group(2)

+ else :

+ patch = 0

+ alpha_match = re.match("^alpha(.*)", version_match.group(3))

+ if alpha_match :

+ build_string = alpha_match.group(1)

+ if len(build_string) > 0 :

+ build_match = re.match("^-dev(\d+)", build_string)

+ if build_match :

+ patch += int(build_match.group(1))

+ return (major, minor, patch)