file = open(filename, "r")

for line in file.readlines() :

if not "#include" in line :

continue

if "Base/Log.h" in filename :

continue

for forbiddenInclude, ignores in FORBIDDEN_INCLUDES :

if forbiddenInclude in line and len([x for x in ignores if x in filename]) == 0 :

foundBadHeaders = True

sys.exit(foundBadHeaders)

source = message.getElementsByTagName("source")[0]

sourceText = getText(source.childNodes)

sourcePlaceholders = set(re.findall("%\d+%?", sourceText))

translation = message.getElementsByTagName("translation")[0]

if "type" in translation.attributes.keys() and translation.attributes["type"]. value == "unfinished" :

finished = False

translationText = getText(translation.childNodes)

translationPlaceholders = set(re.findall("%\d+%?", translationText))

if translationPlaceholders != sourcePlaceholders :

if not finished :

if language not in desktop_generic_names and language != "en" :

if language not in desktop_comments and language != "en" :

if not commit[author_bit] in contributors:

contributors[commit[author_bit]] = []

contributors[commit[author_bit]].append(commit[commit_bit])

for contributor in contributors:

print contributor + " has contributed patches " + ", ".join([commit[len(commit_bit):] for commit in contributors[contributor]])

full_swiften_log = subprocess.check_output(["git", "log", "--", "Swiften"])

print_log(full_swiften_log)

full_all_log = subprocess.check_output(["git", "log"])

print_log(full_all_log)

#coding=utf-8

import os, re, datetime, sys, subprocess

DEFAULT_LICENSE = "gpl3"

CONTRIBUTOR_LICENSE = "mit"

LICENSE_DIR = "Documentation/Licenses"

# The following regex parses license comment blocks and its part out of a complete source file.

class License :

def __init__(self, name, file) :

self.name = name

self.file = file

licenses = {

"default": License("All rights reserved.", "See the COPYING file for more information."),

"gpl3" : License("Licensed under the GNU General Public License v3.", "See " + LICENSE_DIR + "/" + "GPLv3.txt" + " for more information."),

username, email = get_userinfo()

copyrightSetting = get_copyright_setting(username, email)

for block in copyrightBlocks :

if block.author.content == copyrightSetting.author:

year = block.yearBegin.content if not block.yearEnd else block.yearEnd.content

if int(year) == copyrightSetting.year:

return True

else :

if hints :

return False

if hints :

return False

else :

if hints :

return False

def replace_data_in_file(filename, begin, end, replaceWith) :

with open(filename, 'r') as file:

content = file.read()

with open(filename, 'w') as file:

file.write(content[:begin] + replaceWith + content[end:])

def set_or_update_copyright(filename) :

if check_copyright(filename, False) :

else :

copyrightBlocks = parse_file_new(filename)

username, email = get_userinfo()

copyrightSetting = get_copyright_setting(username, email)

lastBlock = 0

for block in copyrightBlocks :

if block.author.content == copyrightSetting.author :

if not block.yearEnd :

# replace year with range

# replace end of range with current year

replace_data_in_file(filename, block.yearEnd.begin, block.yearEnd.end, "%s" % str(copyrightSetting.year))

return

lastBlock = block.total.end

# No copyright block found. Append a new one.

replace_data_in_file(filename, lastBlock+1, lastBlock+1, "\n" + str(copyrightSetting))

def print_help() :

Copyrighter.py check-copyright $filename

Cheks for the existence of a copyright comment block.

Copyrighter.py set-copyright $filename

Adds or updates the existing copyright comment block.

License setting:

A users license configuration can be set via the SWIFT_LICENSE_CONFIG environment variable

in the format "$copyright holder|$license", e.g. "Jane Doe|mit". Possible values for

$license are default, mit and gpl.

if sys.argv[1] == "check-copyright" :

file = sys.argv[2]

if (file.endswith(".cpp") or file.endswith(".h")) and not "3rdParty" in file :

if not check_copyright(file, True) :

sys.exit(-1)

elif sys.argv[1] == "set-copyright" :

file = sys.argv[2]

set_or_update_copyright(file)

else :

print_help()

sys.exit(-1)

#!/usr/bin/env python

# Note

# ----

# This script requires:

# - cdb, the Windows command line debugger installed and available in PATH.

import sys

from subprocess import call

from subprocess import Popen, PIPE

import ntpath

import shutil

import re

import urllib2

import os

import gzip

import time

swiftWindowBuildsPathPrefix = os.getenv("SWIFT_DIST")

if swiftWindowBuildsPathPrefix == None :

sys.exit(1)

if len(sys.argv) != 3:

sys.exit(1)

version = sys.argv[1]

minidump_file = sys.argv[2]

minidump_filename = ntpath.basename(minidump_file)

minidump_fullpath = os.path.abspath(minidump_file)

humantext_fullpath = os.path.splitext(minidump_fullpath)[0]+".txt"

symbol_cache_path = os.path.join(os.getenv("TEMP"), "\symbols")

working_folder = "tmp-crash-{0}".format(minidump_filename)

cdbFullCommand = ["cdb", "-i", os.getcwd(), "-y", symbolPath, "-z", minidump_filename, "-srcpath", oldDir, "-logo", humantext_fullpath, "-c", cdbCommand ]

print("Run command: " + str(cdbFullCommand))

call(cdbFullCommand)

# for testing, delete the old folder

try:

shutil.rmtree(working_folder)

except:

# clone local git repository into dedicated directory

call(["git", "clone", ".", working_folder], shell=True)

# git version from swift version

match = re.match( r"(.*)-dev(\d+)", version)

if match:

basetag = match.group(1)

commits = int(match.group(2))

exit_code = process.wait()

commit = output.strip()

assert(len(commit) > 0)

# Create symbol cache directory

if not os.path.exists(symbol_cache_path):

os.makedirs(symbol_cache_path)

call(["git", "-C", working_folder, "checkout", commit])

os.chdir(working_folder)

downloadInstaller(version)

downloadDebugSymbols(version)

unpackInstaller(version)

unpackDebugSymbols(version)

copyMinidump(minidump_fullpath)

import xml.dom.minidom, os, os.path

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

# XSLT processor

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

def generate(env) :

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

if not env.has_key("XSLTSTYLESHEET") :

# Process the XML catalog files

# FIXME: It's probably not clean to do an ENV assignment globally

env["ENV"]["XML_CATALOG_FILES"] = " ".join(env.get("XMLCATALOGS", ""))

# Build the XMLLint command

xmllintcmd = ["$XMLLINT", "--nonet", "--xinclude", "--postvalid", "--noout", "$SOURCE"]

# Build the XSLT command

headerType = fileNameToHeaderType(lineToFileName(line))

#filename = lineToFileName(line)

if headerType in headerGroups:

headerGroups[headerType].append(line)

else:

headerGroups[headerType] = [line]

if containsComplexPreprocessorDirectives:

exit(1)

if filename_base.endswith(".h"):

if not HeaderType.PRAGMA_ONCE in headerGroups:

exit(2)

cleanHeaderFile(content, headerStart, headerEnd, headerGroups)

elif filename_base.endswith(".cpp") or filename_base.endswith(".mm"):

cleanImplementationFile(content, headerStart, headerEnd, headerGroups)

writeAppcastFile(filename=os.path.join(args.outputFolder, "swift-testing-appcast-mac.xml"),

title="Swift Testing Releases",

description="",

regexPattern="^\d+(\.\d+)?(\.\d+)?(beta\d+)?(rc\d+)?$",

appcastURL=urlparse.urljoin(args.downloadsURL, "swift-testing-appcast-mac.xml"),

releases=manualReleases)

writeAppcastFile(filename=os.path.join(args.outputFolder, "swift-development-appcast-mac.xml"),

title="Swift Development Releases",

description="",

appcastURL=urlparse.urljoin(args.downloadsURL, "swift-development-appcast-mac.xml"),

releases=automaticReleases)

if "--major" in sys.argv :

only_major = True

if only_major :

v = Version.getBuildVersion(os.path.dirname(sys.argv[0]) + "/..", sys.argv[1])

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

if version_match :

print version_match.group(1)

else :

else :

print Version.getBuildVersion(os.path.dirname(sys.argv[0]) + "/..", sys.argv[1])

#!/usr/bin/env python

import subprocess, os, sys, hashlib, urllib

GRAVATAR_URL = "http://www.gravatar.com/avatar/%(id)s?d=404"

if len(sys.argv) != 2 :

sys.exit(-1)

output_dir = sys.argv[1]

# Retrieve the list of authors

authors = {}

p = subprocess.Popen("git log --pretty=format:'%ae|%an'", shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=(os.name != "nt"))

for line in p.stdout.readlines() :

author_components = line.rstrip().split("|")

authors[author_components[0]] = author_components[1]

p.stdin.close()

if p.wait() != 0 :

sys.exit(-1)

# Get & save the avatars

if not os.path.isdir(output_dir) :

os.makedirs(output_dir)

for email, name in authors.items() :

filename = os.path.join(output_dir, name + ".png")

if os.path.isfile(filename) :

continue

m = hashlib.md5()

m.update(email)

url = GRAVATAR_URL % {"id" : m.hexdigest()}

f = urllib.urlopen(url)

input = None

if f.getcode() == 200 :

input = f.read()

f.close()

if input :

f = open(filename, "w")

f.write(input)

f.close()

else :

for filename in filenames:

if any(fnmatch.fnmatch(filename, pattern) for pattern in ['*.cpp', '*.h', '*.mm', '*.m', '*.c']):

projectSourceFiles.append(os.path.join(root, filename))

def CopyrightNames(filename):

names = []

with open(filename, 'r') as file:

data = file.read()

names = re.findall(p, data)

return names

names = Set()

for file in projectSourceFiles:

copyrightNames = CopyrightNames(file)

for name in copyrightNames:

names.add(name)

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

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

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

if os.name == "nt" :

if os.name == "nt" :

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

if os.name == "nt" :

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

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

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

vars.Add("openssl_libnames", "Comma-separated openssl library names to override defaults", None)

vars.Add("openssl_include", "Location of OpenSSL include files (if not under (openssl)/include)", None)

vars.Add("openssl_libdir", "Location of OpenSSL library files (if not under (openssl)/lib)", None)

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

vars.Add(BoolVariable("qt5", "Compile in Qt5 mode", "yes"))

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

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

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

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

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

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

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

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

vars.Add(BoolVariable("check_headers", "Independently build compilation units for all Swiften headers for detecting missing dependencies.", "no"))

vars.Add("win_target_arch", "Target architecture for Windows builds. x86 for 32-bit (default) or x86_64 for 64-bit.", "x86")

vars.Add(BoolVariable("install_git_hooks", "Install git hooks", "true"))

vars.Add(BoolVariable("help2man", "Run help2man to geneate man pages", "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)

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]

# This isn't a real flag (yet) AFAIK. Be sure to append it to the CXXFLAGS

# where you need it

env["OBJCCFLAGS"] = []

# Compile code as C++11

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

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

if env["optimize"] :

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

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

else :

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

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

else :

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

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

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

"-Wno-shadow-field", # FIXME: fix source code issues regarding this warning later

"-Wno-unused-template", # FIXME: fix source code issues regarding this warning later

])

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

import sys, os, re, platform

import SCons.SConf

Import("env", "conf_env")

root = Dir("../..").abspath

# Override SConscript to handle tests

oldSConscript = SConscript

env.SConscript = SConscript

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

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

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

return int(ret[1])

else :

return -1

conf = Configure(conf_env, custom_tests = {

'CheckCpp11Support' : checkForCpp11Support,

})

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

Exit(1)

if not conf.CheckCpp11Support() :

Exit(1)

env["HAVE_ZLIB"] = True

zlib_flags = {}

zlib_okay = False

if env.get("zlib_libdir", None) :

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

zlib_okay = True

zlib_okay = True

elif zlib_okay :

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

if (not zlib_okay) and conf.CheckLib("z") :

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

zlib_okay = True

if zlib_okay :

env["ZLIB_FLAGS"] = zlib_flags

elif not env.get("zlib_bundled_enable", True) :

Exit(1)

else :

env["ZLIB_BUNDLED"] = True

if conf.CheckLib("resolv") :

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

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

if conf.CheckLib("pthread") :

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

elif not env.get("boost_bundled_enable", True) :

Exit(1)

else :

env["BOOST_BUNDLED"] = True

boost_version = GetVersion(conf, "BOOST_VERSION", "boost/version.hpp")

if boost_version == 106400 :

#Version 1.64 has some issues with the serialization of boost::optional, see https://svn.boost.org/trac10/ticket/13050

env["BOOST_1_64_DETECTED"] = True

else:

env["BOOST_1_64_DETECTED"] = False

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

# Bundled expat

bundledExpat = False

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

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

env["HAVE_EXPAT"] = 1

env["EXPAT_BUNDLED"] = True

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

# IDN library

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

env["NEED_IDN"] = env.get("need_idn", True)

env["LIBIDN_FLAGS"].update(libidn_flags)

conf.Finish()

# Fallback to bundled LibIDN

if not env.get("HAVE_ICU", False) and not env.get("HAVE_LIBIDN", False) :

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

env["HAVE_LIBIDN"] = 1

env["LIBIDN_BUNDLED"] = 1

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

Exit(1)

else:

# Unbound

if env["unbound"] :

env["LDNS_BUNDLED"] = 1

env["UNBOUND_BUNDLED"] = 1

else :

env["LDNS_FLAGS"] = {}

env["UNBOUND_FLAGS"] = {}

lua_conf_env.MergeFlags(lua_flags)

conf = Configure(lua_conf_env)

if not env.get("lua_force_bundled", False) and conf.CheckLibWithHeader(env["lua_libname"], "lua.hpp", "cxx", autoadd = 0) :

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 :

env["LUA_FLAGS"].update(lua_flags)

else :

env["LUA_BUNDLED"] = 1

conf.Finish()

# Readline

editline_conf_env = conf_env.Clone()

editline_flags = {}

if env.get("editline_libdir", None) :

env["HAVE_AVAHI"] = True

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

env["AVAHI_FLAGS"].update(avahi_flags)

conf.Finish()

# Qt

if env["qt"] :

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

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:

else:

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)

# Qt

try :

myenv = env.Clone()

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

env["HAVE_QT"] = True

except SCons.Errors.StopError:

env["HAVE_QT"] = False

except Exception as e:

env["HAVE_QT"] = False

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

# DocBook setup

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

if env.get("docbook_xml") :

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

if env.get("docbook_xsl") :

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

# Set up git hooks

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

try:

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

except TypeError:

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

# Replace #pragma once with proper guards on platforms that require it

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

if ARGUMENTS.get("replace_pragma_once", False) :

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

else :

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)

# Modules

modules = []

if os.path.isdir(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)

# QA comes last

modules.remove("QA")

modules.append("QA")

# Flags

env["PROJECTS"] = [m for m in modules if m not in ["Documentation", "QA", "SwifTools"] and not m.startswith("3rdParty")]

for stage in ["flags", "build"] :

env["SCONS_STAGE"] = stage

# SLOCCount

if ARGUMENTS.get("sloccount", False) :

for project in env["PROJECTS"] :

env.SLOCCount("#/" + project)

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

# Print summary

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

parsers = []

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

parsers.append("LibXML")

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

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

Exit(1)

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"

if handlesXMPPURIs :

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

<array>

<dict>

<key>CFBundleURLName</key>

<string>XMPP URL</string>

<key>CFBundleURLSchemes</key>

<array>

<string>xmpp</string>

</array>

</dict>

</array>\n"""

if sparklePublicDSAKey :

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

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)

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

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

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

# continue with other files

errors.extend(err.args[0])

try:

shutil.copystat(src, dst)

except WindowsError:

# can't copy file access times on Windows

pass

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

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

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

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

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

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

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

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

def exists(env) :

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

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

import SCons.Action

import SCons.Builder

import SCons.Defaults

import SCons.Scanner

import SCons.Tool

import SCons.Util

import SCons.SConf

# 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

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:

continue

if not obj.has_builder():

# binary obj file provided

if debug:

continue

cpp = obj.sources[0]

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

if debug:

# c or fortran source

continue

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

try:

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:

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

break

if not h and debug:

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:

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:

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

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

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(

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

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

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)

lsep = linesep

fd.close()

def _strfunc(target, source, env):

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

def _convert_list_R(newlist, sources):

for elem in sources:

if is_Sequence(elem):

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(

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

def exists(env) :

return True

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

return None

def git(cmd, root) :

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:

p.stdin.close()

if p.wait() == 0 :

return gitVersion

return None

def getBuildVersion(root, project) :

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

if os.path.isfile(versionFilename) :

f = open(versionFilename)

last_version = ""

m = re.match("([\w-]+) \((.*)-\d+\)", last_version_line)

if m :

project = m.group(1)

last_version = m.group(2)

if project == "" :

project="swift-im"

distribution = "development"

elif "beta" in version or "rc" in version :

distribution = "beta development"

else :

distribution = "release beta development"

if last_version != version :

changelog = open(sys.argv[1])

changelog_data = changelog.read()

changelog.close()

changelog = open(sys.argv[1], "w")

changelog.write(project + " (" + version + "-1)" + " " + distribution + "; urgency=low\n\n")

changelog.write(" * Upstream development snapshot\n\n")

changelog.write(" -- Swift Package Maintainer <packages@swift.im> " + email.utils.formatdate() + "\n")

changelog.write("\n")

changelog.write(changelog_data)

changelog.close()

#!/usr/bin/env python

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

#

# scons2ninja: A script to create a Ninja build file from SCons.

#

# Copyright (c) 2013 Remko Tronçon

# Licensed under the simplified BSD license.

# See COPYING for details.

#

result += "\n"

result += self.pools + "\n"

result += self.rules + "\n"

result += self._build + "\n"

return result

def to_string(self, lst, quote = False) :

if is_list(lst) :

if quote :

else :

if is_regexp(lst) :

return ' '.join([escape(x) for x in self.targets if lst.match(x)])

return escape(lst)

def get_flags_variable(self, flags_type, flags) :

if len(flags) == 0 :

return ''

if flags_type not in self._flags :

self._flags[flags_type] = {}

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

# Rules

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

ninja = NinjaBuilder()

ninja.pool('scons_pool', depth = 1)

if sys.platform == 'win32' :

command = '$cl /showIncludes $clflags -c $in /Fo$out',

description = 'CXX $out')

ninja.rule('link',

command = '$link $in $linkflags $libs /out:$out',

description = 'LINK $out')

ninja.rule('link_mt',

command = '$link $in $linkflags $libs /out:$out ; $mt $mtflags',

f = subprocess.Popen(scons_generate_cmd, stdout = subprocess.PIPE, stderr = subprocess.PIPE, shell=True)

stage = 'preamble'

skip_nth_line = -1

stack = ['.']

for line in f.stdout :

line = line.rstrip()

# Skip lines if requested from previous command

if skip_nth_line >= 0 :

if skip_nth_line == 0 :

continue

if line.startswith('scons: done building targets') :

break

if stage == "preamble" :

# Pass all lines from the SCons configuration step to output

if re.match("^scons: Building targets ...", line) :

elif stage == "dependencies" :

if not re.match('^[\s|]+\+\-', line) :

# Work around bug in SCons that splits output over multiple lines

continue

level = line.index('+-') / 2

filename = line[level*2+2:]

if filename.startswith('[') :

# Check if we use the 'fixed' format which escapes filenamenames

if filename.startswith('\'') and filename.endswith('\'') :

filename = eval(filename)

if level < len(stack) :

stack = stack[0:level]

elif level > len(stack) :

if level != len(stack) + 1 :

# Skip absolute paths

if not os.path.isabs(filename) :

target = stack[-1]

if target not in dependencies :

dependencies[target] = []

dependencies[target].append(filename)

previous_filename = filename

if f.wait() != 0 :

print f.stderr.read()

exit(-1)

# Pass 2: Parse build rules

tools = {}

for line in build_lines :

# Custom python function

m = re.match('^(\w+)\(\[([^\]]*)\]', line)

if m :

ninja.build(out, 'lib', files, libflags = flags)

elif tool == 'link':

objects, flags = partition(flags, lambda x: x.endswith('.obj') or x.endswith('.res'))

out, flags = extract_unary_flag("/out:", flags)

libs, flags = partition(flags, lambda x: not x.startswith("/") and x.endswith(".lib"))

libpaths = get_unary_flags("/libpath:", flags)

deps = get_built_libs(libs, libpaths, ninja.targets)

if out in mtflags :

libs = libs, linkflags = flags, mtflags = mtflags[out])

else :

libs = libs, linkflags = flags)

elif tool == 'rc':

out, flags = extract_unary_flag("/fo", flags)

files, flags = extract_non_flags(flags)

ninja.build(out, 'rc', files[0], order_deps = '_generated_headers', rcflags = flags)

elif tool == 'mt':

# Already handled

elif tool == 'dsymutil':

out, flags = extract_binary_flag("-o", flags)

files, flags = extract_non_flags(flags)

ninja.build(out, 'dsymutil', files, dsymutilflags = flags)

elif tool == 'sdef' :

source = flags[0];

outdir, flags = extract_binary_flag("-o", flags)

basename, flags = extract_binary_flag("--basename", flags)

basename = basename,

outdir = outdir)

elif not ninja_custom_command(ninja, line) :

raise Exception("Unknown tool: '" + line + "'")

# Phony target for all generated headers, used as an order-only depency from all C/C++ sources

ninja.build('_generated_headers', 'phony', ninja.header_targets())

# Regenerate build.ninja file