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