-CLangDiagnosticsFlags

-CLangDiagnosticsFlagsTool.sh

-CLangDiagnosticsFlagsTool

-clang-diagnostics-overview.*

-/*

- * Copyright (c) 2011 Remko Tronçon

- * Licensed under the GNU General Public License v3.

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

- */

-

-#include <iostream>

-#include <set>

-#include <vector>

-#include <cassert>

-#include <boost/algorithm/string/predicate.hpp>

-#include <boost/graph/graph_traits.hpp>

-#include <boost/graph/adjacency_list.hpp>

-#include <boost/graph/topological_sort.hpp>

-#include <boost/graph/topological_sort.hpp>

-#include <boost/graph/graphviz.hpp>

-

-// -----------------------------------------------------------------------------

-// Include diagnostics data from CLang

-// -----------------------------------------------------------------------------

-

-#define DIAG(name, a, b, c, d, e, f, g) name,

-

-namespace diag {

- enum LexKinds {

-#include <clang/Basic/DiagnosticLexKinds.inc>

-#include <clang/Basic/DiagnosticParseKinds.inc>

-#include <clang/Basic/DiagnosticCommonKinds.inc>

-#include <clang/Basic/DiagnosticDriverKinds.inc>

-#include <clang/Basic/DiagnosticFrontendKinds.inc>

-#include <clang/Basic/DiagnosticSemaKinds.inc>

- };

-}

-

-#define GET_DIAG_ARRAYS

-#include <clang/Basic/DiagnosticGroups.inc>

-#undef GET_DIAG_ARRAYS

-

-struct DiagTableEntry {

- const char* name;

- const short* array;

- const short* group;

-};

-

-static const DiagTableEntry diagnostics[] = {

-#define GET_DIAG_TABLE

-#include <clang/Basic/DiagnosticGroups.inc>

-#undef GET_DIAG_TABLE

-};

-static const size_t diagnostics_count = sizeof(diagnostics) / sizeof(diagnostics[0]);

-

-// -----------------------------------------------------------------------------

-

-using namespace boost;

-

-struct Properties {

- Properties() : have(false), implicitHave(false), dontWant(false), implicitDontWant(false), ignored(false), available(false), missing(false), redundant(false), alreadyCovered(false) {

- }

-

- std::string name;

- bool have;

- bool implicitHave;

- bool dontWant;

- bool implicitDontWant;

- bool ignored;

- bool available;

- bool missing;

- bool redundant;

- bool alreadyCovered;

-};

-

-class GraphVizLabelWriter {

- public:

- GraphVizLabelWriter(const std::vector<Properties>& properties) : properties(properties) {

- }

-

- template <class VertexOrEdge>

- void operator()(std::ostream& out, const VertexOrEdge& v) const {

- std::string color;

- if (properties[v].missing) {

- color = "orange";

- }

- else if (properties[v].redundant) {

- color = "lightblue";

- }

- else if (properties[v].have) {

- color = "darkgreen";

- }

- else if (properties[v].implicitHave) {

- color = "green";

- }

- else if (properties[v].dontWant) {

- color = "red";

- }

- else if (properties[v].implicitDontWant) {

- color = "pink";

- }

- else if (properties[v].ignored) {

- color = "white";

- }

- else if (properties[v].available) {

- color = "yellow";

- }

- else {

- assert(false);

- }

- out << "[label=" << escape_dot_string(properties[v].name) << " fillcolor=\"" << color << "\" style=filled]";

- }

-

- private:

- const std::vector<Properties> properties;

-};

-

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

- // Parse command-line arguments

- std::set<std::string> have;

- std::set<std::string> dontWant;

- std::string outputDir;

- for (int i = 1; i < argc; ++i) {

- std::string arg(argv[i]);

- if (starts_with(arg, "-W")) {

- have.insert(arg.substr(2, arg.npos));

- }

- else if (starts_with(arg, "-w")) {

- dontWant.insert(arg.substr(2, arg.npos));

- }

- else if (starts_with(arg, "-O")) {

- outputDir = arg.substr(2, arg.npos) + "/";

- }

- }

-

- // Build the graph and initialize properties

- typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;

- typedef graph_traits<Graph>::vertex_descriptor Vertex;

- Graph g(diagnostics_count);

- std::vector<Properties> properties(num_vertices(g));

- for (size_t i = 0; i < diagnostics_count; ++i) {

- std::string name(diagnostics[i].name);

- properties[i].name = name;

- properties[i].implicitHave = properties[i].have = have.find(name) != have.end();

- properties[i].implicitDontWant = properties[i].dontWant = dontWant.find(name) != dontWant.end();

- properties[i].ignored = diagnostics[i].group == 0 && diagnostics[i].array == 0;

- properties[i].alreadyCovered = false;

- properties[i].available = true;

- for (const short* j = diagnostics[i].group; j && *j != -1; ++j) {

- add_edge(i, *j, g);

- }

- }

-

- // Sort the diagnostics

- std::list<Vertex> sortedDiagnostics;

- boost::topological_sort(g, std::front_inserter(sortedDiagnostics));

-

- // Propagate dontWant and have properties down

- for(std::list<Vertex>::const_iterator i = sortedDiagnostics.begin(); i != sortedDiagnostics.end(); ++i) {

- graph_traits<Graph>::adjacency_iterator adjacentIt, adjacentEnd;

- for (tie(adjacentIt, adjacentEnd) = adjacent_vertices(*i, g); adjacentIt != adjacentEnd; ++adjacentIt) {

- properties[*adjacentIt].implicitDontWant = properties[*i].implicitDontWant || properties[*adjacentIt].implicitDontWant;

- properties[*adjacentIt].implicitHave = properties[*i].implicitHave || properties[*adjacentIt].implicitHave;

- }

- }

-

- // Propagate 'available' property upwards

- for(std::list<Vertex>::const_reverse_iterator i = sortedDiagnostics.rbegin(); i != sortedDiagnostics.rend(); ++i) {

- properties[*i].available = properties[*i].available && !properties[*i].implicitDontWant;

- graph_traits<Graph>::in_edge_iterator edgesIt, edgesEnd;

- graph_traits<Graph>::edge_descriptor edge;

- for (tie(edgesIt, edgesEnd) = in_edges(*i, g); edgesIt != edgesEnd; ++edgesIt) {

- properties[source(*edgesIt, g)].available = properties[source(*edgesIt, g)].available && properties[*i].available;

- }

- }

-

- // Collect missing & redundant flags

- std::set<std::string> missing;

- std::set<std::string> redundant;

- for(std::list<Vertex>::const_iterator i = sortedDiagnostics.begin(); i != sortedDiagnostics.end(); ++i) {

- bool markChildrenCovered = true;

- if (properties[*i].alreadyCovered) {

- if (properties[*i].have) {

- properties[*i].redundant = true;

- redundant.insert(properties[*i].name);

- }

- }

- else {

- if (properties[*i].available) {

- if (!properties[*i].implicitHave && !properties[*i].ignored) {

- properties[*i].missing = true;

- missing.insert(properties[*i].name);

- }

- }

- else {

- markChildrenCovered = false;

- }

- }

- if (markChildrenCovered) {

- graph_traits<Graph>::adjacency_iterator adjacentIt, adjacentEnd;

- for (tie(adjacentIt, adjacentEnd) = adjacent_vertices(*i, g); adjacentIt != adjacentEnd; ++adjacentIt) {

- properties[*adjacentIt].alreadyCovered = true;

- }

- }

- }

-

- // Write information

- if (!missing.empty()) {

- std::cout << "Missing diagnostic flags: ";

- for(std::set<std::string>::const_iterator i = missing.begin(); i != missing.end(); ++i) {

- std::cout << "-W" << *i << " ";

- }

- std::cout<< std::endl;

- }

-

- if (!redundant.empty()) {

- std::cout << "Redundant diagnostic flags: ";

- for(std::set<std::string>::const_iterator i = redundant.begin(); i != redundant.end(); ++i) {

- std::cout << "-W" << *i << " ";

- }

- std::cout<< std::endl;

- }

-

- // Write graphviz file

- if (!outputDir.empty()) {

- std::ofstream f((outputDir + "clang-diagnostics-overview.dot").c_str());

- write_graphviz(f, g, GraphVizLabelWriter(properties));

- f.close();

- }

-

- return 0;

-}

-Import("env")

-

-#myenv = Environment()

-#myenv.Append(CPPPATH = ["."])

-#myenv.Program("CLangDiagnosticsFlagsTool", ["CLangDiagnosticsFlagsTool.cpp"])

-#

-#disabledDiagnostics = ["-wunreachable-code", "-wunused-macros", "-wmissing-noreturn", "-wlong-long", "-wcast-align", "-wglobal-constructors", "-wmissing-prototypes", "-wpadded", "-wshadow"]

-#clangDiagnosticsFlagsToolCommand = "BuildTools/CLang/CLangDiagnosticsFlagsTool -O" + env.Dir(".").abspath + " " + " ".join(disabledDiagnostics) + " "

-#clangDiagnosticsFlagsToolCommand += " ".join([flag for flag in env["CXXFLAGS"] if flag.startswith("-W")])

-#clangDiagnosticsFlagsToolCommand += "\n"

-#clangDiagnosticsFlagsToolCommand += "dot -Tpng " + env.Dir(".").abspath + "/clang-diagnostics-overview.dot > " + env.Dir(".").abspath + "/clang-diagnostics-overview.png\n"

-#v = env.WriteVal("#/BuildTools/CLang/CLangDiagnosticsFlagsTool.sh", env.Value(clangDiagnosticsFlagsToolCommand))

-#env.AddPostAction(v, Chmod(v[0], 0755))

-#

-#

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

- if "3rdParty" in path or ".sconf" in path or ".framework" in path :

- continue

- if not "Swiften" in path :

- continue

-

- for filename in [os.path.join(path, file) for file in files if file.endswith(".h")] :

- file = open(filename, "r")

- for line in file.readlines() :

- for include in ["iostream", "algorithm", "cassert", "boost/bind.hpp", "boost/filesystem.hpp", "Base/foreach.h", "Base/Log.h", "boost/date_time/date_time.hpp", "boost/filesystem/filesystem.hpp"] :

- if "#include" in line and include in line and not "Base/Log" in filename :

- print "Found " + include + " include in " + filename

- foundBadHeaders = True

-if (filename.endswith(".cpp") or filename.endswith(".h")) and not "3rdParty" in filename :

- file = open(filename, "r")

- contents = []

- contentsChanged = False

- for line in file.readlines() :

- newline = ""

- previousChar = None

- pastInitialSpace = False

- for char in line :

- if not pastInitialSpace :

- if char == ' ' and previousChar == ' ' :

- contentsChanged = True

- previousChar = '\t'

- continue

- pastInitialSpace = (char != ' ')

- if previousChar :

- newline += previousChar

- previousChar = char

- if previousChar :

- newline += previousChar

- contents.append(newline)

- file.close()

- if contentsChanged :

- sys.exit(-1)

- if not "3rdParty" in path :

- for filename in [os.path.join(path, file) for file in files if file.endswith("Test.cpp") and file != "IdleQuerierTest.cpp" and file != "NotifierTest.cpp" and file != "ClientTest.cpp" and file != "ConnectivityTest.cpp" and file != "ReconnectTest.cpp"] :

- file = open(filename, "r")

- isRegistered = False

- registeredTests = set()

- declaredTests = set()

- for line in file.readlines() :

- m = re.match("\s*CPPUNIT_TEST_SUITE_REGISTRATION\((.*)\)", line)

- if m :

- isRegistered = True

- m = re.match("\s*CPPUNIT_TEST\((.*)\)", line)

- if m :

- registeredTests.add(m.group(1))

- continue

- m = re.match("\s*void (test.*)\(\)", line)

- if m :

- declaredTests.add(m.group(1))

- if not isRegistered :

- print filename + ": Registration missing"

- foundUnregisteredTests = True

- if registeredTests - declaredTests != set([]) :

- print filename + ": " + str(registeredTests - declaredTests)

- foundUnregisteredTests = True

- file.close()

- text = ""

- for node in nodelist:

- if node.nodeType == node.TEXT_NODE:

- text += node.data

- return text

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

- if m :

- desktop_generic_names.add(m.group(1))

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

- if m :

- desktop_comments.add(m.group(1))

- m = re.match("swift_(.*)\.ts", filename)

- if m :

- language = m.group(1)

- finished = True

- f = open("Swift/Translations/" + filename, "r")

- document = xml.dom.minidom.parse(f)

- f.close()

- for message in document.getElementsByTagName("message") :

- source = message.getElementsByTagName("source")[0]

- sourceText = getText(source.childNodes)

- sourcePlaceholders = set(re.findall("%\d+%?", sourceText))

- translation = message.getElementsByTagName("translation")[0]

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

- print "[Error] " + filename + ": Placeholder mismatch in translation '" + sourceText + "'"

- if not finished :

- print "[Warning] " + filename + ": Unfinished"

- if language not in desktop_generic_names and language != "en" :

- print "[Warning] GenericName field missing in desktop entry for " + language

- if language not in desktop_comments and language != "en" :

- print "[Warning] Comment field missing in desktop entry for " + language

- def __init__(self, name, file) :

- self.name = name

- self.file = file

- "gpl3" : License("GNU General Public License v3", "GPLv3.txt"),

- "mit" : License("MIT License", "MIT.txt"),

- }

-

- def __init__(self, author, year, license) :

- self.author = author

- self.year = year

- self.license = license

-

- def to_string(self, comment_chars) :

- return "\n".join([

- comment_chars[0],

- comment_chars[1] + " Copyright (c) %(year)s %(name)s" % {"year" : self.year, "name" : self.author },

- comment_chars[1] + " Licensed under the " + licenses[self.license].name + ".",

- comment_chars[1] + " See " + LICENSE_DIR + "/" + licenses[self.license].file + " for more information.",

- comment_chars[2],

- "\n"])

-

-def get_comment_chars_for_filename(filename) :

- return ("/*", " *", " */")

-

-def get_comment_chars_re_for_filename(filename) :

- comment_chars = get_comment_chars_for_filename(filename)

- return "|".join(comment_chars).replace("*", "\\*")

-

-def parse_file(filename) :

- file = open(filename)

- copyright_text = []

- prolog = ""

- epilog = ""

- inProlog = True

- inCopyright = False

- inEpilog = False

- for line in file.readlines() :

- if inProlog :

- if line.startswith("#!") or len(line.strip()) == 0 :

- prolog += line

- continue

- else :

- inProlog = False

- inCopyright = True

-

- if inCopyright :

- if re.match(get_comment_chars_re_for_filename(filename), line) != None :

- copyright_text.append(line.rstrip())

- continue

- else :

- inCopyright = False

- inEpilog = True

- if len(line.strip()) == 0 :

- continue

-

- if inEpilog :

- epilog += line

- continue

-

- file.close()

-

- # Parse the copyright

- copyright = None

- if len(copyright_text) == 5 :

- comment_chars = get_comment_chars_for_filename(filename)

- if copyright_text[0] == comment_chars[0] and copyright_text[4] == comment_chars[2] :

- matchstring = "(" + get_comment_chars_re_for_filename(filename) + ") Copyright \(c\) (?P<startYear>\d\d\d\d)(-(?P<endYear>\d\d\d\d))? (?P<author>.*)"

- m = re.match(matchstring, copyright_text[1])

- if m != None :

- # FIXME: Do better copyright reconstruction here

- copyright = True

- if not copyright :

- epilog = "\n".join(copyright_text) + epilog

- return (prolog, copyright, epilog)

- p = subprocess.Popen("git config user.name", shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=(os.name != "nt"))

- username = p.stdout.read().rstrip()

- p.stdin.close()

- if p.wait() != 0 :

- return None

- p = subprocess.Popen("git config user.email", shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=(os.name != "nt"))

- email = p.stdout.read().rstrip()

- p.stdin.close()

- if p.wait() != 0 :

- return None

- return (username, email)

- if email in ["git@el-tramo.be", "git@kismith.co.uk"] :

- license = DEFAULT_LICENSE

- else :

- license = CONTRIBUTOR_LICENSE

- return Copyright(username, datetime.date.today().strftime("%Y"), license)

-

-def check_copyright(filename) :

- (prolog, copyright, epilog) = parse_file(filename)

- if copyright == None :

- print "No copyright found in: " + filename

- #print "Please run '" + sys.argv[0] + " set-copyright " + filename + "'"

- return False

- else :

- return True

-

-def set_copyright(filename, copyright) :

- (prolog, c, epilog) = parse_file(filename)

- comment_chars = get_comment_chars_for_filename(filename)

- copyright_text = copyright.to_string(comment_chars)

- file = open(filename, "w")

- if prolog != "":

- file.write(prolog)

- file.write(copyright_text)

- if epilog != "" :

- file.write(epilog)

- file.close()

- file = sys.argv[2]

- if (file.endswith(".cpp") or file.endswith(".h")) and not "3rdParty" in file :

- if not check_copyright(file) :

- sys.exit(-1)

- (username, email) = get_userinfo()

- copyright = get_copyright(username, email)

- set_copyright(sys.argv[2], copyright)

- print "Unknown command: " + sys.argv[1]

- sys.exit(-1)

- return (file.find("/Swiften/") == -1 and file.find("/Slimber/") == -1 and file.find("/Swift/") == -1) or (file.find("/UnitTest/") != -1 or file.find("/QA/") != -1)

-

- if inIgnoredFile :

- if line == "end_of_record\n" :

- inIgnoredFile = False

- else :

- if line.startswith("SF:") and isIgnored(line) :

- inIgnoredFile = True

- m = re.match("SF:(.*)", line)

- if m :

- line = "SF:" + os.path.realpath(m.group(1)) + "\n"

- output.append(line)

- line = line.strip()

- m = re.match("^SF:(.*)", line)

- if m :

- currentFile = m.group(1)

- else :

- m = re.match("^DA:(\d+),(\d+)", line)

- currentFileCoverage = coverage.get(currentFile, {})

- line = int(m.group(1))

- count = int(m.group(2))

- currentFileCoverage[line] = currentFileCoverage.get(line, 0) + count

- coverage[currentFile] = currentFileCoverage

- totalLines += len(c)

- for l in c.values() :

- if l > 0 :

- coveredLines += 1

- --enable=all \

- --inline-suppr \

- --suppress=postfixOperator:3rdParty/hippomocks.h \

- --suppress=stlSize:3rdParty/hippomocks.h \

- --suppress=noConstructor \

- --suppress=publicAllocationError:Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp \

- -i 3rdParty -i .git -i .sconf_temp \

- -i Swiftob/linit.cpp \

- -i Swift/QtUI/EventViewer/main.cpp \

- -i Swift/QtUI/ApplicationTest \

- -i Swift/QtUI/ChatView/main.cpp \

- -i Swift/QtUI/Roster/main.cpp \

- -i Swift/QtUI/NotifierTest/NotifierTest.cpp \

- -DSWIFTEN_BUILDING -DSWIFTEN_STATIC \

- -U__BEOS__ -U__CYGWIN__ -U__QNNXTO__ -U__amigaos__ -Uhpux -U__sgi \

- \

- -I . \

- -I Swift/QtUI \

- .

- # Location of stylesheets and catalogs

- docbook_dir = "#/BuildTools/DocBook"

- docbook_xsl_style_dir = env.Dir(docbook_dir + "/Stylesheets").abspath

- docbook_xml_catalog = env.File("catalog.xml").abspath

- if "DOCBOOK_XML_DIR" in env :

- docbook_xml_dir = env.Dir("$DOCBOOK_XML_DIR").abspath

- else :

- docbook_xml_dir = env.Dir("#/3rdParty/DocBook/XML").abspath

- if "DOCBOOK_XSL_DIR" in env :

- docbook_xsl_dir = env.Dir("$DOCBOOK_XSL_DIR").abspath

- else :

- docbook_xsl_dir = env.Dir("#/3rdParty/DocBook/XSL").abspath

- fop_fonts_dir = env.Dir(docbook_dir + "/Fonts").abspath

-

- # Generates a catalog from paths to external tools

- def buildCatalog(target, source, env) :

- catalog = """<?xml version='1.0'?>

- <rewriteSystem

- systemIdStartString="http://www.oasis-open.org/docbook/xml/4.5/"

- rewritePrefix="%(docbook_xml_dir)s/" />

- <rewriteSystem

- systemIdStartString="docbook-xsl:/"

- rewritePrefix="%(docbook_xsl_dir)s/" />

-

- docbook_xml_dir = source[0].get_contents()

- docbook_xsl_dir = source[1].get_contents()

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

- docbook_xml_dir = docbook_xml_dir.replace("\\","/")

- docbook_xsl_dir = docbook_xsl_dir.replace("\\","/")

- file = open(target[0].abspath, "w")

- file.write(catalog % {

- "docbook_xml_dir" : docbook_xml_dir,

- "docbook_xsl_dir" : docbook_xsl_dir,

- })

- file.close()

-

- # Generates a FOP config file

- def buildFopConfig(target, source, env) :

- fopcfg = """<fop version=\"1.0\">

- <renderers>

- <renderer mime=\"application/pdf\">

- <fonts>

- <directory recursive=\"true\">%(fonts_dir)s</directory>

- </fonts>

- </renderer>

- </renderers>

- file = open(target[0].abspath, "w")

- file.write(fopcfg % {

- "fonts_dir" : source[0].get_contents()

- })

- file.close()

-

- # Builds a DocBook file

- def buildDocBook(env, source) :

- db_env = env.Clone()

- db_env["XMLCATALOGS"] = [docbook_xml_catalog]

- db_env["ENV"].update({"OS" : os.environ.get("OS", "")})

-

- db_env["XMLLINT"] = env.WhereIs("xmllint")

- db_env["XSLT"] = env.WhereIs("xsltproc")

- db_env["FO"] = env.WhereIs("fop")

-

- if not db_env["XMLLINT"] or not db_env["XSLT"] :

- return

-

- # PDF generation

- if db_env["FO"] :

- fo = db_env.XSLT(os.path.splitext(source)[0] + ".fo", source,

- XSLTSTYLESHEET = db_env["DOCBOOK_XSL_FO"])

- pdf = db_env.FO(fo)

-

- # HTML generation

- db_env.XSLT(os.path.splitext(source)[0] + ".html", source,

- XSLTSTYLESHEET = db_env["DOCBOOK_XSL_HTML"])

-

- # Import tools

- env.Tool("FO", toolpath = [docbook_dir + "/SCons"])

- env.Tool("XSLT", toolpath = [docbook_dir + "/SCons"])

-

- # Catalog file generation

- env.Command("catalog.xml", [env.Value(docbook_xml_dir), env.Value(docbook_xsl_dir)], SCons.Action.Action(buildCatalog, cmdstr = "$GENCOMSTR"))

-

- # FO config file generation

- env["FOCFG"] = env.File("fop.cfg").abspath

- env.Command("fop.cfg", [env.Value(fop_fonts_dir)], SCons.Action.Action(buildFopConfig, cmdstr = "$GENCOMSTR"))

-

- # DocBook stylesheets

- env["DOCBOOK_XSL_FO"] = docbook_xsl_style_dir + "/fo/docbook.xsl"

- env["DOCBOOK_XSL_HTML"] = docbook_xsl_style_dir + "/html/docbook.xsl"

- env.AddMethod(buildDocBook, "DocBook")

-

- return True

- def generate_actions(source, target, env, for_signature) :

- if len(env["FOCFG"]) > 0 :

- cmd = "$FO -c $FOCFG $FOFLAGS $SOURCE $TARGET"

- else :

- cmd = "$FO $FOFLAGS $SOURCE $TARGET"

- return SCons.Action.Action(cmd, cmdstr = "$FOCOMSTR")

- def modify_sources(target, source, env) :

- if len(env["FOCFG"]) > 0 :

- source.append(env["FOCFG"])

- return target, source

- def scan_fo(node, env, path) :

- dependencies = set()

- try :

- document = xml.dom.minidom.parseString(node.get_contents())

- except xml.parsers.expat.ExpatError:

- return []

- for include in document.getElementsByTagNameNS("http://www.w3.org/1999/XSL/Format", "external-graphic") :

- m = re.match("url\((.*)\)", include.getAttribute("src"))

- if m :

- dependencies.add(m.group(1))

- return list(dependencies)

- env["FO"] = "fop"

- env["FOFLAGS"] = ""

- env["FOCFG"] = ""

- env["BUILDERS"]["FO"] = SCons.Builder.Builder(

- generator = generate_actions,

- emitter = modify_sources,

- source_scanner = SCons.Scanner.Scanner(function = scan_fo, skeys = [".fo"]),

- suffix = ".pdf",

- src_suffix = ".fo"

- )

- return True

- def generate_actions(source, target, env, for_signature) :

- if not env.has_key("XSLTSTYLESHEET") :

- raise SCons.Errors.UserError, "The XSLTSTYLESHEET construction variable must be defined"

-

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

-

- # Build the XMLLint command

- xmllintcmd = ["$XMLLINT", "--nonet", "--xinclude", "--postvalid", "--noout", "$SOURCE"]

-

- # Build the XSLT command

- xsltcmd = ["$XSLT", "--nonet", "--xinclude"]

- for (param, value) in env["XSLTPARAMS"] :

- xsltcmd += ["--stringparam", param, value]

- xsltcmd += ["-o", "$TARGET", "$XSLTSTYLESHEET", "$SOURCE"]

-

- return [

- SCons.Action.Action([xmllintcmd], cmdstr = "$XMLLINTCOMSTR"),

- SCons.Action.Action([xsltcmd], cmdstr = "$XSLTCOMSTR")]

-

- def modify_sources(target, source, env) :

- if len(env["FOCFG"]) > 0 :

- source.append(env["FOCFG"])

- source.append(env.get("XMLCATALOGS", []))

- return target, source

-

- def scan_xml(node, env, path) :

- dependencies = set()

- nodes = [node]

- while len(nodes) > 0 :

- node = nodes.pop()

- try :

- document = xml.dom.minidom.parseString(node.get_contents())

- except xml.parsers.expat.ExpatError:

- continue

- for include in document.getElementsByTagNameNS("http://www.w3.org/2001/XInclude", "include") :

- include_file = include.getAttribute("href")

- dependencies.add(include_file)

- if include.getAttribute("parse") != "text" :

- nodes.append(env.File(include_file))

- return list(dependencies)

-

- env["XMLLINT"] = "xmllint"

- env["XSLT"] = "xsltproc"

- env["XSLTPARAMS"] = []

- env["BUILDERS"]["XSLT"] = SCons.Builder.Builder(

- generator = generate_actions,

- emitter = modify_sources,

- source_scanner = SCons.Scanner.Scanner(function = scan_xml),

- src_suffix = ".xml"

- )

- return True

- * Copyright (c) ${year} Remko Tronçon&#13;

- * Licensed under the GNU General Public License v3.&#13;

- * See Documentation/Licenses/GPLv3.txt for more information.&#13;

-</template></templates> \ No newline at end of file

- only_major = True

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

- print "0"

- print Version.getBuildVersion(os.path.dirname(sys.argv[0] + "/.."), sys.argv[1])

- if ! BuildTools/Copyrighter.py check-copyright $file; then

- echo "ERROR: '$file' has a copyright error. Aborting commit."

- print "Usage: " + sys.argv[0] + " <output-dir>"

- sys.exit(-1)

- author_components = line.rstrip().split("|")

- authors[author_components[0]] = author_components[1]

- print "Error"

- sys.exit(-1)

- os.makedirs(output_dir)

- print "Processing avatar for " + name + " <" + email + ">"

- filename = os.path.join(output_dir, name + ".png")

- if os.path.isfile(filename) :

- print "-> Already there. Skipping."

- continue

- m = hashlib.md5()

- m.update(email)

- url = GRAVATAR_URL % {"id" : m.hexdigest()}

- print "- Downloading " + url

- f = urllib.urlopen(url)

- input = None

- if f.getcode() == 200 :

- input = f.read()

- f.close()

- if input :

- print "- Saving file " + filename

- f = open(filename, "w")

- f.write(input)

- else :

- print "- No Gravatar found"

-*.suo

-*.ncp

-Slimber

-Swift

-import os, os.path

-

-projects = [("Swift", "Swift\QtUI\Swift.exe"), ("Slimber", "Slimber\Qt\Slimber.exe")]

-

-for (project, outputbin) in projects :

- if not os.path.exists(project) :

- os.mkdir(project)

- output = open(os.path.join(project, project + ".vcproj"), "w")

-

- headers = []

- sources = []

- for root, dirs, files in os.walk(os.path.join("..", "..", project)) :

- for file in files :

- if file.endswith(".h") :

- headers.append('<File RelativePath="' + os.path.join("..", root, file) + '" />')

- elif file.endswith(".cpp") :

- sources.append('<File RelativePath="' + os.path.join("..", root, file) + '" />')

-

- output.write("""<?xml version="1.0" encoding="Windows-1252"?>

-<VisualStudioProject

- ProjectType="Visual C++"

- Version="9.00"

- Name="%(project)s"

- Keyword="MakeFileProj"

- TargetFrameworkVersion="196613"

- >

- <Platforms>

- <Platform

- Name="Win32"

- />

- </Platforms>

- <ToolFiles>

- </ToolFiles>

- <Configurations>

- <Configuration

- Name="Debug|Win32"

- OutputDirectory="$(ConfigurationName)"

- IntermediateDirectory="$(ConfigurationName)"

- ConfigurationType="0"

- >

- <Tool

- Name="VCNMakeTool"

- BuildCommandLine="cd ..\..\..\ &amp;&amp; scons debug=1 %(project)s"

- ReBuildCommandLine=""

- CleanCommandLine="cd ..\..\..\ &amp;&amp; scons -c debug=1 %(project)s"

- Output="..\..\..\%(output)s"

- PreprocessorDefinitions="WIN32;_DEBUG"

- IncludeSearchPath=""

- ForcedIncludes=""

- AssemblySearchPath=""

- ForcedUsingAssemblies=""

- CompileAsManaged=""

- />

- </Configuration>

- <Configuration

- Name="Release|Win32"

- OutputDirectory="$(ConfigurationName)"

- IntermediateDirectory="$(ConfigurationName)"

- ConfigurationType="0"

- >

- <Tool

- Name="VCNMakeTool"

- BuildCommandLine="cd ..\..\..\ &amp;&amp; scons %(project)s"

- ReBuildCommandLine=""

- CleanCommandLine="cd ..\..\..\ &amp;&amp; scons -c %(project)s"

- Output="..\..\..\%(output)s"

- PreprocessorDefinitions="WIN32;NDEBUG"

- IncludeSearchPath=""

- ForcedIncludes=""

- AssemblySearchPath=""

- ForcedUsingAssemblies=""

- CompileAsManaged=""

- />

- </Configuration>

- </Configurations>

- <References>

- </References>

- <Files>

- <Filter

- Name="Source Files"

- Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"

- >

- %(sources)s

- </Filter>

- <Filter

- Name="Header Files"

- Filter="h;hpp;hxx;hm;inl;inc;xsd"

- >

- %(headers)s

- </Filter>

- <Filter

- Name="Resource Files"

- Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"

- >

- </Filter>

- </Files>

- <Globals>

- </Globals>

-</VisualStudioProject>""" % { "project": project, "output" : outputbin, "headers" : '\n'.join(headers), "sources": '\n'.join(sources) })

- output.close()

-

-Microsoft Visual Studio Solution File, Format Version 10.00

-# Visual C++ Express 2008

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Swift", "Swift\Swift.vcproj", "{C67C3A5B-1382-4B4A-88F7-3BFC98DA43A2}"

-EndProject

-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Slimber", "Slimber\Slimber.vcproj", "{597242B2-A667-47A1-B69E-D2C4281183D0}"

-EndProject

-Global

- GlobalSection(SolutionConfigurationPlatforms) = preSolution

- Debug|Win32 = Debug|Win32

- Release|Win32 = Release|Win32

- EndGlobalSection

- GlobalSection(ProjectConfigurationPlatforms) = postSolution

- {C67C3A5B-1382-4B4A-88F7-3BFC98DA43A2}.Debug|Win32.ActiveCfg = Debug|Win32

- {C67C3A5B-1382-4B4A-88F7-3BFC98DA43A2}.Debug|Win32.Build.0 = Debug|Win32

- {C67C3A5B-1382-4B4A-88F7-3BFC98DA43A2}.Release|Win32.ActiveCfg = Release|Win32

- {C67C3A5B-1382-4B4A-88F7-3BFC98DA43A2}.Release|Win32.Build.0 = Release|Win32

- {597242B2-A667-47A1-B69E-D2C4281183D0}.Debug|Win32.ActiveCfg = Debug|Win32

- {597242B2-A667-47A1-B69E-D2C4281183D0}.Debug|Win32.Build.0 = Debug|Win32

- {597242B2-A667-47A1-B69E-D2C4281183D0}.Release|Win32.ActiveCfg = Release|Win32

- {597242B2-A667-47A1-B69E-D2C4281183D0}.Release|Win32.Build.0 = Release|Win32

- EndGlobalSection

- GlobalSection(SolutionProperties) = preSolution

- HideSolutionNode = FALSE

- EndGlobalSection

-EndGlobal

-vars.Add('ccflags', "Extra C(++) compiler flags")

-vars.Add(BoolVariable("distcc", "Use DistCC", "no"))

-vars.Add('distcc_hosts', "DistCC hosts (overrides DISTCC_HOSTS)")

-vars.Add(EnumVariable("target", "Choose a target platform for compilation", "native", ["native", "iphone-simulator", "iphone-device", "xcode"]))

- vars.Add(BoolVariable("coverage", "Compile with coverage information", "no"))

- vars.Add(BoolVariable("valgrind", "Run tests with valgrind", "no"))

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

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

- vars.Add(PathVariable("wix_bindir", "Path to WiX binaries", "", PathVariable.PathAccept))

- vars.Add(PackageVariable("bonjour", "Bonjour SDK location", "yes"))

-vars.Add("expat_libname", "Expat library name", "libexpat" if os.name == "nt" else "expat")

-vars.Add("libidn_libname", "LibIDN library name", "libidn" if os.name == "nt" else "idn")

-vars.Add("sqlite_libname", "SQLite library name", "libsqlite3" if os.name == "nt" else "sqlite3")

- 'PATH' : os.environ['PATH'],

- 'LD_LIBRARY_PATH' : os.environ.get("LD_LIBRARY_PATH", ""),

- env = Environment(ENV = env_ENV, variables = vars, MSVC_VERSION = ARGUMENTS["MSVC_VERSION"])

- env = Environment(ENV = env_ENV, variables = vars)

-env["PLATFORM_FLAGS"] = {}

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

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

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

- #So we don't need to escalate with UAC

- if "TMP" in os.environ.keys() :

- env['ENV']['TMP'] = os.environ['TMP']

- try :

- import multiprocessing

- SetOption("num_jobs", multiprocessing.cpu_count())

- except NotImplementedError :

- pass

- except ImportError :

- pass

-

-# Default compiler flags

-if env.get("distcc", False) :

- env["ENV"]["HOME"] = os.environ["HOME"]

- env["ENV"]["DISTCC_HOSTS"] = os.environ.get("DISTCC_HOSTS", "")

- if "distcc_hosts" in env :

- env["ENV"]["DISTCC_HOSTS"] = env["distcc_hosts"]

- env["CC"] = "distcc gcc"

- env["CXX"] = "distcc g++"

- env["CC"] = env["cc"]

- env["CXX"] = env["cxx"]

-ccflags = env.get("ccflags", [])

-if isinstance(ccflags, str) :

- # FIXME: Make the splitting more robust

- env["CCFLAGS"] = ccflags.split(" ")

-else :

- env["CCFLAGS"] = ccflags

- env["SHLINK"] = env["link"]

- env["LINK"] = env["link"]

-linkflags = env.get("linkflags", [])

-if isinstance(linkflags, str) :

- # FIXME: Make the splitting more robust

- env["LINKFLAGS"] = linkflags.split(" ")

-else :

- env["LINKFLAGS"] = linkflags

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

- env.Append(CCFLAGS = ["/O2"])

- else :

- env.Append(CCFLAGS = ["-O2"])

- env.Append(CCFLAGS = ["-Os"])

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

- env.Append(CCFLAGS = ["/Z7"])

- env.Append(LINKFLAGS = ["/DEBUG"])

- if env["set_iterator_debug_level"] :

- env.Append(CPPDEFINES = ["_ITERATOR_DEBUG_LEVEL=0"])

- if env["optimize"] :

- env.Append(LINKFLAGS = ["/OPT:NOREF"])

- env.Append(CCFLAGS = ["/MD"])

- else :

- env.Append(CCFLAGS = ["/MDd"])

- else :

- env.Append(CCFLAGS = ["-g"])

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

- env.Append(CCFLAGS = ["/MD"])

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

- "-isysroot", "/Developer/SDKs/MacOSX10.4u.sdk",

- "-arch", "i386",

- "-arch", "ppc"])

- assert(env["PLATFORM"] == "darwin")

- env.Append(CCFLAGS = [

- "-isysroot", "/Developer/SDKs/MacOSX10.5.sdk",

- "-arch", "i386"])

- env.Append(LINKFLAGS = [

- "-mmacosx-version-min=10.5",

- "-isysroot", "/Developer/SDKs/MacOSX10.5.sdk",

- "-arch", "i386"])

- env.Append(FRAMEWORKS = ["Security"])

- assert(env["PLATFORM"] == "darwin")

- env.Append(CCFLAGS = [

- "-isysroot", "/Developer/SDKs/MacOSX10.6.sdk",

- "-arch", "i386"])

- env.Append(LINKFLAGS = [

- "-mmacosx-version-min=10.6",

- "-isysroot", "/Developer/SDKs/MacOSX10.6.sdk",

- "-arch", "i386"])

- env.Append(FRAMEWORKS = ["Security"])

- env.Append(CPPDEFINES = ["NDEBUG"])

- env.Append(CPPDEFINES = ["SWIFT_EXPERIMENTAL_FT", "SWIFT_EXPERIMENTAL_HISTORY", "SWIFT_EXPERIMENTAL_WB"])

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

- env.Append(CCFLAGS = ["-fPIC"])

- # TODO: Find the ideal set of warnings

- #env.Append(CCFLAGS = ["/Wall"])

- pass

- env.Append(CXXFLAGS = ["-Wextra", "-Wall", "-Wnon-virtual-dtor", "-Wundef", "-Wold-style-cast", "-Wno-long-long", "-Woverloaded-virtual", "-Wfloat-equal", "-Wredundant-decls"])

- if not env.get("allow_warnings", False) :

- env.Append(CXXFLAGS = ["-Werror"])

- 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 "clang" in env["CC"] :

- env.Append(CXXFLAGS = ["-W#warnings", "-Wc++0x-compat", "-Waddress-of-temporary", "-Wambiguous-member-template", "-Warray-bounds", "-Watomic-properties", "-Wbind-to-temporary-copy", "-Wbuiltin-macro-redefined", "-Wc++-compat", "-Wc++0x-extensions", "-Wcomments", "-Wconditional-uninitialized", "-Wconstant-logical-operand", "-Wdeclaration-after-statement", "-Wdeprecated", "-Wdeprecated-implementations", "-Wdeprecated-writable-strings", "-Wduplicate-method-arg", "-Wempty-body", "-Wendif-labels", "-Wenum-compare", "-Wformat=2", "-Wfour-char-constants", "-Wgnu", "-Wincomplete-implementation", "-Winvalid-noreturn", "-Winvalid-offsetof", "-Winvalid-token-paste", "-Wlocal-type-template-args", "-Wmethod-signatures", "-Wmicrosoft", "-Wmissing-declarations", "-Wnon-pod-varargs", "-Wnull-dereference", "-Wout-of-line-declaration", "-Woverlength-strings", "-Wpacked", "-Wpointer-arith", "-Wpointer-sign", "-Wprotocol", "-Wreadonly-setter-attrs", "-Wselector", "-Wshift-overflow", "-Wshift-sign-overflow", "-Wstrict-selector-match", "-Wsuper-class-method-mismatch", "-Wtautological-compare", "-Wtypedef-redefinition", "-Wundeclared-selector", "-Wunknown-warning-option", "-Wunnamed-type-template-args", "-Wunused-exception-parameter", "-Wunused-member-function", "-Wused-but-marked-unused", "-Wvariadic-macros", "-Wno-c++11-extensions"])

-# To enable:

-# "-Wnonfragile-abi2" -> deprecated, is now -Warc-abi i think

-# "-Wheader-hygiene"

-# "-Wnon-gcc",

-# "-Wweak-vtables",

-# "-Wlarge-by-value-copy",

- assert(env["PLATFORM"] != "win32")

- env.Append(CCFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

- env.Append(LINKFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

- env.Append(LIBS = ["user32", "crypt32", "dnsapi", "iphlpapi", "ws2_32", "wsock32", "Advapi32"])

- env.Append(CCFLAGS = ["/EHsc", "/nologo"])

- env.Append(LINKFLAGS = ["/INCREMENTAL:no", "/NOLOGO"])

- if int(env["MSVS_VERSION"].split(".")[0]) < 10 :

- env["LINKCOM"] = [env["LINKCOM"], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;1']

- env["SHLINKCOM"] = [env["SHLINKCOM"], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;2']

-

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

- env.Append(FRAMEWORKS = ["IOKit", "AppKit", "SystemConfiguration", "Security", "SecurityInterface"])

- env["TEST_TYPE"] = "unit"

- env["TEST_RUNNER"] = "valgrind --suppressions=QA/valgrind.supp -q --leak-check=full --track-origins=yes "

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

- if ARGUMENTS.get(path, "") :

- if os.path.isabs(ARGUMENTS[path]) :

- env[path] = Dir(ARGUMENTS[path]).abspath

- else :

- env[path] = Dir("#/" + ARGUMENTS[path]).abspath

- # Extract/initialize all the information we need

- if target == "xcode" :

- # Get the information from the XCode environment

- env["XCODE_PLATFORM_DEVELOPER_BIN_DIR"] = os.environ["PLATFORM_DEVELOPER_BIN_DIR"]

- env["XCODE_SDKROOT"] = os.environ["SDKROOT"]

- env["XCODE_ARCH_FLAGS"] = sum([["-arch", arch] for arch in os.environ["ARCHS"].split(" ")], [])

- env["IPHONEOS_DEPLOYMENT_TARGET"] = os.environ["IPHONEOS_DEPLOYMENT_TARGET"]

- # Use absolute path sources so Xcode can highlight compilation errors in swiften

- env['CXXCOM'] = '$CXX -o $TARGET -c $CXXFLAGS $CCFLAGS $_CCCOMCOM ${SOURCES.abspath}'

- else :

- # Hard code values

- env["XCODE_PLATFORM_DEVELOPER_BIN_DIR"] = "/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin"

- if target == "iphone-device":

- env["XCODE_ARCH_FLAGS"] = ["-arch", "armv6", "-arch", "armv7"]

- sdkPart = "iPhoneOS"

- else :

- env["XCODE_ARCH_FLAGS"] = ["-arch", "i386"]

- sdkPart = "iPhoneSimulator"

- sdkVer = "4.3"

- env["XCODE_SDKROOT"] = "/Developer/Platforms/" + sdkPart + ".platform/Developer/SDKs/" + sdkPart + sdkVer + ".sdk"

- env["IPHONEOS_DEPLOYMENT_TARGET"] = "4.1"

-

- # Set the build flags

- env["CC"] = "$XCODE_PLATFORM_DEVELOPER_BIN_DIR/gcc"

- env["CXX"] = "$XCODE_PLATFORM_DEVELOPER_BIN_DIR/g++"

- env["OBJCCFLAGS"] = ["-fobjc-abi-version=2", "-fobjc-legacy-dispatch"]

- env["LD"] = env["CC"]

- env.Append(CCFLAGS = env["XCODE_ARCH_FLAGS"] + ["-fvisibility=hidden", "-miphoneos-version-min=" + env["IPHONEOS_DEPLOYMENT_TARGET"]])

- if os.environ.get("GCC_THUMB_SUPPORT", False) :

- env.Append(CCFLAGS = ["-mthumb"])

- env.Append(LINKFLAGS = env["XCODE_ARCH_FLAGS"])

- env.Append(CPPFLAGS = ["-isysroot", "$XCODE_SDKROOT"])

- env.Append(FRAMEWORKS = ["CoreFoundation", "Foundation", "UIKit", "CoreGraphics"])

- env.Append(LINKFLAGS = env["XCODE_ARCH_FLAGS"] + ["-isysroot", "$XCODE_SDKROOT", "-L\"$XCODE_SDKROOT/usr/lib\"", "-F\"$XCODE_SDKROOT/System/Library/Frameworks\"", "-F\"$XCODE_SDKROOT/System/Library/PrivateFrameworks\""])

- # Bit of a hack, because BOOST doesn't know the endianness for ARM

- env.Append(CPPDEFINES = ["_LITTLE_ENDIAN"])

- env["ENV"]["HOME"] = os.environ["HOME"]

- for var in os.environ :

- if var.startswith("CCACHE_") :

- env["ENV"][var] = os.environ[var]

- if env.get("CC", "") != "" :

- env["CC"] = "ccache " + env["CC"]

- else :

- env["CC"] = "ccache gcc"

- if env.get("CXX", "") != "" :

- env["CXX"] = "ccache " + env["CXX"]

- else :

- env["CC"] = "ccache g++"

- fingerprint = ",".join([flag for flag in env["CXXFLAGS"] + env["CCFLAGS"] if not flag.startswith("-W") and not flag.startswith("-fvisibility")])

- variant = "build/" + fingerprint

- if not os.path.exists(Dir("#/build").abspath) :

- os.mkdir(Dir("#/build").abspath)

- if os.path.exists(Dir("#/build/current").abspath) :

- os.unlink(Dir("#/build/current").abspath)

- os.symlink(os.path.basename(variant), Dir("#/build/current").abspath)

-def SConscript(*arguments, **keywords) :

- if not keywords.get("test_only", False) or env["TEST"] :

- return apply(oldSConscript, arguments, keywords)

-

-# env["MSVC_BATCH"] = 1

- colors = { "red": "31", "green": "32", "yellow": "33", "blue": "34" }

- prefix = ""

- suffix = ""

- if sys.stdout.isatty() and env["PLATFORM"] != "win32":

- prefix = "\033[0;" + colors[color] + ";140m"

- suffix = "\033[0m"

- return " " + prefix + command + suffix + " " + target

-

-if int(ARGUMENTS.get("V", 0)) == 0:

- env["CCCOMSTR"] = colorize("CC", "$TARGET", "green")

- env["SHCCCOMSTR"] = colorize("CC", "$TARGET", "green")

- env["CXXCOMSTR"] = colorize("CXX", "$TARGET", "green")

- env["SHCXXCOMSTR"] = colorize("CXX", "$TARGET", "green")

- env["LINKCOMSTR"] = colorize("LINK", "$TARGET", "red")

- env["SHLINKCOMSTR"] = colorize("LINK", "$TARGET", "red")

- env["ARCOMSTR"] = colorize("AR", "$TARGET", "red")

- env["RANLIBCOMSTR"] = colorize("RANLIB", "$TARGET", "red")

- env["QT4_RCCCOMSTR"] = colorize("RCC", "$TARGET", "blue")

- env["QT4_UICCOMSTR"] = colorize("UIC", "$TARGET", "blue")

- env["QT4_MOCFROMHCOMSTR"] = colorize("MOC", "$TARGET", "blue")

- env["QT4_MOCFROMCXXCOMSTR"] = colorize("MOC", "$TARGET", "blue")

- env["QT4_LRELEASECOMSTR"] = colorize("LRELEASE", "$TARGET", "blue")

- env["QT4_LUPDATECOMSTR"] = colorize("LUPDATE", "$TARGET", "blue")

- env["GENCOMSTR"] = colorize("GEN", "$TARGET", "blue")

- env["RCCOMSTR"] = colorize("RC", "$TARGET", "blue")

- env["BUNDLECOMSTR"] = colorize("BUNDLE", "$TARGET", "blue")

- env["NIBCOMSTR"] = colorize("NIB", "$TARGET", "blue")

- env["NSISCOMSTR"] = colorize("NSIS", "$TARGET", "blue")

- env["INSTALLSTR"] = colorize("INSTALL", "$TARGET", "blue")

- env["TESTCOMSTR"] = colorize("TEST", "$SOURCE", "yellow")

- env["FOCOMSTR"] = colorize("FO", "$TARGET", "blue")

- env["XSLTCOMSTR"] = colorize("XSLT", "$TARGET", "blue")

- env["XMLLINTCOMSTR"] = colorize("XMLLINT", "$SOURCE", "blue")

- env["DOXYCOMSTR"] = colorize("DOXY", "$SOURCE", "blue")

- #Progress(colorize("DEP", "$TARGET", "red")

- context.Message("Checking for Objective-C header " + header + " ... ")

- ret = context.TryCompile("#include <Cocoa/Cocoa.h>\n#include <" + header + ">", ".m")

- context.Result(ret)

- return ret

- SCons.SConf.SetCacheMode("force")

- context.Message( 'Checking for package %s... ' % name )

- ret = context.TryAction('pkg-config --exists \'%s\'' % name)[0]

- context.Result( ret )

- return ret

- context.Message("Checking " + library + " version (>= " + version + ") ...")

- ret = context.TryRun("""

- printf("%%d\\n", %(define)s);

- return 0;

-""" % { "header" : header, "define": define }, ".c")

- ok = ret[0] and int(ret[1]) >= value

- context.Result(ok)

- return ok

-conf = Configure(conf_env)

- print "Error: You need a working compiler"

- Exit(1)

-if conf.CheckLib("z") :

- env["ZLIB_FLAGS"] = {"LIBS": ["z"]}

- env["ZLIB_BUNDLED"] = True

- env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["resolv"]

- if conf.CheckLib("pthread") :

- env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["pthread"]

- env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["dl"]

- env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["m"]

- env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["c"]

-

-if conf.CheckLib("stdc++") :

- env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["stdc++"]

- boost_flags["LIBPATH"] = [env["boost_libdir"]]

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

- boost_flags["CPPPATH"] = [env["boost_includedir"]]

- else :

- # Using isystem to avoid getting warnings from a system boost

- # Unfortunately, this also disables dependency tracking

- boost_flags["CPPFLAGS"] = [("-isystem", env["boost_includedir"])]

-boostLibs = [("signals", None), ("thread", None), ("regex", None), ("program_options", None), ("filesystem", None), ("system", "system/system_error.hpp"), ("date_time", "date_time/date.hpp")]

- if header :

- header = "boost/" + header

- else :

- header = "boost/" + lib + ".hpp"

- if not conf.CheckCXXHeader(header) :

- allLibsPresent = False

- break

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

- libName = "boost_" + lib

- if not conf.CheckLib(libName) :

- libName += "-mt"

- if not conf.CheckLib(libName) :

- allLibsPresent = False

- break

- libNames.append(libName)

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

- env["BOOST_BUNDLED"] = True

- xss_flags = {

- "LIBPATH": ["/usr/X11R6/lib"],

- "LIBS": ["Xss"]

- }

- xss_env = conf_env.Clone()

- xss_env.MergeFlags(xss_flags)

- conf = Configure(xss_env)

- if conf.CheckFunc("XScreenSaverQueryExtension") :

- env["HAVE_XSS"] = 1

- env["XSS_FLAGS"] = xss_flags

- conf.Finish()

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

- gconf_env = conf_env.Clone()

- conf = Configure(gconf_env, custom_tests = {"CheckPKG": CheckPKG})

- if conf.CheckPKG("gconf-2.0") :

- gconf_bare_env = Environment()

- gconf_bare_env.ParseConfig('pkg-config --cflags gconf-2.0 gobject-2.0 --libs gconf-2.0 gobject-2.0')

- gconf_flags = {

- "LIBS": gconf_bare_env["LIBS"],

- "CCFLAGS": gconf_bare_env["CCFLAGS"],

- "CPPPATH": gconf_bare_env["CPPPATH"],

- "CPPDEFINES": gconf_bare_env.get("CPPDEFINES", []),

- }

- gconf_env.MergeFlags(gconf_flags)

- if conf.CheckCHeader("gconf/gconf-client.h") and conf.CheckLib("gconf-2") :

- env["HAVE_GCONF"] = 1

- env["GCONF_FLAGS"] = {

- "LIBS": gconf_env["LIBS"],

- "CCFLAGS": gconf_env["CCFLAGS"],

- "CPPPATH": gconf_env["CPPPATH"],

- "CPPDEFINES": gconf_env.get("CPPDEFINES", []),

- }

- conf.Finish()

- sparkle_flags = {

- "FRAMEWORKPATH": ["/Library/Frameworks"],

- "FRAMEWORKS": ["Sparkle"]

- }

- sparkle_env = conf_env.Clone()

- sparkle_env.MergeFlags(sparkle_flags)

- conf = Configure(sparkle_env, custom_tests = { "CheckObjCHeader" : checkObjCHeader })

- if conf.CheckObjCHeader("Sparkle/Sparkle.h") :

- env["HAVE_SPARKLE"] = 1

- env["SPARKLE_FLAGS"] = sparkle_flags

- env["SPARKLE_FRAMEWORK"] = "/Library/Frameworks/Sparkle.framework"

- conf.Finish()

- growl_flags = {

- "FRAMEWORKPATH": ["/Library/Frameworks"],

- "FRAMEWORKS": ["Growl"]

- }

- growl_env = conf_env.Clone()

- growl_env.MergeFlags(growl_flags)

- conf = Configure(growl_env, custom_tests = { "CheckObjCHeader" : checkObjCHeader })

- if conf.CheckObjCHeader("Growl/Growl.h") :

- env["HAVE_GROWL"] = 1

- env["GROWL_FLAGS"] = growl_flags

- env["GROWL_FRAMEWORK"] = "/Library/Frameworks/Growl.framework"

- conf.Finish()

-

-# Snarl

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

- env["HAVE_SNARL"] = True

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

- env["HAVE_LIBXML"] = 1

- env["LIBXML_FLAGS"] = { "LIBS": ["xml2"] }

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

- libxml_env = conf_env.Clone()

- libxml_env.Append(CPPPATH = ["/usr/include/libxml2"])

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

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

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

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

- env["HAVE_EXPAT"] = 1

- env["EXPAT_BUNDLED"] = True

-icu_prefix = env["icu"] if isinstance(env["icu"], str) else ""

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

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

- icu_env.MergeFlags(icu_flags)

- env["HAVE_ICU"] = 1

- env["ICU_FLAGS"] = icu_flags

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

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

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

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

- env["HAVE_LIBIDN"] = 1

- env["LIBIDN_BUNDLED"] = 1

-if env["experimental"] :

- #libminiupnpc_conf_env = conf_env.Clone()

- #conf = Configure(libminiupnpc_conf_env)

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

- # print "NOT IMPLEMENTED YET"

- #else :

- env["LIBMINIUPNPC_BUNDLED"] = 1

- #conf.Finish()

- env["LIBMINIUPNPC_FLAGS"] = {}

-if env["experimental"] :

- #libnatpmp_conf_env = conf_env.Clone()

- #conf = Configure(libnatpmp_conf_env)

- #if conf.CheckCHeader("natpmp.h") and conf.CheckLib(env["libnatpmp_libname"]) :

- # print "NOT IMPLEMENTED YET"

- #else :

- env["LIBNATPMP_BUNDLED"] = 1

- #conf.Finish()

- env["LIBNATPMP_FLAGS"] = {}

- sqlite_conf_env = conf_env.Clone()

- sqlite_flags = {}

- if env.get("sqlite_libdir", None) :

- sqlite_flags["LIBPATH"] = [env["sqlite_libdir"]]

- if env.get("sqlite_includedir", None) :

- sqlite_flags["CPPPATH"] = [env["sqlite_includedir"]]

- sqlite_conf_env.MergeFlags(sqlite_flags)

- conf = Configure(sqlite_conf_env)

- if conf.CheckCHeader("sqlite3.h") and conf.CheckLib(env["sqlite_libname"]) and not env.get("sqlite_force_bundled", False):

- env["HAVE_SQLITE"] = 1

- env["SQLITE_FLAGS"] = { "LIBS": [env["sqlite_libname"]] }

- env["SQLITE_FLAGS"].update(sqlite_flags)

- else :

- env["SQLITE_BUNDLED"] = 1

- env["SQLITE_ASYNC_BUNDLED"] = 1

- conf.Finish()

- env["SQLITE_FLAGS"] = {}

-env["LUA_BUNDLED"] = 1

-conf = Configure(conf_env)

-if conf.CheckCHeader(["stdio.h", "readline/readline.h"]) and conf.CheckLib("readline") :

- env["HAVE_READLINE"] = True

- env["READLINE_FLAGS"] = { "LIBS": ["readline"] }

- avahi_flags["LIBPATH"] = [env["avahi_libdir"]]

- avahi_flags["CPPPATH"] = [env["avahi_includedir"]]

-if conf.CheckCHeader("avahi-client/client.h") and conf.CheckLib("avahi-client") and conf.CheckLib("avahi-common") :

- env["HAVE_AVAHI"] = True

- env["AVAHI_FLAGS"] = { "LIBS": ["avahi-client", "avahi-common"] }

- env["AVAHI_FLAGS"].update(avahi_flags)

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

-openssl_env = conf_env.Clone()

-use_openssl = bool(env["openssl"])

-openssl_prefix = env["openssl"] if isinstance(env["openssl"], str) else ""

-openssl_flags = {}

-if openssl_prefix :

- openssl_flags = { "CPPPATH": [os.path.join(openssl_prefix, "include")] }

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

-

-openssl_conf = Configure(openssl_env)

-if use_openssl and openssl_conf.CheckCHeader("openssl/ssl.h") :

- env["HAVE_OPENSSL"] = 1

- env["OPENSSL_FLAGS"] = openssl_flags

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

- env["OPENSSL_FLAGS"]["LIBS"] = ["libeay32MD", "ssleay32MD"]

- else:

- env["OPENSSL_FLAGS"]["LIBS"] = ["ssl", "crypto"]

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

- if platform.mac_ver()[0].startswith("10.5") :

- env["OPENSSL_FLAGS"]["FRAMEWORKS"] = ["Security"]

-elif env["target"] in ("iphone-device", "iphone-simulator", "xcode") :

- env["OPENSSL_BUNDLED"] = True

- env["HAVE_OPENSSL"] = True

-else :

- env["OPENSSL_FLAGS"] = {}

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

- env["HAVE_SCHANNEL"] = True

- # If we're compiling for Windows and OpenSSL isn't being used, use Schannel

- env.Append(LIBS = ["secur32"])

-openssl_conf.Finish()

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

- env["HAVE_BONJOUR"] = 1

- bonjour_env = conf_env.Clone()

- bonjour_conf = Configure(bonjour_env)

- bonjour_flags = {}

- if env.get("bonjour") != True :

- bonjour_prefix = env["bonjour"]

- bonjour_flags["CPPPATH"] = [os.path.join(bonjour_prefix, "include")]

- bonjour_flags["LIBPATH"] = [os.path.join(bonjour_prefix, "lib", "win32")]

- bonjour_env.MergeFlags(bonjour_flags)

- if bonjour_conf.CheckCHeader("dns_sd.h") and bonjour_conf.CheckLib("dnssd") :

- env["HAVE_BONJOUR"] = 1

- env["BONJOUR_FLAGS"] = bonjour_flags

- env["BONJOUR_FLAGS"]["LIBS"] = ["dnssd"]

- bonjour_conf.Finish()

- cocoa_conf = Configure(conf_env)

- if cocoa_conf.CheckCHeader("IOKit/IOKitLib.h") :

- env["HAVE_IOKIT"] = True

- cocoa_conf.Finish()

- myenv = env.Clone()

- myenv.Tool("qt4", toolpath = ["#/BuildTools/SCons/Tools"])

- env["HAVE_QT"] = True

-except :

- env["HAVE_QT"] = False

- env["DOCBOOK_XML_DIR"] = env["docbook_xml"]

- env["DOCBOOK_XSL_DIR"] = env["docbook_xsl"]

-if env.Dir("#/.git").exists() :

- if not env.GetOption("clean") :

- env.Install("#/.git/hooks", Glob("#/BuildTools/Git/Hooks/*"))

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

- env.Append(CPPPATH = [root])

-# Build tools

-env.SConscript(dirs = ["#/BuildTools/CLang"])

-for dir in os.listdir(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)

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

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

-for stage in ["flags", "build", "test"] :

- env["SCONS_STAGE"] = stage

- SConscript(dirs = map(lambda x : root + "/" + x, modules))

- for project in env["PROJECTS"] :

- env.SLOCCount("#/" + project)

-print

-print " Build Configuration"

-print " -------------------"

- parsers.append("LibXML")

- parsers.append("Expat")

- if env.get("EXPAT_BUNDLED", False) :

- parsers.append("(Bundled)")

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

-print ""

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

-

-print " TLS Support: " + ("OpenSSL" if env.get("HAVE_OPENSSL",0) else ("Schannel" if env.get("HAVE_SCHANNEL", 0) else "Disabled"))

-print " DNSSD Support: " + ("Bonjour" if env.get("HAVE_BONJOUR") else ("Avahi" if env.get("HAVE_AVAHI") else "Disabled"))

-print

- def createAppBundle(env, bundle, version = "1.0", resources = [], frameworks = [], info = {}, handlesXMPPURIs = False) :

- bundleDir = bundle + ".app"

- bundleContentsDir = bundleDir + "/Contents"

- resourcesDir = bundleContentsDir + "/Resources"

- frameworksDir = bundleContentsDir + "/Frameworks"

- env.Install(bundleContentsDir + "/MacOS", bundle)

- env.WriteVal(bundleContentsDir + "/PkgInfo", env.Value("APPL\77\77\77\77"))

- infoDict = {

- "CFBundleDevelopmentRegion" : "English",

- "CFBundleExecutable" : bundle,

- "CFBundleIdentifier" : "im.swift." + bundle,

- "CFBundleInfoDictionaryVersion" : "6.0",

- "CFBundleName" : bundle,

- "CFBundlePackageType" : "APPL",

- "CFBundleSignature": "\77\77\77\77",

- "CFBundleVersion" : version,

- "CFBundleIconFile" : bundle,

- "NSPrincipalClass" : "NSApplication",

- "NSHumanReadableCopyright" : unichr(0xA9) + " 2010 Swift Development Team.\nAll Rights Reserved."

- }

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

- plist += "<string>" + value.encode("utf-8") + "</string>\n"

- if handlesXMPPURIs :

- plist += """<key>CFBundleURLTypes</key>

-<array>

- <key>CFBundleURLName</key>

- <string>XMPP URL</string>

- <key>CFBundleURLSchemes</key>

- <array>

- <string>xmpp</string>

- </array>

- </dict>

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

- for framework in frameworks :

- env.Install(frameworksDir, framework)

- return env.Dir(bundleDir)

- env.AddMethod(createAppBundle, "AppBundle")

- return env["PLATFORM"] == "darwin"

- def createBuildVersion(env, target, project) :

- buildVersion = """#pragma once

- env.WriteVal(target, env.Value(buildVersion))

- env.AddMethod(createBuildVersion, "BuildVersion")

- return true

- def modify_targets(target, source, env) :

- target = [env.File("html/index.html")]

- return target, source

- def generate_actions(source, target, env, for_signature) :

- if env.WhereIs("$DOXYGEN") and env.WhereIs("$DOT") :

- return [SCons.Action.Action("$DOXYGEN $SOURCE", cmdstr = "$DOXYCOMSTR")]

- else :

- return []

- env["DOXYGEN"] = "doxygen"

- # FIXME: For some reason, things go incredibly slow (at least on OS X)

- # when not doing this. Some environment flag is having an effect on

- # this; find out which

- env["ENV"] = os.environ

- env["DOT"] = "dot"

- env["BUILDERS"]["DoxyGen"] = SCons.Builder.Builder(

- emitter = modify_targets,

- generator = generate_actions,

- single_source = True)

- return True

- def useFlags(env, flags) :

- for flag in flags :

- env[flag] = env.get(flag, []) + flags[flag]

- env.AddMethod(useFlags, "UseFlags")

- return True

- env["IBTOOL"] = "ibtool"

- env["BUILDERS"]["Nib"] = SCons.Builder.Builder(

- action = SCons.Action.Action("$IBTOOL --errors --warnings --notices --output-format human-readable-text --compile $TARGET $SOURCE", cmdstr = "$NIBCOMSTR"),

- suffix = ".nib",

- src_suffix = ".xib",

- single_source = True)

- return env["PLATFORM"] == "darwin"

- root = env.Dir("#").abspath

- def relpath(path, start) :

- i = len(os.path.commonprefix([path, start]))

- return path[i+1:]

- def replacePragmaOnce(env, target, source) :

- guard = relpath(source[0].abspath, root).replace("/", "_").replace(".", "_").upper()

- data = source[0].get_contents()

- f = open(str(target[0]), 'wb')

- if "#pragma once" in data :

- f.write(data.replace("#pragma once", "#ifndef %(guard)s\n#define %(guard)s" % {"guard": guard}))

- f.write("\n#endif\n")

- else :

- f.write(data)

- f.close()

- env["BUILDERS"]["ReplacePragmaOnce"] = SCons.Builder.Builder(

- action = SCons.Action.Action(replacePragmaOnce, cmdstr = "$GENCOMSTR"),

- single_source = True)

- return True

- def createSLOCCount(env, source) :

- myenv = env.Clone()

- myenv["ENV"]["HOME"] = os.environ["HOME"]

- source = myenv.Dir(source)

- target = myenv.File("#/" + source.path + ".sloccount")

- # FIXME: There's probably a better way to force building the .sc

- if os.path.exists(target.abspath) :

- os.unlink(target.abspath)

- return myenv.Command(target, source, [SCons.Action.Action("sloccount --duplicates --wide --details " + source.path + " | grep -v qrc_ > $TARGET", cmdstr = "$GENCOMSTR")])

- env.AddMethod(createSLOCCount, "SLOCCount")

- return True

- def registerTest(env, target, type = "unit", is_checker = False) :

- if env["TEST_TYPE"] == "all" or env["TEST_TYPE"] == type :

- cmd = target[0].abspath if SCons.Util.is_List(target) else target.abspath

- params = ""

-

- # Special support for unittest checker

- if is_checker and env.get("checker_report", False) :

- params = " --xml > " + os.path.join(target[0].dir.path, "checker-report.xml")

-

- ignore_prefix = ""

- if env.get("TEST_IGNORE_RESULT", False) :

- ignore_prefix = "-"

-

- # Set environment variables for running the test

- test_env = env.Clone()

- for i in ["HOME", "USERPROFILE", "APPDATA"]:

- if os.environ.get(i, "") :

- test_env["ENV"][i] = os.environ[i]

- if test_env["PLATFORM"] == "darwin" :

- test_env["ENV"]["DYLD_FALLBACK_LIBRARY_PATH"] = ":".join(map(lambda x : str(x), test_env.get("LIBPATH", [])))

- elif test_env["PLATFORM"] == "win32" :

- test_env["ENV"]["PATH"] = ";".join(map(lambda x : str(x), test_env.get("LIBRUNPATH", []))) + ";" + test_env["ENV"]["PATH"]

-

- # Run the test

- test_env.Command("**dummy**", target,

- SCons.Action.Action(ignore_prefix + env.get("TEST_RUNNER", "") + cmd + " " + params, cmdstr = "$TESTCOMSTR"))

-

- def registerScriptTests(env, scripts, name, type) :

- if env["TEST_TYPE"] == "all" or env["TEST_TYPE"] == type :

- pass

-

- env.AddMethod(registerTest, "Test")

- env.AddMethod(registerScriptTests, "ScriptTests")

- return True

- def createWindowsBundle(env, bundle, resources = {}, qtimageformats = [], qtlibs = []) :

- all_files = []

- all_files += env.Install(bundle, bundle + ".exe")

- for lib in qtlibs :

- all_files += env.Install(bundle, os.path.join(env["QTDIR"], "bin", lib + ".dll"))

- all_files += env.Install(os.path.join(bundle, "imageformats"), [os.path.join(env["QTDIR"], "plugins", "imageformats", "q" + codec + "4.dll") for codec in qtimageformats])

-

- for dir, resourceFiles in resources.items() :

- for resource in resourceFiles :

- e = env.Entry(resource)

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

- return all_files

-

- env.AddMethod(createWindowsBundle, "WindowsBundle")

-def exists(env) :

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

- def replacePragmaOnce(env, target, source) :

- f = open(str(target[0]), 'wb')

- f.write(source[0].get_contents())

- f.close()

- env["BUILDERS"]["WriteVal"] = SCons.Builder.Builder(

- action = SCons.Action.Action(replacePragmaOnce, cmdstr = "$GENCOMSTR"),

- single_source = True)

- return True

- - Extract the target from the nsis file

- - When a target is provided use the output function

- """Add Builders and construction variables for qt to an Environment."""

- Builder = SCons.Builder.Builder

- env['NSIS_MAKENSIS'] = 'makensis'

- env['NSIS_OPTIONS'] = ["/V2"]

- def winToLocalReformat(path) :

- return os.path.join(*path.split("\\"))

- def scanNsisContent(node, env, path, arg):

- contents = node.get_contents()

- includes = nsisFiles_re.findall(contents) + nsisIncludes_re.findall(contents)

- includes = [ winToLocalReformat(include) for include in includes ]

- return filter(lambda x: x.rfind('*')==-1, includes)

- nsisscanner = env.Scanner(name = 'nsisfile',

- function = scanNsisContent,

- argument = None,

- skeys = ['.nsi'])

- nsisbuilder = Builder(

- action = SCons.Action.Action('$NSIS_MAKENSIS $NSIS_OPTIONS $SOURCE', cmdstr = '$NSISCOMSTR'),

- source_scanner = nsisscanner,

- single_source = True

- )

- env.Append( BUILDERS={'Nsis' : nsisbuilder} )

- return True

- pass

- pass

- pass

- return os.popen('winepath -w "%s"'%path).read().strip().replace('\\','/')

- header_extensions.append('.H')

- moc = target[0]

- cpp = source[0]

- # looks like cpp.includes is cleared before the build stage :-(

- # not really sure about the path transformations (moc.cwd? cpp.cwd?) :-/

- path = SCons.Defaults.CScan.path_function(env, moc.cwd)

- includes = SCons.Defaults.CScan(cpp, env, path)

- if not moc in includes:

- SCons.Warnings.warn(

- GeneratedMocFileNotIncluded,

- "Generated moc file '%s' is not included by '%s'" %

- (str(moc), str(cpp)))

- for dir in paths:

- node = node_factory(filename, dir)

- if node.rexists():

- return node

- return None

- """

- Callable class, which works as an emitter for Programs, SharedLibraries and

- StaticLibraries.

- """

-

- def __init__(self, objBuilderName):

- self.objBuilderName = objBuilderName

-

- def __call__(self, target, source, env):

- """

- Smart autoscan function. Gets the list of objects for the Program

- or Lib. Adds objects and builders for the special qt files.

- """

- try:

- if int(env.subst('$QT4_AUTOSCAN')) == 0:

- return target, source

- except ValueError:

- pass

- try:

- debug = int(env.subst('$QT4_DEBUG'))

- except ValueError:

- debug = 0

-

- # some shortcuts used in the scanner

- splitext = SCons.Util.splitext

- objBuilder = getattr(env, self.objBuilderName)

-

- # some regular expressions:

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

- objBuilder.env = 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:

- if isinstance(obj,basestring): # big kludge!

- print "scons: qt4: '%s' MAYBE USING AN OLD SCONS VERSION AND NOT CONVERTED TO 'File'. Discarded." % str(obj)

- continue

- if not obj.has_builder():

- # binary obj file provided

- if debug:

- print "scons: qt: '%s' seems to be a binary. Discarded." % str(obj)

- continue

- cpp = obj.sources[0]

- if not splitext(str(cpp))[1] in cxx_suffixes:

- if debug:

- print "scons: qt: '%s' is no cxx file. Discarded." % str(cpp)

- # c or fortran source

- continue

- #cpp_contents = comment.sub('', cpp.get_contents())

- try:

- cpp_contents = cpp.get_contents()

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

- print "scons: qt: Scanning '%s' (header of '%s')" % (str(h), str(cpp))

- #h_contents = comment.sub('', h.get_contents())

- h_contents = h.get_contents()

- break

- if not h and debug:

- print "scons: qt: no header for '%s'." % (str(cpp))

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

- print "scons: qt: found Q_OBJECT macro in '%s', moc'ing to '%s'" % (str(h), str(moc_cpp))

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

- print "scons: qt: found Q_OBJECT macro in '%s', moc'ing to '%s'" % (str(cpp), str(moc))

- #moc.source_scanner = SCons.Defaults.CScan

- # restore the original env attributes (FIXME)

- objBuilder.env = objBuilderEnv

- env.Moc4.env = mocBuilderEnv

-

- return (target, out_sources)

- """Not really safe, but fast method to detect the QT library"""

- try: return env['QTDIR']

- except KeyError: pass

-

- try: return os.environ['QTDIR']

- except KeyError: pass

-

- moc = env.WhereIs('moc-qt4') or env.WhereIs('moc4') or env.WhereIs('moc')

- if moc:

- import sys

- if sys.platform == "darwin" :

- return ""

- QTDIR = os.path.dirname(os.path.dirname(moc))

- SCons.Warnings.warn(

- QtdirNotFound,

- "QTDIR variable is not defined, using moc executable as a hint (QTDIR=%s)" % QTDIR)

- return QTDIR

-

- raise SCons.Errors.StopError(

- QtdirNotFound,

- "Could not detect Qt 4 installation")

- return None

- """Add Builders and construction variables for qt to an Environment."""

-

- def locateQt4Command(env, command, qtdir) :

- if len(qtdir) == 0 :

- qtdir = "/usr"

- suffixes = [

- '-qt4',

- '-qt4.exe',

- '4',

- '4.exe',

- '',

- '.exe',

- ]

- triedPaths = []

- for suffix in suffixes :

- fullpath = os.path.join(qtdir,'bin',command + suffix)

- if os.access(fullpath, os.X_OK) :

- return fullpath

- triedPaths.append(fullpath)

-

- fullpath = env.Detect([command+'-qt4', command+'4', command])

- if not (fullpath is None) : return fullpath

-

- raise Exception("Qt4 command '" + command + "' not found. Tried: " + ', '.join(triedPaths))

-

-

- CLVar = SCons.Util.CLVar

- Action = SCons.Action.Action

- Builder = SCons.Builder.Builder

- splitext = SCons.Util.splitext

-

- env['QTDIR'] = _detect(env)

- # TODO: 'Replace' should be 'SetDefault'

-# env.SetDefault(

- env.Replace(

- QTDIR = _detect(env),

- # TODO: This is not reliable to QTDIR value changes but needed in order to support '-qt4' variants

- QT4_MOC = locateQt4Command(env,'moc', env['QTDIR']),

- QT4_UIC = locateQt4Command(env,'uic', env['QTDIR']),

- QT4_RCC = locateQt4Command(env,'rcc', env['QTDIR']),

- QT4_LUPDATE = locateQt4Command(env,'lupdate', env['QTDIR']),

- QT4_LRELEASE = locateQt4Command(env,'lrelease', env['QTDIR']),

- QT4_LIB = '', # KLUDGE to avoid linking qt3 library

-

- QT4_AUTOSCAN = 1, # Should the qt tool try to figure out, which sources are to be moc'ed?

-

- # Some QT specific flags. I don't expect someone wants to

- # manipulate those ...

- QT4_UICFLAGS = CLVar(''),

- QT4_MOCFROMHFLAGS = CLVar(''),

- QT4_MOCFROMCXXFLAGS = CLVar('-i'),

- QT4_QRCFLAGS = '',

-

- # suffixes/prefixes for the headers / sources to generate

- QT4_UISUFFIX = '.ui',

- QT4_UICDECLPREFIX = 'ui_',

- QT4_UICDECLSUFFIX = '.h',

- QT4_MOCHPREFIX = 'moc_',

- QT4_MOCHSUFFIX = '$CXXFILESUFFIX',

- QT4_MOCCXXPREFIX = '',

- QT4_MOCCXXSUFFIX = '.moc',

- QT4_QRCSUFFIX = '.qrc',

- QT4_QRCCXXSUFFIX = '$CXXFILESUFFIX',

- QT4_QRCCXXPREFIX = 'qrc_',

- QT4_MOCCPPPATH = [],

- QT4_MOCINCFLAGS = '$( ${_concat("-I", QT4_MOCCPPPATH, INCSUFFIX, __env__, RDirs)} $)',

-

- # Commands for the qt support ...

- QT4_UICCOM = '$QT4_UIC $QT4_UICFLAGS -o $TARGET $SOURCE',

- # FIXME: The -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED flag is a hack to work

- # around an issue in Qt

- # See https://bugreports.qt-project.org/browse/QTBUG-22829

- QT4_MOCFROMHCOM = '$QT4_MOC -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED $QT4_MOCFROMHFLAGS $QT4_MOCINCFLAGS -o $TARGET $SOURCE',

- QT4_MOCFROMCXXCOM = [

- '$QT4_MOC -DBOOST_TT_HAS_OPERATOR_HPP_INCLUDED $QT4_MOCFROMCXXFLAGS $QT4_MOCINCFLAGS -o $TARGET $SOURCE',

- Action(checkMocIncluded,None)],

- QT4_LUPDATECOM = '$QT4_LUPDATE $SOURCE -ts $TARGET',

- QT4_LRELEASECOM = '$QT4_LRELEASE -silent $SOURCE -qm $TARGET',

- QT4_RCCCOM = '$QT4_RCC $QT4_QRCFLAGS -name $SOURCE $SOURCE -o $TARGET',

- )

- if len(env["QTDIR"]) > 0 :

- env.Replace(QT4_LIBPATH = os.path.join('$QTDIR', 'lib'))

-

- # Translation builder

- tsbuilder = Builder(

- action = SCons.Action.Action('$QT4_LUPDATECOM'), #,'$QT4_LUPDATECOMSTR'),

- multi=1

- )

- env.Append( BUILDERS = { 'Ts': tsbuilder } )

- qmbuilder = Builder(

- action = SCons.Action.Action('$QT4_LRELEASECOM', cmdstr = '$QT4_LRELEASECOMSTR'),

- src_suffix = '.ts',

- suffix = '.qm',

- single_source = True

- )

- env.Append( BUILDERS = { 'Qm': qmbuilder } )

-

- # Resource builder

- def scanResources(node, env, path, arg):

- # I've being careful on providing names relative to the qrc file

- # If that was not needed that code could be simplified a lot

- 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

- contents = node.get_contents()

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

- function = scanResources,

- argument = None,

- skeys = ['.qrc'])

- qrcbuilder = Builder(

- action = SCons.Action.Action('$QT4_RCCCOM', cmdstr = '$QT4_RCCCOMSTR'),

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

- action = SCons.Action.Action('$QT4_UICCOM', cmdstr = '$QT4_UICCOMSTR'),

- 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

- mocBld = Builder(action={}, prefix={}, suffix={})

- for h in header_extensions:

- act = SCons.Action.Action('$QT4_MOCFROMHCOM', cmdstr = '$QT4_MOCFROMHCOMSTR')

- mocBld.add_action(h, act)

- mocBld.prefix[h] = '$QT4_MOCHPREFIX'

- mocBld.suffix[h] = '$QT4_MOCHSUFFIX'

- for cxx in cxx_suffixes:

- act = SCons.Action.Action('$QT4_MOCFROMCXXCOM', cmdstr = '$QT4_MOCFROMCXXCOMSTR')

- mocBld.add_action(cxx, act)

- mocBld.prefix[cxx] = '$QT4_MOCCXXPREFIX'

- mocBld.suffix[cxx] = '$QT4_MOCCXXSUFFIX'

- env['BUILDERS']['Moc4'] = mocBld

-

- # er... no idea what that was for

- static_obj, shared_obj = SCons.Tool.createObjBuilders(env)

- static_obj.src_builder.append('Uic4')

- shared_obj.src_builder.append('Uic4')

-

- # We use the emitters of Program / StaticLibrary / SharedLibrary

- # to scan for moc'able files

- # We can't refer to the builders directly, we have to fetch them

- # as Environment attributes because that sets them up to be called

- # correctly later by our emitter.

- env.AppendUnique(PROGEMITTER =[AutomocStatic],

- SHLIBEMITTER=[AutomocShared],

- LIBEMITTER =[AutomocStatic],

- # Of course, we need to link against the qt libraries

- LIBPATH=["$QT4_LIBPATH"],

- LIBS=['$QT4_LIB'])

-

- # TODO: Does dbusxml2cpp need an adapter

- env.AddMethod(enable_modules, "EnableQt4Modules")

-

-def enable_modules(self, modules, debug=False, crosscompiling=False) :

- import sys

-

- validModules = [

- 'QtCore',

- 'QtGui',

- 'QtOpenGL',

- 'Qt3Support',

- 'QtAssistant',

- 'QtScript',

- 'QtDBus',

- 'QtSql',

- # The next modules have not been tested yet so, please

- # maybe they require additional work on non Linux platforms

- 'QtNetwork',

- 'QtSvg',

- 'QtTest',

- 'QtXml',

- 'QtXmlPatterns',

- 'QtUiTools',

- 'QtDesigner',

- 'QtDesignerComponents',

- 'QtWebKit',

- 'QtHelp',

- 'QtScript',

- ]

- staticModules = [

- 'QtUiTools',

- ]

- invalidModules=[]

- for module in modules:

- if module not in validModules :

- invalidModules.append(module)

- if invalidModules :

- raise Exception("Modules %s are not Qt4 modules. Valid Qt4 modules are: %s"% (

- str(invalidModules),str(validModules)))

-

- moduleDefines = {

- 'QtScript' : ['QT_SCRIPT_LIB'],

- 'QtSvg' : ['QT_SVG_LIB'],

- 'Qt3Support' : ['QT_QT3SUPPORT_LIB','QT3_SUPPORT'],

- 'QtSql' : ['QT_SQL_LIB'],

- 'QtXml' : ['QT_XML_LIB'],

- 'QtOpenGL' : ['QT_OPENGL_LIB'],

- 'QtGui' : ['QT_GUI_LIB'],

- 'QtNetwork' : ['QT_NETWORK_LIB'],

- 'QtCore' : ['QT_CORE_LIB'],

- }

- for module in modules :

- try : self.AppendUnique(CPPDEFINES=moduleDefines[module])

- except: pass

- debugSuffix = ''

-

- if sys.platform.startswith("linux") and not crosscompiling :

- if debug : debugSuffix = '_debug'

- self.AppendUnique(CPPPATH=[os.path.join("$QTDIR","include", "phonon")])

- for module in modules :

- self.AppendUnique(LIBS=[module+debugSuffix])

- self.AppendUnique(LIBPATH=[os.path.join("$QTDIR","lib")])

- self.AppendUnique(CPPPATH=[os.path.join("$QTDIR","include")])

- self.AppendUnique(CPPPATH=[os.path.join("$QTDIR","include",module)])

- self["QT4_MOCCPPPATH"] = self["CPPPATH"]

- return

-

- if sys.platform == "win32" or crosscompiling :

- if crosscompiling:

- transformedQtdir = transformToWinePath(self['QTDIR'])

- self['QT4_MOC'] = "QTDIR=%s %s"%( transformedQtdir, self['QT4_MOC'])

- self.AppendUnique(CPPPATH=[os.path.join("$QTDIR","include")])

- try: modules.remove("QtDBus")

- except: pass

- if debug : debugSuffix = 'd'

- if "QtAssistant" in modules:

- self.AppendUnique(CPPPATH=[os.path.join("$QTDIR","include","QtAssistant")])

- modules.remove("QtAssistant")

- modules.append("QtAssistantClient")

- # FIXME: Phonon Hack

- self.AppendUnique(LIBS=['phonon'+debugSuffix+'4'])

- self.AppendUnique(LIBS=[lib+debugSuffix+'4' for lib in modules if lib not in staticModules])

- self.PrependUnique(LIBS=[lib+debugSuffix for lib in modules if lib in staticModules])

- if 'QtOpenGL' in modules:

- self.AppendUnique(LIBS=['opengl32'])

- self.AppendUnique(CPPPATH=[ '$QTDIR/include/'])

- self.AppendUnique(CPPPATH=[ '$QTDIR/include/'+module for module in modules])

- if crosscompiling :

- self["QT4_MOCCPPPATH"] = [

- path.replace('$QTDIR', transformedQtdir)

- for path in self['CPPPATH'] ]

- else :

- self["QT4_MOCCPPPATH"] = self["CPPPATH"]

- self.AppendUnique(LIBPATH=[os.path.join('$QTDIR','lib')])

- return

-

- if sys.platform=="darwin" :

- if debug : debugSuffix = 'd'

-

- if len(self["QTDIR"]) > 0 :

- self.AppendUnique(LIBPATH=[os.path.join('$QTDIR','lib')])

- self.AppendUnique(LINKFLAGS="-F$QTDIR/lib")

- self.AppendUnique(CPPFLAGS="-F$QTDIR/lib")

- self.AppendUnique(LINKFLAGS="-L$QTDIR/lib") #TODO clean!

-

- # FIXME: Phonon Hack

- self.Append(LINKFLAGS=['-framework', "phonon"])

-

- for module in modules :

- if module in staticModules :

- self.AppendUnique(LIBS=[module+debugSuffix]) # TODO: Add the debug suffix

- self.AppendUnique(LIBPATH=[os.path.join("$QTDIR","lib")])

- else :

- if len(self["QTDIR"]) > 0 :

- self.Append(CPPFLAGS = ["-I" + os.path.join("$QTDIR", "lib", module + ".framework", "Versions", "4", "Headers")])

- else :

- self.Append(CPPFLAGS = ["-I" + os.path.join("/Library/Frameworks", module + ".framework", "Versions", "4", "Headers")])

- self.Append(LINKFLAGS=['-framework', module])

- if 'QtOpenGL' in modules:

- self.AppendUnique(LINKFLAGS="-F/System/Library/Frameworks")

- self.Append(LINKFLAGS=['-framework', 'AGL']) #TODO ughly kludge to avoid quotes

- self.Append(LINKFLAGS=['-framework', 'OpenGL'])

- self["QT4_MOCCPPPATH"] = self["CPPPATH"]

- return _detect(env)

-# -*- python -*-

-#

-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 The SCons Foundation

-#

-# Permission is hereby granted, free of charge, to any person obtaining

-# a copy of this software and associated documentation files (the

-# "Software"), to deal in the Software without restriction, including

-# without limitation the rights to use, copy, modify, merge, publish,

-# distribute, sublicense, and/or sell copies of the Software, and to

-# permit persons to whom the Software is furnished to do so, subject to

-# the following conditions:

-#

-# The above copyright notice and this permission notice shall be included

-# in all copies or substantial portions of the Software.

-#

-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-#

-

-__doc__ = """

-Textfile/Substfile builder for SCons.

-

- Create file 'target' which typically is a textfile. The 'source'

- may be any combination of strings, Nodes, or lists of same. A

- 'linesep' will be put between any part written and defaults to

- os.linesep.

-

- The only difference between the Textfile builder and the Substfile

- builder is that strings are converted to Value() nodes for the

- former and File() nodes for the latter. To insert files in the

- former or strings in the latter, wrap them in a File() or Value(),

- respectively.

-

- The values of SUBST_DICT first have any construction variables

- expanded (its keys are not expanded). If a value of SUBST_DICT is

- a python callable function, it is called and the result is expanded

- as the value. Values are substituted in a "random" order; if any

- substitution could be further expanded by another subsitition, it

- is unpredictible whether the expansion will occur.

-"""

-

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

-

-import SCons

-

-import os

-import re

-

-from SCons.Node import Node

-from SCons.Node.Python import Value

-from SCons.Util import is_String, is_Sequence, is_Dict

-

-def _do_subst(node, subs):

- """

- Fetch the node contents and replace all instances of the keys with

- their values. For example, if subs is

- {'%VERSION%': '1.2345', '%BASE%': 'MyProg', '%prefix%': '/bin'},

- then all instances of %VERSION% in the file will be replaced with

- 1.2345 and so forth.

- """

- contents = node.get_text_contents()

- if not subs: return contents

- for (k,v) in subs:

- contents = re.sub(k, v, contents)

- return contents

-

-def _action(target, source, env):

- # prepare the line separator

- linesep = env['LINESEPARATOR']

- if linesep is None:

- linesep = os.linesep

- elif is_String(linesep):

- pass

- elif isinstance(linesep, Value):

- linesep = linesep.get_text_contents()

- else:

- raise SCons.Errors.UserError(

- 'unexpected type/class for LINESEPARATOR: %s'

- % repr(linesep), None)

-

- # create a dictionary to use for the substitutions

- if 'SUBST_DICT' not in env:

- subs = None # no substitutions

- else:

- d = env['SUBST_DICT']

- if is_Dict(d):

- d = list(d.items())

- elif is_Sequence(d):

- pass

- else:

- raise SCons.Errors.UserError('SUBST_DICT must be dict or sequence')

- subs = []

- for (k,v) in d:

- if callable(v):

- v = v()

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

- except (OSError,IOError), e:

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

- fd.write(_do_subst(s, subs))

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

- _convert_list_R(newlist, elem)

- elif isinstance(elem, Node):

- newlist.append(elem)

- else:

- newlist.append(Value(elem))

-def _convert_list(target, source, env):

- if len(target) != 1:

- raise SCons.Errors.UserError("Only one target file allowed")

- newlist = []

- _convert_list_R(newlist, source)

- return target, newlist

-

-_common_varlist = ['SUBST_DICT', 'LINESEPARATOR']

-

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

-_text_builder = SCons.Builder.Builder(

- action = SCons.Action.Action(_action, _strfunc, varlist = _text_varlist),

- source_factory = Value,

- emitter = _convert_list,

- prefix = '$TEXTFILEPREFIX',

- suffix = '$TEXTFILESUFFIX',

- )

-

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

-_subst_builder = SCons.Builder.Builder(

- action = SCons.Action.Action(_action, _strfunc, varlist = _subst_varlist),

- source_factory = SCons.Node.FS.File,

- emitter = _convert_list,

- prefix = '$SUBSTFILEPREFIX',

- suffix = '$SUBSTFILESUFFIX',

- src_suffix = ['.in'],

- )

-

-def generate(env):

- env['LINESEPARATOR'] = os.linesep

- env['BUILDERS']['MyTextfile'] = _text_builder

- env['TEXTFILEPREFIX'] = ''

- env['TEXTFILESUFFIX'] = '.txt'

- env['BUILDERS']['MySubstfile'] = _subst_builder

- env['SUBSTFILEPREFIX'] = ''

- env['SUBSTFILESUFFIX'] = ''

-

-def exists(env):

- return 1

-

-# Local Variables:

-# tab-width:4

-# indent-tabs-mode:nil

-# End:

-# vim: set expandtab tabstop=4 shiftwidth=4:

- wixPath = env.get("wix_bindir", "")

- if len(wixPath) > 0 and wixPath[-1] != "\\":

- wixPath += "\\"

- env['WIX_HEAT'] = wixPath + 'heat.exe'

- env['WIX_HEAT_OPTIONS'] = '-nologo -gg -sfrag -suid -template fragment -dr ProgramFilesFolder'

- env['WIX_CANDLE'] = wixPath + 'candle.exe'

- env['WIX_CANDLE_OPTIONS'] = '-nologo'

- env['WIX_LIGHT'] = wixPath + 'light.exe'

- env['WIX_LIGHT_OPTIONS'] = '-nologo -ext WixUIExtension'

-

- def WiX_IncludeScanner(source, env, path, arg):

- wixIncludeRegexp = re.compile(r'^\s*\<\?include (\S+.wxs)\s*\?\>\S*', re.M)

- contents = source.get_contents()

- includes = wixIncludeRegexp.findall(contents)

- return [ "" + include for include in includes ]

-

- heat_builder = SCons.Builder.Builder(

- action = '"$WIX_HEAT" dir Swift\\QtUI\\Swift -cg Files $WIX_HEAT_OPTIONS -o ${TARGET} -t Swift\\Packaging\\WiX\\include.xslt',

- suffix = '.wxi')

-

-

- candle_scanner = env.Scanner(name = 'wixincludefile',

- function = WiX_IncludeScanner,

- argument = None,

- skeys = ['.wxs'])

-

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

- action = '"$WIX_LIGHT" $WIX_LIGHT_OPTIONS -b Swift\\QtUI\\Swift ${SOURCES} -o ${TARGET}',

- 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

- return True

-

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

-

-def getGitBuildVersion(project) :

- tag = git("describe --tags --exact --match \"" + project + "-*\"")

- if tag :

- return tag.rstrip()[len(project)+1:]

- tag = git("describe --tags --match \"" + project + "-*\"")

- if tag :

- m = re.match(project + "-(.*)-(.*)-(.*)", tag)

- if m :

- return m.group(1) + "-dev" + m.group(2)

- return None

-

-def git(cmd) :

- p = subprocess.Popen("git " + cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=(os.name != "nt"))

- gitVersion = p.stdout.read()

- p.stdin.close()

- return gitVersion if p.wait() == 0 else None

- versionFilename = os.path.join(root, "VERSION." + project)

- if os.path.isfile(versionFilename) :

- f = open(versionFilename)

- version = f.read().strip()

- f.close()

- return version

-

- gitVersion = getGitBuildVersion(project)

- if gitVersion :

- return gitVersion

-

- return datetime.date.today().strftime("%Y%m%d")

-

-def convertToWindowsVersion(version) :

- version_match = re.match("(\d+)\.(\d+)(.*)", version)

- major = int(version_match.group(1)) if version_match else 0

- minor = int(version_match.group(2)) if version_match else 0

- if version_match and len(version_match.group(3)) == 0 :

- patch = 99999

- else :

- match = re.match("^beta(\d+)(.*)", version_match.group(3))

- build_string = ""

- if match :

- patch = 1000*int(match.group(1))

- build_string = match.group(2)

- else :

- rc_match = re.match("^rc(\d+)(.*)", version_match.group(3))

- if rc_match :

- patch = 10000*int(rc_match.group(1))

- build_string = rc_match.group(2)

- else :

- patch = 0

- alpha_match = re.match("^alpha(.*)", version_match.group(3))

- if alpha_match :

- build_string = alpha_match.group(1)

-

- if len(build_string) > 0 :

- build_match = re.match("^-dev(\d+)", build_string)

- if build_match :

- patch += int(build_match.group(1))

- project = m.group(1)

- last_version = m.group(2)

- project="swift-im"

-if "dev" in version :

- distribution = "development"

- distribution = "beta development"

- distribution = "release beta development"

- changelog = open(sys.argv[1])

- changelog_data = changelog.read()

- changelog.close()

- changelog = open(sys.argv[1], "w")

- changelog.write(project + " (" + version + "-1)" + " " + distribution + "; urgency=low\n\n")

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

-