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)

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

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)

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

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

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

# 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

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

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

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

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)

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)

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

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

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 :

def CopyrightNames(filename):

names = []

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

data = file.read()

names = re.findall(p, data)

return names

names = Set()

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

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

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

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

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

# Override SConscript to handle tests

oldSConscript = SConscript

env.SConscript = SConscript

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

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

#

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

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

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

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

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

# Qt

if env["qt"] :

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

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

# TLS backend selection

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

env["OPENSSL_FLAGS"] = {}

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

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

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

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

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

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

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

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

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

</dict>

</array>\n"""

if sparklePublicDSAKey :

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

env.Install(resourcesDir, sparklePublicDSAKey)

plist += """</dict>

</plist>

"""

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

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

if p:

stdout, stderr = p.communicate()

mappings = []

matches = re.findall(p, stdout)

for match in matches:

mappings.append(match)

return mappings

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:

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

env.AddMethod(createWindowsBundle, "WindowsBundle")

def exists(env) :

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

__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

# 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

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 :

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

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]

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

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

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"

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.

#

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

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

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

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)

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 = {}

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)

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