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)

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

LICENSE_DIR = "Documentation/Licenses"

class License :

licenses = {

class Copyright :

def get_comment_chars_for_filename(filename) :

def get_comment_chars_re_for_filename(filename) :

def parse_file(filename) :

def get_userinfo() :

def get_copyright(username, email) :

def check_copyright(filename) :

def set_copyright(filename, copyright) :

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

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

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

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

env_ENV = {

}

if "MSVC_VERSION" in ARGUMENTS :

else :

Help(vars.GenerateHelpText(env))

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

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

def CheckPKG(context, name):

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

}

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

if ret[0] :

else :

conf = Configure(conf_env)

use_icu = bool(env["icu"])

icu_prefix = ""

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

icu_flags = {}

if icu_prefix :

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

# Unbound

if env["unbound"] :

else :

# LibMiniUPnPc

if env["experimental_ft"] :

# SLOCCount

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

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

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 shutil

def which(program_name):

def generate(env) :

def exists(env) :

import SCons.Util

def generate(env) :

def exists(env) :

__doc__ = """

Textfile/Substfile builder for SCons.

"""

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

from SCons.Util import is_String, is_Sequence, is_Dict

def _do_subst(node, subs):

def _action(target, source, env):

def _strfunc(target, source, env):

def _convert_list_R(newlist, sources):

def _convert_list(target, source, env):

_common_varlist = ['SUBST_DICT', 'LINESEPARATOR']

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

_text_builder = SCons.Builder.Builder(

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

_subst_builder = SCons.Builder.Builder(

def generate(env):

def exists(env):

# Local Variables:

# tab-width:4

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

def getGitBuildVersion(root, project) :

def git(cmd, root) :

def getBuildVersion(root, project) :

def convertToWindowsVersion(version) :

last_version = ""

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

if m :

if project == "" :

if "dev" in version :

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

else :

if last_version != version :

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

# Helper methods & variables

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

SCRIPT = sys.argv[0]

SCONS_ARGS = ' '.join(sys.argv[1:])

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

if sys.platform == 'win32' :

else :

def is_regexp(x) :

def is_list(l) :

def escape(s) :

def quote_spaces(s) :

def to_list(l) :

def partition(l, f) :

def get_unary_flags(prefix, flags) :

def extract_unary_flags(prefix, flags) :

def extract_unary_flag(prefix, flags) :

def extract_binary_flag(prefix, flags) :

def get_non_flags(flags) :

def extract_non_flags(flags) :

def get_dependencies(target, build_targets) :

def get_built_libs(libs, libpaths, outputs) :

def parse_tool_command(line) :

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

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

# Helper for building Ninja files

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

class NinjaBuilder :

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

# Configuration

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

def ninja_custom_command(ninja, line) :

CONFIGURATION_FILE = '.scons2ninja.conf'

execfile(CONFIGURATION_FILE)

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

if sys.platform == 'win32' :

else :

ninja.rule('moc',

ninja.rule('rcc',

ninja.rule('uic',

ninja.rule('lrelease',

ninja.rule('ibtool',

ninja.rule('dsymutil',

ninja.rule('generator',

ninja.rule('sdef',

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

# Build Statements

skip_nth_line = -1

stack = ['.']

for line in f.stdout :

if f.wait() != 0 :

# Pass 2: Parse build rules

tools = {}

for line in build_lines :

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

ninja.build('_generated_headers', 'phony', ninja.header_targets())

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

ninja.variable("scons_args", SCONS_ARGS)

for k, v in tools.iteritems() :

# Extra customizations

if 'ninja_post' in dir() :

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

if env["TEST"] :

if env["SCONS_STAGE"] == "flags" :

env["CHECKER_FLAGS"] = {

"LIBS": ["Checker"],

"LIBPATH": [Dir(".")],

"LINKFLAGS": env["PLATFORM"] == "win32" and ["/SUBSYSTEM:CONSOLE"] or []

qt4modules = ['QtCore', 'QtGui']

if myenv["qt5"] :

else :

myenv.EnableQt4Modules(qt4modules, debug = False, version = qt_version)

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

import Version

def generateDefaultTheme(dir) :

Import("env")

myenv.UseFlags(env["SWIFT_CONTROLLERS_FLAGS"])

myenv.UseFlags(env["SWIFTOOLS_FLAGS"])

if myenv["HAVE_XSS"] :

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

if myenv["HAVE_SPARKLE"] :

myenv.UseFlags(env["SWIFTEN_FLAGS"])

myenv.UseFlags(env["SWIFTEN_DEP_FLAGS"])

if myenv.get("HAVE_BREAKPAD") :

if myenv.get("HAVE_GROWL", False) :

myenv.UseFlags(myenv["GROWL_FLAGS"])

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

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

qt4modules = ['QtCore', 'QtWebKit', 'QtGui']

if myenv["qt5"] :

else :

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

qt4modules += ["QtDBus"]

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

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

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

myenv.WriteVal("DefaultTheme.qrc", myenv.Value(generateDefaultTheme(myenv.Dir("#/Swift/resources/themes/Default"))))

sources = [

# QtVCardWidget

sources.extend([

("SWIFT_VERSION_PATCH", "${SWIFT_VERSION_PATCH}"),

])

res = res_env.RES("#/Swift/resources/Windows/Swift.rc")

# Adding it explicitly until i figure out why

myenv.Depends(res, "../Controllers/BuildVersion.h")

sources += [

sources += ["CocoaUIHelpers.mm"]

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

else :

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

openURIProgram = myenv.Program("swift-open-uri", "swift-open-uri.cpp")

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

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

if env.get("SWIFT_INSTALLDIR", "") :

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

myenv = swiften_env.Clone()

if myenv["target"] == "native":

if myenv["experimental"]:

objects = myenv.SwiftenObject([

myenv = swiften_env.Clone()

if myenv.get("unbound", False) :

sourceList = [

"ProxiedConnection.cpp",