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

def _strfunc(target, source, env):

def _convert_list_R(newlist, sources):

def _convert_list(target, source, env):

_common_varlist = ['SUBST_DICT', 'LINESEPARATOR']

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

_text_builder = SCons.Builder.Builder(

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

_subst_builder = SCons.Builder.Builder(

def generate(env):

def exists(env):

# Local Variables:

# tab-width:4

from subprocess import call

def generate(env) :

def exists(env) :

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

def getGitBuildVersion(root, project) :

def git(cmd, root) :

def getBuildVersion(root, project) :

def convertToWindowsVersion(version) :

last_version = ""

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

if m :

if project == "" :

if "dev" in version :

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

else :

if last_version != version :

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

if sys.platform == 'win32' :

else :

def is_regexp(x) :

def is_list(l) :

def escape(s) :

def quote_spaces(s) :

def to_list(l) :

def partition(l, f) :

def get_unary_flags(prefix, flags) :

def extract_unary_flags(prefix, flags) :

def extract_unary_flag(prefix, flags) :

def extract_binary_flag(prefix, flags) :

def get_non_flags(flags) :

def extract_non_flags(flags) :

def get_dependencies(target, build_targets) :

def get_built_libs(libs, libpaths, outputs) :

def parse_tool_command(line) :

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

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

# Helper for building Ninja files

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

class NinjaBuilder :

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

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

def ninja_custom_command(ninja, line) :

CONFIGURATION_FILE = '.scons2ninja.conf'

execfile(CONFIGURATION_FILE)

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

if sys.platform == 'win32' :

else :

ninja.rule('moc',

ninja.rule('rcc',

ninja.rule('uic',

ninja.rule('lrelease',

ninja.rule('ibtool',

ninja.rule('dsymutil',

ninja.rule('generator',

ninja.rule('sdef',

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

# Build Statements

skip_nth_line = -1

stack = ['.']

for line in f.stdout :

if f.wait() != 0 :

# Pass 2: Parse build rules

tools = {}

for line in build_lines :

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

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

ninja.variable("scons_args", SCONS_ARGS)

for k, v in tools.iteritems() :

# Extra customizations

if 'ninja_post' in dir() :

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