import os, sys

FORBIDDEN_INCLUDES = [

]

foundBadHeaders = False

filename = sys.argv[1]

if "3rdParty" in filename or ".sconf" in filename or ".framework" in filename or not filename.endswith(".h") :

if not "Swiften" in filename :

if filename.endswith("Swiften.h") :

file = open(filename, "r")

for line in file.readlines() :

sys.exit(foundBadHeaders)

foundExpandedTabs = False

filename = sys.argv[1]

foundUnregisteredTests = False

for (path, dirs, files) in os.walk(".") :

sys.exit(foundUnregisteredTests)

import os, sys, re, xml.dom.minidom

def getText(nodelist):

desktop_generic_names = set()

desktop_comments = set()

f = open("Swift/resources/swift.desktop", "r")

for l in f.readlines() :

f.close()

for filename in os.listdir("Swift/Translations") :

import subprocess

def print_log(full_log):

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

reParseLicenseCommentBlocks = re.compile(ur'(\/\*\n\s\*\sCopyright \(c\) (?P<startYear>\d\d\d\d)(-(?P<endYear>\d\d\d\d))? (?P<author>[^\n\.]*)\.?\n.\* (?P<license>[^\n]*)\n \* (?P<seeMore>[^\n]+)\n *\*\/)')

class License :

licenses = {

class Copyright :

* Copyright (c) %s %s.

* %s

* %s

""" % (self.year, self.author, licenses[self.license].name, licenses[self.license].file)

class ContentRef :

class CopyrightBlock :

def cref_from_group(match, group):

def parse_file_new(filename):

def get_userinfo() :

def get_copyright(username, email) :

def get_copyright_setting(username, email) :

def check_copyright(filename, hints) :

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

def set_or_update_copyright(filename) :

def print_help() :

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

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

else :

assert(len(sys.argv) == 2)

def isIgnored(file) :

output = []

inputFile = open(sys.argv[1])

inIgnoredFile = False

for line in inputFile.readlines() :

inputFile.close()

outputFile = open(sys.argv[1], 'w')

currentFile = ""

coverage = {}

for line in inputFile.readlines() :

inputFile.close()

totalLines = 0

coveredLines = 0

for c in coverage.values() :

outputFile = open(sys.argv[2], 'w')

outputFile.write(str(coveredLines) + "/" + str(totalLines))

#!/bin/sh

cppcheck $@ \

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

def generate(env) :

<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog" prefer="public">

</catalog>"""

</fop>"""

def exists(env) :

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

def generate(env) :

def exists(env) :

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

def generate(env) :

def exists(env) :

resultDirs = [ d for d in os.listdir(resultsDir) if os.path.isdir(os.path.join(resultsDir, d)) ]

resultDirs.sort()

if len(resultDirs) > 0 :

inPlace = False

if "-i" in sys.argv:

filename_base = os.path.basename(filename)

(filename_name, filename_ext) = os.path.splitext(filename_base)

cpp_stdlib_headers = Set(["algorithm", "fstream", "list", "regex", "typeindex", "array", "functional", "locale", "set", "typeinfo", "atomic", "future", "map", "sstream", "type_traits", "bitset", "initializer_list", "memory", "stack", "unordered_map", "chrono", "iomanip", "mutex", "stdexcept", "unordered_set", "codecvt", "ios", "new", "streambuf", "utility", "complex", "iosfwd", "numeric", "string", "valarray", "condition_variable", "iostream", "ostream", "strstream", "vector", "deque", "istream", "queue", "system_error", "exception", "iterator", "random", "thread", "forward_list", "limits", "ratio", "tuple", "cassert", "ciso646", "csetjmp", "cstdio", "ctime", "cctype", "climits", "csignal", "cstdlib", "cwchar", "cerrno", "clocale", "cstdarg", "cstring", "cwctype", "cfloat", "cmath", "cstddef"])

class HeaderType:

def findHeaderBlock(lines):

def lineToFileName(line):

def fileNameToHeaderType(name):

def serializeHeaderGroups(groups):

def overwriteFile(filename, content):

def cleanHeaderFile(content, headerStart, headerEnd, headerGroups):

def cleanImplementationFile(content, headerStart, headerEnd, headerGroups):

containsComplexPreprocessorDirectives = False

with open(filename) as f:

(headerStart, headerEnd) = findHeaderBlock(content)

headerGroups = {}

for line in content[headerStart:headerEnd]:

if containsComplexPreprocessorDirectives:

if filename_base.endswith(".h"):

only_major = False

if "--major" in sys.argv :

if only_major :

else :

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

if len(sys.argv) != 2 :

output_dir = sys.argv[1]

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

p.stdin.close()

if p.wait() != 0 :

# Get & save the avatars

if not os.path.isdir(output_dir) :

for email, name in authors.items() :

if [ "$SYSTEM_NAME" == "Linux" ]

then

else

fi

vars.Add('linkflags', "Extra linker flags")

vars.Add('ar', "Archiver (ar or lib)")

if os.name == "nt":

vars.Add(BoolVariable("ccache", "Use CCache", "no"))

vars.Add(EnumVariable("test", "Compile and run tests", "none", ["none", "all", "unit", "system"]))

vars.Add(BoolVariable("optimize", "Compile with optimizations turned on", "no"))

vars.Add(BoolVariable("debug", "Compile with debug information", "yes"))

vars.Add(BoolVariable("swift_mobile", "Build mobile Swift", "no"))

vars.Add(BoolVariable("swiften_dll", "Build Swiften as dynamically linked library", "no"))

if os.name != "nt" :

if os.name == "posix" :

if os.name == "mac" or (os.name == "posix" and os.uname()[0] == "Darwin"):

if os.name == "nt" :

if os.name == "nt" :

if os.name == "nt" :

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(PackageVariable("hunspell_prefix", "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(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(BoolVariable("need_idn", "Whether an IDN library is required. Without this, most internal binaries will fail", "true"))

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", os.name == "nt" and "libminiupnpc" or "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", os.name == "nt" and "libnatpmp" or "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("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"))

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

# Set up default build & configure environment

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

env_ENV = {

}

if "MSVC_VERSION" in ARGUMENTS :

else :

Help(vars.GenerateHelpText(env))

# Workaround for missing Visual Studio 2012 support in SCons

# Requires scons to be run from a VS2012 console

if env.get("MSVC_VERSION", "").startswith("11.0") :

# Default environment variables

env["PLATFORM_FLAGS"] = {

}

# Default custom tools

env.Tool("BuildVersion", toolpath = ["#/BuildTools/SCons/Tools"])

env.Tool("Flags", toolpath = ["#/BuildTools/SCons/Tools"])

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

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

env.Tool("SLOCCount", toolpath = ["#/BuildTools/SCons/Tools"])

# Max out the number of jobs

if env["max_jobs"] :

# Set speed options

env.Decider("MD5-timestamp")

# Set the default compiler to CLang on OS X, and set the necessary flags

if env["PLATFORM"] == "darwin" and env["target"] == "native" :

# Set QT_SELECT variable to enable building on systems that have Qt4 and Qt5 installed and use qtselect

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

# Check whether we are running inside scan-build, and override compiler if so

if "CCC_ANALYZER_HTML" in os.environ :

# Override the compiler with custom variables set at config time

if "cc" in env :

if "cxx" in env :

if "ar" in env :

if "link" in env :

for flags_type in ["ccflags", "cxxflags", "linkflags"] :

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

# where you need it

env["OBJCCFLAGS"] = []

if env["optimize"] :

if env["target"] == "xcode" and os.environ["CONFIGURATION"] == "Release" :

if env["debug"] :

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

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

# Link against other versions of the OS X SDKs.

# FIXME: This method does not work anymore, we need to set deployment targets.

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

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

if not env["assertions"] :

# disable file-transfer support on iOS

if env["target"] in ["iphone-device", "iphone-simulator", "xcode"] :

if env["experimental_ft"] :

if env["experimental"] :

# If we build shared libs on AMD64, we need -fPIC.

# This should have no performance impact om AMD64

if env["PLATFORM"] == "posix" and platform.machine() in ["x86_64", "amd64"] :

# Warnings

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

elif env["PLATFORM"] == "hpux" :

elif env["PLATFORM"] == "sunos" :

else :

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

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

if env["PLATFORM"] == "darwin" and not env["target"] in ["iphone-device", "iphone-simulator", "xcode", "android"] :

# Required by boost headers on HP-UX

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

# Testing

env["TEST_TYPE"] = env["test"]

if "check" in ARGUMENTS :

env["checker_report"] = ARGUMENTS.get("checker_report", False)

env["TEST"] = (env["TEST_TYPE"] != "none") or env.GetOption("clean")

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

env["TEST_IGNORE_RESULT"] = "ignore_test_result" in ARGUMENTS

env["TEST_CREATE_LIBRARIES"] = "create_test_libraries" in ARGUMENTS

# Packaging

env["DIST"] = "dist" in ARGUMENTS or env.GetOption("clean")

for path in ["SWIFT_INSTALLDIR", "SWIFTEN_INSTALLDIR", "SLUIFT_INSTALLDIR"] :

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

target = env["target"]

if target in ["iphone-device", "iphone-simulator", "xcode"] :

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

# Android

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

if target in ["android"] :

# CCache

if env.get("ccache", False) :

conf_env = env.Clone()

variant = ""

if env["enable_variants"] :

Return("variant")

# Override SConscript to handle tests

oldSConscript = SConscript

def SConscript(*arguments, **keywords) :

env.SConscript = SConscript

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

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

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

# Pretty output

def colorize(command, target, color) :

if int(ARGUMENTS.get("V", 0)) == 0 and not ARGUMENTS.get("dump_trace", False) :

def checkObjCHeader(context, header) :

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

# Platform configuration

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

if ARGUMENTS.get("force-configure", 0) :

def CheckPKG(context, name):

def CheckVersion(context, library, version, define, header, value) :

def GetVersion(context, define, header, extension = ".c") :

#include <%(header)s>

#include <stdio.h>

int main(int argc, char* argv[]) {

}

""" % { "header" : header, "define": define }, extension)

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

env["HAVE_ZLIB"] = True

zlib_flags = {}

zlib_okay = False

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

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

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

elif zlib_okay :

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

if zlib_okay :

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

else :

if conf.CheckLib("resolv") :

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

if conf.CheckLib("dl") :

if conf.CheckLib("m") :

if conf.CheckLib("c") :

# Even if you find stdc++ on HP-UX, it is the wrong one for aCC

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

conf.Finish()

# Boost

boost_conf_env = conf_env.Clone()

boost_flags = {}

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

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

boost_conf_env.MergeFlags(boost_flags)

conf = Configure(boost_conf_env)

allLibsPresent = True

libNames = []

for (lib, header) in boostLibs :

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

else :

conf.Finish()

# Xss

env["HAVE_XSS"] = 0

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

# GConf

env["HAVE_GCONF"] = 0

if env.get("try_gconf", True) and env["PLATFORM"] != "win32" and env["PLATFORM"] != "darwin" :

# Sparkle

env["HAVE_SPARKLE"] = 0

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

# Growl

env["HAVE_GROWL"] = 0

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

# LibXML

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

if env.get("try_libxml", True) and conf.CheckCHeader("libxml/parser.h") and conf.CheckLib("xml2") :

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

conf.Finish()

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

# Expat

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

# Bundled expat

bundledExpat = False

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

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

# IDN library

use_icu = bool(env["icu"])

icu_prefix = ""

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

icu_flags = {}

if icu_prefix :

icu_conf = Configure(icu_env)

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

icu_conf.Finish()

# LibIDN

libidn_conf_env = conf_env.Clone()

libidn_flags = {}

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

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

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

conf.Finish()

# Fallback to bundled LibIDN

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

# Unbound

if env["unbound"] :

else :

# LibMiniUPnPc

if env["experimental_ft"] :

else :

# LibNATPMP

if env["experimental_ft"] :

else :

# SQLite

if env["experimental"] :

else :

# Lua

lua_conf_env = conf_env.Clone()

lua_flags = {}

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

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

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

else :

conf.Finish()

# Readline

editline_conf_env = conf_env.Clone()

editline_flags = {}

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

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

editline_conf_env.MergeFlags(editline_flags)

conf = Configure(editline_conf_env)

if conf.CheckLibWithHeader(env["editline_libname"], ["stdio.h", "editline/readline.h"], "c") :

conf.Finish()

# Avahi

avahi_conf_env = conf_env.Clone()

avahi_flags = {}

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

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

avahi_conf_env.MergeFlags(avahi_flags)

conf = Configure(avahi_conf_env)

if env.get("try_avahi", True) and conf.CheckCHeader("avahi-client/client.h") and conf.CheckLib("avahi-client") and conf.CheckLib("avahi-common") :

conf.Finish()

# Qt

if env["qt"] :

# OpenSSL

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

#Hunspell

hunspell_env = conf_env.Clone()

hunspell_prefix = isinstance(env.get("hunspell_prefix", False), str) and env["hunspell_prefix"] or ""

hunspell_flags = {}

if hunspell_prefix :

hunspell_env.MergeFlags(hunspell_flags)

env["HAVE_HUNSPELL"] = 0;

if env.get("hunspell_enable", False) :

# Bonjour

if env["PLATFORM"] == "darwin" and env["target"] == "native" :

elif env.get("bonjour", False) :

# Cocoa & IOKit

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

# Qt

try :

except SCons.Errors.StopError:

except Exception as e:

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

# DocBook setup

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

if env.get("docbook_xml") :

if env.get("docbook_xsl") :

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

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

try:

except TypeError:

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

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

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

else :

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

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

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

# Modules

modules = []

if os.path.isdir(Dir("#/3rdParty").abspath) :

for dir in os.listdir(Dir("#").abspath) :

# QA comes last

modules.remove("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"] :

# SLOCCount

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

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

parsers = []

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

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

print " Projects: " + ' '.join(env["PROJECTS"])

print ""

print " XML Parsers: " + ' '.join(parsers)

print " TLS Support: " + (env.get("HAVE_OPENSSL",0) and "OpenSSL" or env.get("HAVE_SECURETRANSPORT",0) and "Secure Transport" or env.get("HAVE_SCHANNEL", 0) and "Schannel" or "Disabled")

print " DNSSD Support: " + (env.get("HAVE_BONJOUR") and "Bonjour" or (env.get("HAVE_AVAHI") and "Avahi" or "Disabled"))

print

import SCons.Util, os.path

def generate(env) :

<array>

</array>\n"""

def exists(env) :

import Version

def generate(env) :

static const char* buildVersion = \"%(buildVersion)s\";\n

#define SWIFT_VERSION_STRING \"%(buildVersion)s\";\n

""" % { "buildVersion" : Version.getBuildVersion(env.Dir("#").abspath, project) }

def exists(env) :

import SCons.Util, os

def generate(env) :

def exists(env) :

import SCons.Util

def generate(env) :

def exists(env) :

import SCons.Util

def generate(env) :

def exists(env) :

import SCons.Util, os.path

def generate(env) :

def exists(env) :

import SCons.Util, os.path, os

def generate(env) :

def exists(env) :

import SCons.Util, os

def generate(env) :

def exists(env) :

import shutil

def which(program_name):

def generate(env) :

def exists(env) :

import SCons.Util

def generate(env) :

def exists(env) :

"""

TODO:

"""

def generate(env) :

def exists(env) :

import SCons.SConf

class ToolQtWarning(SCons.Warnings.Warning):

class GeneratedMocFileNotIncluded(ToolQtWarning):

class QtdirNotFound(ToolQtWarning):

SCons.Warnings.enableWarningClass(ToolQtWarning)

qrcinclude_re = re.compile(r'<file (alias=\"[^\"]*\")?>([^<]*)</file>', re.M)

def transformToWinePath(path) :

header_extensions = [".h", ".hxx", ".hpp", ".hh"]

if SCons.Util.case_sensitive_suffixes('.h', '.H'):

# TODO: The following two lines will work when integrated back to SCons

# TODO: Meanwhile the third line will do the work

#cplusplus = __import__('c++', globals(), locals(), [])

cxx_suffixes = [".c", ".cxx", ".cpp", ".cc"]

def checkMocIncluded(target, source, env):

def find_file(filename, paths, node_factory):

class _Automoc:

AutomocShared = _Automoc('SharedObject')

AutomocStatic = _Automoc('StaticObject')

def _detect(env):

def generate(env):

def enable_modules(self, modules, debug=False, crosscompiling=False, version='4') :

def exists(env):

__doc__ = """

Textfile/Substfile builder for SCons.

"""

__revision__ = "src/engine/SCons/Tool/textfile.py 5357 2011/09/09 21:31:03 bdeegan"

from SCons.Util import is_String, is_Sequence, is_Dict

def _do_subst(node, subs):

def _action(target, source, env):

def _strfunc(target, source, env):

def _convert_list_R(newlist, sources):

def _convert_list(target, source, env):

_common_varlist = ['SUBST_DICT', 'LINESEPARATOR']

_text_varlist = _common_varlist + ['TEXTFILEPREFIX', 'TEXTFILESUFFIX']

_text_builder = SCons.Builder.Builder(

_subst_varlist = _common_varlist + ['SUBSTFILEPREFIX', 'TEXTFILESUFFIX']

_subst_builder = SCons.Builder.Builder(

def generate(env):

def exists(env):

# Local Variables:

# tab-width:4

from subprocess import call

def generate(env) :

def exists(env) :

import subprocess, os, datetime, re, os.path

def getGitBuildVersion(root, project) :

def git(cmd, root) :

def getBuildVersion(root, project) :

def convertToWindowsVersion(version) :

last_version = ""

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

if m :

if project == "" :

if "dev" in version :

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

else :

if last_version != version :

BINARY_FLAGS = ["-framework", "-arch", "-x", "--output-format", "-isystem", "-include"]

if sys.platform == 'win32' :

else :

def is_regexp(x) :

def is_list(l) :

def escape(s) :

def quote_spaces(s) :

def to_list(l) :

def partition(l, f) :

def get_unary_flags(prefix, flags) :

def extract_unary_flags(prefix, flags) :

def extract_unary_flag(prefix, flags) :

def extract_binary_flag(prefix, flags) :

def get_non_flags(flags) :

def extract_non_flags(flags) :

def get_dependencies(target, build_targets) :

def get_built_libs(libs, libpaths, outputs) :

def parse_tool_command(line) :

def rglob(pattern, root = '.') :

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

# Helper for building Ninja files

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

class NinjaBuilder :

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

scons_dependencies = ['SConstruct'] + rglob('SConscript')

def ninja_custom_command(ninja, line) :

CONFIGURATION_FILE = '.scons2ninja.conf'

execfile(CONFIGURATION_FILE)

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

if sys.platform == 'win32' :

else :

ninja.rule('moc',

ninja.rule('rcc',

ninja.rule('uic',

ninja.rule('lrelease',

ninja.rule('ibtool',

ninja.rule('dsymutil',

ninja.rule('generator',

ninja.rule('sdef',

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

# Build Statements

skip_nth_line = -1

stack = ['.']

for line in f.stdout :

if f.wait() != 0 :

# Pass 2: Parse build rules

tools = {}

for line in build_lines :

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

ninja.variable("ninja_required_version", "1.3")