# FIXME: Remove this when Boost UUID is present on most distros

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

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

# Common

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

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

# Flags

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

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

# Build

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

# Module flags

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

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

# Build

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

else :

if env["TEST"] :

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

# Module flags

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

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

# Build

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

Import(["env", "conf_env"])

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

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

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

# Flags

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

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

# Build

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

# Module flags

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

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

# Build

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

# Module flags

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

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

# Build

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

"""

#ifndef __MINIUPNPCSTRINGS_H__

#define __MINIUPNPCSTRINGS_H__

#endif

""".replace("$OS_STRING", myenv["PLATFORM"])))

# Module flags

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

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

# Build

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

# Module flags

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

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

# Build

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

openssl_bundle_dir = "openssl"

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

# Flags

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

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

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

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

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

# Flags

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

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

# Build

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

Import("env")

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

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)

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

elif filename_base.endswith(".cpp") or filename_base.endswith(".mm"):

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

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