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

vars.Add(PathVariable("vcredist", "MSVC redistributable dir", None, PathVariable.PathAccept))

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(PackageVariable("openssl", "OpenSSL location", "yes"))

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

vars.Add(BoolVariable("openssl_force_bundled", "Force use of the bundled OpenSSL", "no"))

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(PackageVariable("hunspell", "Hunspell location", False))

vars.Add(PathVariable("boost_includedir", "Boost headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("boost_libdir", "Boost library location", None, PathVariable.PathAccept))

vars.Add(BoolVariable("boost_bundled_enable", "Allow use of bundled Boost as last resort", "true"))

vars.Add(PathVariable("zlib_includedir", "Zlib headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("zlib_libdir", "Zlib library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("zlib_libfile", "Zlib library file (full path to file)", None, PathVariable.PathAccept))

vars.Add(BoolVariable("zlib_bundled_enable", "Allow use of bundled Zlib as last resort", "true"))

vars.Add(BoolVariable("try_gconf", "Try configuring for GConf?", "true"))

vars.Add(BoolVariable("try_libxml", "Try configuring for libXML?", "true"))

vars.Add(BoolVariable("try_expat", "Try configuring for expat?", "true"))

vars.Add(PathVariable("expat_includedir", "Expat headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("expat_libdir", "Expat library location", None, PathVariable.PathAccept))

vars.Add("expat_libname", "Expat library name", os.name == "nt" and "libexpat" or "expat")

vars.Add(PackageVariable("icu", "ICU library location", "no"))

vars.Add(BoolVariable("libidn_bundled_enable", "Allow use of bunded Expat", "true"))

vars.Add(BoolVariable("try_libidn", "Try configuring for LibIDN?", "true"))

vars.Add(PathVariable("libidn_includedir", "LibIDN headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libidn_libdir", "LibIDN library location", None, PathVariable.PathAccept))

vars.Add("libidn_libname", "LibIDN library name", os.name == "nt" and "libidn" or "idn")

vars.Add(PathVariable("libminiupnpc_includedir", "LibMiniUPNPC headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libminiupnpc_libdir", "LibMiniUPNPC library location", None, PathVariable.PathAccept))

vars.Add("libminiupnpc_libname", "LibMiniUPNPC library name", "libminiupnpc" if os.name == "nt" else "miniupnpc")

vars.Add(PathVariable("libnatpmp_includedir", "LibNATPMP headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libnatpmp_libdir", "LibNATPMP library location", None, PathVariable.PathAccept))

vars.Add("libnatpmp_libname", "LibNATPMP library name", "libnatpmp" if os.name == "nt" else "natpmp")

vars.Add(PathVariable("sqlite_includedir", "SQLite headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("sqlite_libdir", "SQLite library location", None, PathVariable.PathAccept))

vars.Add("sqlite_libname", "SQLite library name", os.name == "nt" and "libsqlite3" or "sqlite3")

vars.Add("sqlite_force_bundled", "Force use of the bundled SQLite", None)

vars.Add(PathVariable("lua_includedir", "Lua headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("lua_libdir", "Lua library location", None, PathVariable.PathAccept))

vars.Add("lua_libname", "Lua library name", "liblua" if os.name == "nt" else "lua")

vars.Add("lua_force_bundled", "Force use of the bundled Lua", None)

vars.Add(PathVariable("editline_includedir", "Readline headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("editline_libdir", "Readline library location", None, PathVariable.PathAccept))

vars.Add("editline_libname", "Readline library name", "libedit" if os.name == "nt" else "edit")

vars.Add(BoolVariable("try_avahi", "Try configuring for avahi?", "true"))

vars.Add(PathVariable("avahi_includedir", "Avahi headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("avahi_libdir", "Avahi library location", None, PathVariable.PathAccept))

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

vars.Add(BoolVariable("qt5", "Compile in Qt5 mode", "no")) # TODO: auto-detect this

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("install_git_hooks", "Install git hooks", "true"))

conf = Configure(libxml_env, custom_tests = {"CheckVersion": CheckVersion})

if conf.CheckCHeader("libxml/parser.h") and conf.CheckLib("xml2") :

# and conf.CheckVersion("LibXML", "2.6.23", "LIBXML_VERSION", "libxml/xmlversion.h", 20623):

env["HAVE_LIBXML"] = 1

env["LIBXML_FLAGS"] = { "CPPPATH": ["/usr/include/libxml2"], "LIBS": ["xml2"] }

conf.Finish()

# Expat

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

expat_conf_env = conf_env.Clone()

expat_flags = {}

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

expat_flags["LIBPATH"] = [env["expat_libdir"]]

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

expat_flags["CPPPATH"] = [env["expat_includedir"]]

expat_conf_env.MergeFlags(expat_flags)

conf = Configure(expat_conf_env)

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

print "Expat or LibXML not found. Using bundled Expat"

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

env["HAVE_EXPAT"] = 1

env["EXPAT_BUNDLED"] = True

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

# IDN library

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

# ICU

icu_env = conf_env.Clone()

use_icu = bool(env["icu"])

icu_prefix = ""

if isinstance(env["icu"], str) :

icu_prefix = env["icu"]

icu_flags = {}

if icu_prefix :

icu_flags = { "CPPPATH": [os.path.join(icu_prefix, "include")] }

icu_flags["LIBPATH"] = [os.path.join(icu_prefix, "lib")]

icu_env.MergeFlags(icu_flags)

icu_conf = Configure(icu_env)

if use_icu and icu_conf.CheckCHeader("unicode/usprep.h") :

env["HAVE_ICU"] = 1

env["ICU_FLAGS"] = icu_flags

env["ICU_FLAGS"]["LIBS"] = ["icuuc"]

icu_conf.Finish()

# LibIDN

libidn_conf_env = conf_env.Clone()

libidn_flags = {}

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

libidn_flags["LIBPATH"] = [env["libidn_libdir"]]

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

libidn_flags["CPPPATH"] = [env["libidn_includedir"]]

libidn_conf_env.MergeFlags(libidn_flags)

conf = Configure(libidn_conf_env)

if env.get("try_libidn", True) and not env.get("HAVE_ICU") and conf.CheckCHeader("idna.h") and conf.CheckLib(env["libidn_libname"]) :

env["HAVE_LIBIDN"] = 1

env["LIBIDN_FLAGS"] = { "LIBS": [env["libidn_libname"]] }

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

print "Error: ICU and LIBIDN not found, and libidn_bundled_enable is false"

Exit(1)

# Unbound

if env["unbound"] :

env["LDNS_BUNDLED"] = 1

env["UNBOUND_BUNDLED"] = 1

else :

env["LDNS_FLAGS"] = {}

env["UNBOUND_FLAGS"] = {}

# LibMiniUPnPc

if env["experimental_ft"] :

libminiupnpc_flags = {"CPPPATH": ["/usr/include/miniupnpc/"]}

libminiupnpc_conf_env = conf_env.Clone()

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

libminiupnpc_flags["LIBPATH"] = [env["libminiupnpc_libdir"]]

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

libminiupnpc_flags["CPPPATH"] = [env["libminiupnpc_includedir"]]

libminiupnpc_conf_env.MergeFlags(libminiupnpc_flags)

conf = Configure(libminiupnpc_conf_env)

if conf.CheckCHeader("miniupnpc.h") and conf.CheckLib(env["libminiupnpc_libname"]) and False :

# ^ False because APIs aren't stable

env["HAVE_LIBMINIUPNPC"] = 1

env["LIBMINIUPNPC_FLAGS"] = { "LIBS": ["miniupnpc"] }

env["LIBMINIUPNPC_FLAGS"].update(libminiupnpc_flags)

else :

env["LIBMINIUPNPC_BUNDLED"] = 1

conf.Finish()

else :

env["LIBMINIUPNPC_FLAGS"] = {}

# LibNATPMP

if env["experimental_ft"] :

libnatpmp_flags = {}

libnatpmp_conf_env = conf_env.Clone()

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

/*

* Copyright (c) 2012 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/IDN/PlatformIDNConverter.h>

#if defined(HAVE_LIBIDN)

#include <Swiften/IDN/LibIDNConverter.h>

#elif defined(HAVE_ICU)

#include <Swiften/IDN/ICUConverter.h>

#endif

namespace Swift {

IDNConverter* PlatformIDNConverter::create() {

#if defined(HAVE_LIBIDN)

return new LibIDNConverter();

#elif defined(HAVE_ICU)

return new ICUConverter();

#else

#error "No IDN implementation"

return 0;

#endif

}

}

Import("swiften_env", "env")

objects = swiften_env.SwiftenObject(["IDNConverter.cpp"])

myenv = swiften_env.Clone()

if myenv.get("HAVE_ICU") :

myenv.MergeFlags(swiften_env["ICU_FLAGS"])

myenv.Append(CPPDEFINES = ["HAVE_ICU"])

objects += myenv.SwiftenObject(["ICUConverter.cpp"])

if myenv.get("HAVE_LIBIDN") :

myenv.MergeFlags(swiften_env["LIBIDN_FLAGS"])

myenv.Append(CPPDEFINES = ["HAVE_LIBIDN"])

objects += myenv.SwiftenObject(["LibIDNConverter.cpp"])

objects += myenv.SwiftenObject(["PlatformIDNConverter.cpp"])

swiften_env.Append(SWIFTEN_OBJECTS = [objects])

if env["TEST"] :

test_env = myenv.Clone()

test_env.UseFlags(swiften_env["CPPUNIT_FLAGS"])

env.Append(UNITTEST_OBJECTS = test_env.SwiftenObject([

File("UnitTest/IDNConverterTest.cpp"),

]))