xcodebuild-helper 1.1.1 → 1.2.0

data/externals/oclint/bin/oclint-json-compilation-database

@@ -1,88 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import platform
-import json
-import argparse
-import re
-import subprocess
-import sys
-
-OCLINT_BIN_FOLDER = os.path.dirname(os.path.abspath(__file__))
-OCLINT_BIN = OCLINT_BIN_FOLDER + os.sep + "oclint"
-if platform.system() == "Windows":
-    OCLINT_BIN += ".exe"
-CURRENT_WORKING_DIRECTORY = os.getcwd()
-JSON_COMPILATION_DATABASE = CURRENT_WORKING_DIRECTORY + os.sep + "compile_commands.json"
-
-arg_parser = argparse.ArgumentParser(description='OCLint for JSON Compilation Database (compile_commands.json)')
-arg_parser.add_argument("-v", action="store_true", dest="invocation", help="show invocation command with arguments")
-arg_parser.add_argument('-debug', '--debug', action="store_true", dest="debug", help="invoke OCLint in debug mode")
-arg_parser.add_argument('-i', '-include', '--include', action='append', dest='includes', help="extract files matching pattern")
-arg_parser.add_argument('-e', '-exclude', '--exclude', action='append', dest='excludes', help="remove files matching pattern")
-arg_parser.add_argument('oclint_args', nargs='*', help="arguments that are passed to OCLint invocation")
-args = arg_parser.parse_args()
-
-def get_source_path(file_attr, dir_attr):
-    if file_attr.startswith(os.sep):
-        return file_attr
-    elif dir_attr.endswith(os.sep):
-        return dir_attr + file_attr
-    else:
-        return dir_attr + os.sep + file_attr
-
-def source_exist_at(path):
-    return os.path.isfile(path)
-
-def source_list_inclusion_filter(source_list, inclusion_filter):
-    filtered_list = []
-    for path in source_list:
-        if re.search(inclusion_filter, path):
-            filtered_list.append(path)
-    return filtered_list
-
-def source_list_exclusion_filter(source_list, exclusion_filter):
-    filtered_list = []
-    for path in source_list:
-        if not re.search(exclusion_filter, path):
-            filtered_list.append(path)
-    return filtered_list
-
-if not source_exist_at(OCLINT_BIN):
-    print "Error: OCLint executable file not found."
-    sys.exit(99)
-
-if not source_exist_at(JSON_COMPILATION_DATABASE):
-    print "Error: compile_commands.json not found at current location."
-    sys.exit(98)
-
-compilation_database = json.load(open(JSON_COMPILATION_DATABASE))
-source_list = []
-for file_item in compilation_database:
-    file_path = file_item["file"]
-    if not platform.system() == "Windows":
-        file_path = get_source_path(file_item["file"], file_item["directory"])
-    if source_exist_at(file_path) and not file_path in source_list:
-        source_list.append(file_path)
-if args.includes:
-    matched_list = []
-    for inclusion_filter in args.includes:
-        matched_list.extend( source_list_inclusion_filter(source_list, inclusion_filter) )
-    source_list = matched_list
-if args.excludes:
-    for exclusion_filter in args.excludes:
-        source_list = source_list_exclusion_filter(source_list, exclusion_filter)
-source_paths = '"' + '" "'.join(source_list) + '"'
-oclint_arguments = ''
-if args.oclint_args:
-    oclint_arguments = ' ' + ' '.join(args.oclint_args)
-debug_argument = ''
-if args.debug:
-    debug_argument = ' -debug'
-oclint_invocation = OCLINT_BIN + debug_argument + oclint_arguments + ' ' + source_paths
-if args.invocation:
-    print '------------------------------ OCLint ------------------------------'
-    print oclint_invocation
-    print '--------------------------------------------------------------------'
-exit_code = subprocess.call(oclint_invocation, shell=True)
-sys.exit(exit_code)

data/externals/oclint/bin/oclint-xcodebuild

@@ -1,218 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import sys
-import json
-import argparse
-import re
-import shlex
-import StringIO
-import glob
-import itertools
-
-
-SUPPORTED_COMPILERS = [
-    "clang",
-    "clang\+\+",
-    "llvm-cpp-4.2",
-    "llvm-g\+\+",
-    "llvm-g\+\+-4.2",
-    "llvm-gcc",
-    "llvm-gcc-4.2",
-    "arm-apple-darwin10-llvm-g\+\+-4.2",
-    "arm-apple-darwin10-llvm-gcc-4.2",
-    "i686-apple-darwin10-llvm-g\+\+-4.2",
-    "i686-apple-darwin10-llvm-gcc-4.2",
-    "gcc",
-    "g\+\+",
-    "c\+\+",
-    "cc"
-]
-
-DEFAULT_INPUT_FILE = "xcodebuild.log"
-
-JSON_COMPILATION_DATABASE = "compile_commands.json"
-
-
-_find_unsafe = re.compile('[ "\\\\]').search
-
-def clang_quote(s):
-    """
-    Return a minimally-escaped version of the string *s* that clang-based tools understand.
-    (See http://clang.llvm.org/docs/JSONCompilationDatabase.html)
-    ex:
-      clang_quote('aa') == r'aa'
-      clang_quote('a"a') == r'"a\"a"'
-      clang_quote('--my-option=a"a') == r'"--my-option=a\"a"'
-    """
-    if not s:
-        return '""'
-
-    if _find_unsafe(s) is None:
-        return s
-
-    return '"' + s.replace('\\', '\\\\').replace('"', '\\"') + '"'
-
-
-_find_quoting = re.compile('[\'"\\\\]').search
-
-def tokenize_command(c):
-    """Compute the list of shell arguments in *c* using shlex.split (note: make an explicit call to StringIO for compatibility with Python 2)."""
-    if _find_quoting(c) is None:
-        return map(str.strip, c.strip().split(' '))
-    else:
-        return shlex.split(StringIO.StringIO(c))
-
-# global table to map pth files to (source) pch files
-_pch_dictionary = {}
-
-def register_source_for_pth_file(clang_command, directory):
-    tokens = iter(tokenize_command(clang_command))
-    src_file = ""
-    pth_file = ""
-    try:
-        while 1:
-            tok = tokens.next()
-            if tok == '-c':
-                file = tokens.next()
-                src_file = file
-            elif tok == '-o':
-                file = tokens.next()
-                if file.endswith('.pch.pth') or file.endswith('.pch.pch') or file.endswith('.h.pch'):
-                    pth_file = file
-    except StopIteration:
-        if src_file and pth_file:
-            _pch_dictionary[pth_file] = src_file
-
-def get_source_for_pth_file(file):
-    src_file = _pch_dictionary.get(file + '.pth')
-    if src_file is not None:
-        return src_file
-    return _pch_dictionary.get(file + '.pch')
-
-def process_clang_command(clang_command, directory):
-    tokens = iter(tokenize_command(clang_command))
-    command = []
-    source_file = None
-
-    try:
-        while 1:
-            tok = tokens.next()
-            if tok == '-include':
-                include_file = tokens.next()
-                if not os.path.isfile(include_file):
-                    src_file = get_source_for_pth_file(include_file)
-                    if src_file is not None:
-                        include_file = src_file
-                    else:
-                        print "cannot find original pch source file for %s" % include_file
-                        exit(3)
-                command.append(tok)
-                command.append(clang_quote(include_file))
-
-            elif tok == '-c':
-                source_file = tokens.next()
-                command.append(tok)
-                command.append(clang_quote(source_file))
-
-            else:
-                command.append(clang_quote(tok))
-
-    except StopIteration:
-        return {"directory": directory, "command": " ".join(command), "file": os.path.normpath(source_file)}
-
-
-def read_directory(line):
-    tokens = tokenize_command(line)
-    if tokens[0] == "cd":
-        return tokens[1]
-    else:
-        return ""
-
-def convert(input_file, output_file, is_excluded=None):
-    json_input_mode = input_file.endswith('.json')
-
-    find_compileC = re.compile("CompileC").search
-
-    find_processPCH = re.compile("ProcessPCH").search
-
-    find_clang_command = re.compile("(" + "|".join(SUPPORTED_COMPILERS) + ") .* -c .* -o ").search
-
-    if is_excluded is None:
-        is_excluded = (lambda x: False)
-
-    with open(output_file, "w") as output:
-        with open(input_file, "r") as input:
-            if json_input_mode:
-                lines = itertools.chain(*(json.loads(line).get('command', '').encode("utf8").splitlines(True) for line in input))
-            else:
-                lines = input
-            try:
-                output.write("[")
-                cr = "\n"
-                while 1:
-                    log_line = lines.next()
-                    compilation_section_re = find_compileC(log_line)
-                    if compilation_section_re:
-                        directory = read_directory(lines.next())
-                        if is_excluded(directory):
-                            continue
-                        while 1:
-                            log_line = lines.next()
-                            if not find_clang_command(log_line):
-                                continue
-                            output_record = process_clang_command(log_line, directory)
-                            output.write(cr)
-                            output.write(json.dumps(output_record, indent=2))
-                            cr = ",\n"
-                            break
-                        continue
-                    compilation_section_re = find_processPCH(log_line)
-                    if compilation_section_re:
-                        directory = read_directory(lines.next())
-                        if is_excluded(directory):
-                            continue
-                        while 1:
-                            log_line = lines.next()
-                            if not find_clang_command(log_line):
-                                continue
-                            register_source_for_pth_file(log_line, directory)
-                            break
-                        continue
-            except StopIteration:
-                output.write("\n]\n");
-
-def main():
-    arg_parser = argparse.ArgumentParser(description='Converts xcodebuild logs or xctool-json-reporter logs to compile_commands.json')
-    arg_parser.add_argument("-e", "-exclude", dest="exclusion", help="Directory exclusion pattern (regular expression)")
-    arg_parser.add_argument("-o", "-output", dest="output_file", help="Output json file (default: ./%s)" % JSON_COMPILATION_DATABASE)
-    arg_parser.add_argument(metavar="FILE", nargs='?', dest="input_file", help="Input log file (default: ./%s)" % DEFAULT_INPUT_FILE)
-
-    args = arg_parser.parse_args()
-
-    if args.input_file:
-        input_file = args.input_file
-    else:
-        input_file = DEFAULT_INPUT_FILE
-
-    if args.output_file:
-        output_file = args.output_file
-    else:
-        output_file = JSON_COMPILATION_DATABASE
-
-    if not os.path.isfile(input_file):
-        print "Error: %s not found." % input_file
-        exit(1)
-
-    if args.exclusion:
-        is_excluded = re.compile(args.exclusion).match
-    else:
-        is_excluded = None
-
-    convert(input_file, output_file, is_excluded)
-
-
-if __name__ == '__main__':
-    print "This binary is no longer under maintenance by OCLint team."
-    print "Please consider using xcpretty (https://github.com/supermarin/xcpretty) instead!"
-    main()

data/externals/oclint/lib/clang/3.7.0/asan_blacklist.txt

@@ -1,13 +0,0 @@
-# Blacklist for AddressSanitizer. Turns off instrumentation of particular
-# functions or sources. Use with care. You may set location of blacklist
-# at compile-time using -fsanitize-blacklist=<path> flag.
-
-# Example usage:
-# fun:*bad_function_name*
-# src:file_with_tricky_code.cc
-# global:*global_with_bad_access_or_initialization*
-# global:*global_with_initialization_issues*=init
-# type:*Namespace::ClassName*=init
-
-# Stack buffer overflow in VC/INCLUDE/xlocnum, see http://goo.gl/L4qqUG
-fun:*_Find_elem@*@std*