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

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

+ if handlesXMPPURIs :

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

+ <dict>

+ <key>CFBundleURLName</key>

+ <string>XMPP URL</string>

+ <key>CFBundleURLSchemes</key>

+ <array>

+ <string>xmpp</string>

+ </array>

+ </dict>

+ 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.Install(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

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

+ 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

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

+ self.AppendUnique(LIBS=test_conf.env["LIBS"], LIBPATH=test_conf.env["LIBPATH"], CPPPATH=test_conf.env["CPPPATH"])

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

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

+

+ # 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", "Versions", version, "Headers")])

+ else :

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