-import sys, os

-sys.path.append(Dir("BuildTools/SCons").abspath)

-import SCons.SConf

-

-################################################################################

-# Build variables

-################################################################################

-

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

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

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

-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" if os.name != "nt" else "no"))

-vars.Add(BoolVariable("warnings", "Compile with warnings turned on",

- "yes" if os.name != "nt" else "no"))

-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"]))

-if os.name != "nt" :

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

-if os.name == "posix" :

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

-if os.name == "mac" or (os.name == "posix" and os.uname()[0] == "Darwin"):

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

-if os.name == "nt" :

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

-if os.name == "nt" :

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

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

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

-

-################################################################################

-# Set up default build & configure environment

-################################################################################

-

-env = Environment(CPPPATH = "#", ENV = {'PATH' : os.environ['PATH']}, variables = vars)

-

-Help(vars.GenerateHelpText(env))

-

-env.Alias("dist", ["."])

-

-# Default custom tools

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

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

-env.Tool("BuildVersion", 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"])

-

-# Override SConscript to handle tests

-oldSConscript = SConscript

-def SConscript(*arguments, **keywords) :

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

- return apply(oldSConscript, arguments, keywords)

-

-# Max out the number of jobs

-if env["max_jobs"] :

- try :

- import multiprocessing

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

- except NotImplementedError :

- pass

-

-# Default compiler flags

-env["CCFLAGS"] = env.get("ccflags", [])

-env["LINKFLAGS"] = env.get("linkflags", [])

-if env["optimize"] :

- env.Append(CCFLAGS = "-O2")

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

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

- env.Append(LINKFLAGS = ["/INCREMENTAL:NO", "/LTCG"])

-

-if env["debug"] :

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

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

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

- 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 = [

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

- "-arch", "i386",

- "-arch", "ppc"])

- env.Append(LINKFLAGS = [

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

- "-Wl", "-syslibroot,/Developer/SDKs/MacOSX10.4u.sdk",

- "-arch", "i386",

- "-arch", "ppc"])

-

-if env["warnings"] :

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

- env.Append(CCFLAGS = ["/Wall"])

- else :

- env.Append(CCFLAGS = ["-W", "-Wall"])

- #env.Append(CCFLAGS = ["-W", "-Wall", "-Wredundant-decls", "-pedantic", "-Wno-long-long", "-Woverloaded-virtual", "-Wundef", "-Wfloat-equal", "-Wold-style-cast"])

-

-if env.get("coverage", 0) :

- 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", "dnsapi", "ws2_32", "wsock32"])

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

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

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

-

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

- env.Append(FRAMEWORKS = ["IOKit", "AppKit"])

-

-# Testing

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

-env.Alias("check", ".")

-if "check" in ARGUMENTS or "check" in COMMAND_LINE_TARGETS :

- env["TEST_TYPE"] = "unit"

-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 "

-

-# Packaging

-if ARGUMENTS.get("SWIFT_INSTALLDIR", "") :

- env["SWIFT_INSTALLDIR"] = Dir(ARGUMENTS["SWIFT_INSTALLDIR"]).abspath

-

-# cross-compiling

-target = env["target"]

-if target in ("iphone-device", "iphone-simulator"):

- if target == "iphone-device":

- sdkPart = "iPhoneOS"

- env["CC"] = "/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/arm-apple-darwin9-gcc-4.0.1"

- env["CXX"] = "/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/arm-apple-darwin9-g++-4.0.1"

- env["PATH"] = "/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/"

- env["LD"] = env["CC"]

-# env["openssl"] = "#/3rdParty/openssl-0.9.8l-arm"

- targetIncludesArch = "arm"

-

- if target == "iphone-simulator":

- sdkPart = "iPhoneSimulator"

- env.Append(CCFLAGS = ["-arch", "i386"])

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

- targetIncludesArch = "i686"

-

- sdkVer = "3.0"

- sdk = "/Developer/Platforms/" + sdkPart + ".platform/Developer/SDKs/" + sdkPart + sdkVer + ".sdk"

-

- env["FRAMEWORKS"] = ["CoreFoundation", "Foundation", "UIKit", "CoreGraphics"]

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

- env["CPPPATH"] = ["/Users/kismith/devel/swift/iPhone/Swiftly/swift/", "/Developer/Platforms/" + sdkPart + ".platform/Developer/usr/lib/gcc/" + targetIncludesArch + "-apple-darwin9/4.0.1/include/", sdk + "/usr/include", sdk + "/usr/include/c++/4.0.0/" + targetIncludesArch + "-apple-darwin9", sdk + "/usr/include/c++/4.0.0", "/Developer/Platforms/" + sdkPart + ".platform/Developer/usr/include/"]

-

-# end cross compiling stuff

-

-

-conf_env = env.Clone()

-

-Export("env")

-Export("conf_env")

-

-

-################################################################################

-# Extend the default build environment (not affecting the configure env)

-#

-# Keeping both environments separated mostly because of SCons Issue 2391,

-# although it doesn't hurt to separate them (e.g. not have pretty printed

-# strings in config.log)

-################################################################################

-

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

-# env["MSVC_BATCH"] = 1

-

-# Pretty output

-def colorize(command, target, color) :

- 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

-

-if int(ARGUMENTS.get("V", 0)) == 0:

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

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

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

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

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

- 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["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")

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

-

-def checkObjCHeader(context, header) :

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

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

- context.Result(ret)

- return ret

-

-################################################################################

-# Platform configuration

-################################################################################

-

-if ARGUMENTS.get("force-configure", 0) :

- SCons.SConf.SetCacheMode("force")

-

-conf = Configure(conf_env)

-

-if not conf.CheckCXX() or not conf.CheckCC() :

- print "Error: You need a working compiler"

- Exit(1)

-

-if conf.CheckLib("z") :

- env.Append(LIBS = "z")

- env["ZLIB_FLAGS"] = ""

-else :

- SConscript("#/3rdParty/ZLib/SConscript")

-

-if conf.CheckLib("dl") :

- env.Append(LIBS = ["dl"])

-

-if conf.CheckLib("c") :

- env.Append(LIBS = ["c"])

-

-if conf.CheckLib("resolv") :

- env.Append(LIBS = ["resolv"])

-

-# Expat

-if conf.CheckCHeader("expat.h") and conf.CheckLib("expat") :

- env["HAVE_EXPAT"] = 1

- env["EXPAT_FLAGS"] = { "LIBS": ["expat"] }

-

-conf.Finish()

-

-# Xss

-env["HAVE_XSS"] = 0

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

- xss_flags = {

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

- "LIBS": ["X11", "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()

-

-# Sparkle

-env["HAVE_SPARKLE"] = 0

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

- sparkle_flags = {

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

- "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"] = "/Library/Frameworks/Sparkle.framework"

- conf.Finish()

-

-# LibXML

-conf = Configure(conf_env)

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

- env["HAVE_LIBXML"] = 1

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

-conf.Finish()

-

-if not env.get("HAVE_LIBXML", 0) :

- libxml_env = conf_env.Clone()

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

- conf = Configure(libxml_env)

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

- env["HAVE_LIBXML"] = 1

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

- conf.Finish()

-

-# Bundled expat

-bundledExpat = False

-if not env.get("HAVE_EXPAT", 0) :

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

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

- env["HAVE_EXPAT"] = 1

- bundledExpat = True

-

-# Qt

-if env["qt"] :

- env["QTDIR"] = env["qt"]

-

-# OpenSSL

-openssl_env = conf_env.Clone()

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

-openssl_prefix = env["openssl"] if isinstance(env["openssl"], str) else ""

-openssl_flags = {}

-if openssl_prefix :

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

- if 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

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

- env["OPENSSL_FLAGS"]["LIBS"] = ["libeay32MT", "ssleay32MT"]

- else:

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

-else :

- env["OPENSSL_FLAGS"] = ""

-

-openssl_conf.Finish()

-

-# Bonjour

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

- env["HAVE_BONJOUR"] = 1

-elif env.get("bonjour", False) :

- 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()

-

-################################################################################

-# Project files

-# FIXME: We need to explicitly list the order of libraries here, because of

-# the exported FLAGS. We should put FLAGS in separate SConscript files, and

-# read these in before anything else, such that we don't need to manually

-# list modules in order.

-################################################################################

-

-# Third-party modules

-SConscript(dirs = [

- "#/3rdParty/CppUnit",

- "#/3rdParty/Boost",

- "#/3rdParty/LibIDN"

- ])

-

-if env.get("target", 0) == "native":

- SConscript(dirs = [

- "#/3rdParty/CAres",

- "#/3rdParty/SQLite"

- ])

-

-# Checker

-SConscript(dirs = ["#/QA/Checker"], test_only = True)

-

-# Libraries

-SConscript(dirs = [

- "#/Swiften",

- "#/SwifTools"

- ])

-

-# Projects

-for dir in os.listdir(Dir("#").abspath) :

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

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

- continue

- if dir in ["QA", "Swiften", "SwifTools"] :

- continue

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

- if os.path.isfile(sconscript) :

- SConscript(sconscript)

-

-# Unit test runner

-SConscript(dirs = ["#/QA/UnitTest"], test_only = True)

-

-################################################################################

-# Print summary

-################################################################################

-

-print

-print " Build Configuration"

-print " -------------------"

-

-parsers = []

-if env.get("HAVE_LIBXML", 0):

- parsers.append("LibXML")

-if env.get("HAVE_EXPAT", 0):

- parsers.append("Expat")

- if bundledExpat:

- parsers.append("(Bundled)")

-print " XML Parsers: " + ' '.join(parsers)

-

-print " TLS Support: " + ("OpenSSL" if env.get("HAVE_OPENSSL",0) else "Disabled")

-print " DNSSD Support: " + ("Bonjour" if env.get("HAVE_BONJOUR") else ("Avahi" if env.get("HAVE_AVAHI") else "Disabled"))

-print

-import SCons.Util

-

-def generate(env) :

- def createAppBundle(env, bundle, version = "1.0", resources = [], frameworks = [], info = {}) :

- 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" : unichr(0xA9) + " 2009 Swift Development Team.\nAll Rights Reserved."

- }

- 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"

- plist += """</dict>

- </plist>

- """

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

-

- for resource in resources :

- env.Install(resourcesDir, resource)

-

- for framework in frameworks :

- env.Install(frameworksDir, framework)

-

- return env.Dir(bundleDir)

-

- env.AddMethod(createAppBundle, "AppBundle")

-

-

-def exists(env) :

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

-import SCons.Util

-

-import Version

-

-def generate(env) :

- def createBuildVersion(env, target, version = None) :

- buildVersion = """#pragma once

-

-static const char* buildVersion = \"%(buildVersion)s\";\n

-""" % { "buildVersion" : Version.getBuildVersion(version) }

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

-

- env.AddMethod(createBuildVersion, "BuildVersion")

-

-

-def exists(env) :

- return true

-import SCons.Util

-

-def generate(env) :

- 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)

-

-def exists(env) :

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

-import SCons.Util

-

-def generate(env) :

- def registerTest(env, target, type = "unit") :

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

- cmd = target[0].abspath if SCons.Util.is_List(target) else target.abspath

- env.Command("**dummy**", target,

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

-

- env.AddMethod(registerTest, "Test")

-

-def exists(env) :

- return True

-import SCons.Util, os

-

-def generate(env) :

- def createWindowsBundle(env, bundle, resources = [], qtimageformats = [], qtlibs = []) :

- env.Install(bundle, bundle + ".exe")

- for lib in qtlibs :

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

- env.Install(os.path.join(bundle, "imageformats"), [os.path.join(env["QTDIR"], "plugins", "imageformats", "q" + codec + "4.dll") for codec in qtimageformats])

-

- for resource in resources :

- env.Install(bundle, resource)

-

- env.AddMethod(createWindowsBundle, "WindowsBundle")

-

-def exists(env) :

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

-

-import SCons.Util

-

-def generate(env) :

- def writeVal(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(writeVal, cmdstr = "$GENCOMSTR"),

- single_source = True)

-

-def exists(env) :

- return True

-import re, os

-import SCons.Util

-nsisFiles_re = re.compile(r'^\s*File "([^"]*)"', re.M)

-

-"""

-TODO:

- - Extract the target from the nsis file

- - When a target is provided use the output function

-"""

-

-def generate(env) :

- """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)

- 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} )

-

-def exists(env) :

- return True

-

-

-"""SCons.Tool.qt

-

-Tool-specific initialization for Qt.

-

-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, 2002, 2003, 2004, 2005, 2006, 2007 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.

-#

-

-__revision__ = "/home/scons/scons/branch.0/branch.96/baseline/src/engine/SCons/Tool/qt.py 0.96.92.D001 2006/04/10 23:13:27 knight"

-

-import os.path

-import re

-

-import SCons.Action

-import SCons.Builder

-import SCons.Defaults

-import SCons.Scanner

-import SCons.Tool

-import SCons.Util

-

-class ToolQtWarning(SCons.Warnings.Warning):

- pass

-

-class GeneratedMocFileNotIncluded(ToolQtWarning):

- pass

-

-class QtdirNotFound(ToolQtWarning):

- pass

-

-SCons.Warnings.enableWarningClass(ToolQtWarning)

-

-qrcinclude_re = re.compile(r'<file>([^<]*)</file>', re.M)

-

-def transformToWinePath(path) :

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

-

-header_extensions = [".h", ".hxx", ".hpp", ".hh"]

-if SCons.Util.case_sensitive_suffixes('.h', '.H'):

- header_extensions.append('.H')

-# TODO: The following two lines will work when integrated back to SCons

-# TODO: Meanwhile the third line will do the work

-#cplusplus = __import__('c++', globals(), locals(), [])

-#cxx_suffixes = cplusplus.CXXSuffixes

-cxx_suffixes = [".c", ".cxx", ".cpp", ".cc"]

-

-def checkMocIncluded(target, source, env):

- 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)))

-

-def find_file(filename, paths, node_factory):

- for dir in paths:

- node = node_factory(filename, dir)

- if node.rexists():

- return node

- return None

-

-class _Automoc:

- """

- 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)

-

-AutomocShared = _Automoc('SharedObject')

-AutomocStatic = _Automoc('StaticObject')

-

-def _detect(env):

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

- try: return env['QTDIR']

- except KeyError: pass

-

- try: return os.environ['QTDIR']

- except KeyError: pass

-

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

- if moc:

- import sys

- if sys.platform == "darwin" :

- return ""

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

- SCons.Warnings.warn(

- QtdirNotFound,

- "QTDIR variable is not defined, using moc executable as a hint (QTDIR=%s)" % QTDIR)

- return QTDIR

-

- raise SCons.Errors.StopError(

- QtdirNotFound,

- "Could not detect Qt 4 installation")

- return None

-

-def generate(env):

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

-

- def locateQt4Command(env, command, qtdir) :

- if len(qtdir) == 0 :

- qtdir = "/usr"

- 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 = '',

-

- # 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',

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

- QT4_MOCFROMCXXCOM = [

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

- Action(checkMocIncluded,None)],

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

- QT4_LRELEASECOM = '$QT4_LRELEASE $SOURCE',

- 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'),# , '$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 = 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")

-

-def enable_modules(self, modules, debug=False, crosscompiling=False) :

- 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',

- ]

- 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'],

- 'QtNetwork' : ['QT_NETWORK_LIB'],

- 'QtCore' : ['QT_CORE_LIB'],

- }

- for module in modules :

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

- except: pass

- debugSuffix = ''

-

- if sys.platform in ["linux2"] and not crosscompiling :

- if debug : debugSuffix = '_debug'

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

- for module in modules :

- self.AppendUnique(LIBS=[module+debugSuffix])

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

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

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

- self["QT4_MOCCPPPATH"] = self["CPPPATH"]

- 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")

- # FIXME: Phonon Hack

- self.AppendUnique(LIBS=['phonon4'+debugSuffix])

- self.AppendUnique(LIBS=[lib+'4'+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'])

- 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')])

- 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="-F$QTDIR/lib")

- self.AppendUnique(LINKFLAGS="-L$QTDIR/lib") #TODO clean!

-

- # FIXME: Phonon Hack

- 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 = ["-I" + os.path.join("$QTDIR", "lib", module + ".framework", "Versions", "4", "Headers")])

- else :

- self.Append(CPPFLAGS = ["-I" + os.path.join("/Library/Frameworks", module + ".framework", "Versions", "4", "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"]

-

-def exists(env):

- return _detect(env)

-import subprocess, os, datetime

-

-def getGitBuildVersion() :

- p = subprocess.Popen("git rev-parse HEAD", shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=(os.name != "nt"))

- gitVersion = p.stdout.read().rstrip()[0:7]

- p.stdin.close()

- return gitVersion if p.wait() == 0 else None

-

-def getBuildVersion(version = None) :

- if version :

- return version

- gitVersion = getGitBuildVersion()

- if gitVersion :

- return gitVersion

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