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)