- '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, platform = ARGUMENTS.get("PLATFORM", None))

- SCons.SConf.SetCacheMode("force")

- return int(ret[1])

- return -1

- icu_prefix = env["icu"]

- env["LDNS_BUNDLED"] = 1

- env["UNBOUND_BUNDLED"] = 1

- env["LDNS_FLAGS"] = {}

- env["UNBOUND_FLAGS"] = {}

- for project in env["PROJECTS"] :

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

- 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" : unichr(0xA9) + " 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

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

- 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

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