repo_name: apple/cups

code:
#!/bin/sh
#
# Test the lpq command.
#
# Copyright © 2007 by Apple Inc.
# Copyright © 1997-2005 by Easy Software Products, all rights reserved.
#
# Licensed under Apache License v2.0.  See the file "LICENSE" for more
# information.
#

echo "LPQ Test"
echo ""
echo "    lpq -P Test1"
$runcups $VALGRIND ../berkeley/lpq -P Test1 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""


code:
#!/bin/sh
#
# Test the lpadmin command.
#
# Copyright © 2007-2018 by Apple Inc.
# Copyright © 1997-2005 by Easy Software Products, all rights reserved.
#
# Licensed under Apache License v2.0.  See the file "LICENSE" for more
# information.
#

echo "Add Printer Test"
echo ""
echo "    lpadmin -p Test3 -v file:/dev/null -E -m drv:///sample.drv/deskjet.ppd"
$runcups $VALGRIND ../systemv/lpadmin -p Test3 -v file:/dev/null -E -m drv:///sample.drv/deskjet.ppd 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	if test -f $CUPS_SERVERROOT/ppd/Test3.ppd; then
		echo "    PASSED"
	else
		echo "    FAILED (No PPD)"
		exit 1
	fi
fi
echo ""

echo "Modify Printer Test"
echo ""
echo "    lpadmin -p Test3 -v file:/tmp/Test3 -o PageSize=A4"
$runcups $VALGRIND ../systemv/lpadmin -p Test3 -v file:/tmp/Test3 -o PageSize=A4 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""

echo "Delete Printer Test"
echo ""
echo "    lpadmin -x Test3"
$runcups $VALGRIND ../systemv/lpadmin -x Test3 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""

echo "Add Shared Printer Test"
echo ""
echo "    lpadmin -p Test3 -E -v ipp://localhost:$IPP_PORT/printers/Test2 -m everywhere"
$runcups $VALGRIND ../systemv/lpadmin -p Test3 -E -v ipp://localhost:$IPP_PORT/printers/Test2 -m everywhere 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""


code:
#!/bin/sh
#
# Test the lpstat command.
#
# Copyright © 2007-2019 by Apple Inc.
# Copyright © 1997-2005 by Easy Software Products, all rights reserved.
#
# Licensed under Apache License v2.0.  See the file "LICENSE" for more
# information.
#

echo "LPSTAT Basic Test"
echo ""
echo "    lpstat -t"
$runcups $VALGRIND ../systemv/lpstat -t 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""

echo "LPSTAT Enumeration Test"
echo ""
echo "    lpstat -e"
printers="`$runcups $VALGRIND ../systemv/lpstat -e 2>&1`"
if test $? != 0 -o "x$printers" = x; then
	echo "    FAILED"
	exit 1
else
	for printer in $printers; do
	        echo $printer
	done
	echo "    PASSED"
fi
echo ""

echo "LPSTAT Get Host Test"
echo ""
echo "    lpstat -H"
server="`$runcups $VALGRIND ../systemv/lpstat -H 2>&1`"
if test $? != 0 -o "x$server" != x$CUPS_SERVER; then
	echo "    FAILED ($server)"
	exit 1
else
	echo "    PASSED ($server)"
fi
echo ""


code:
#!/bin/sh
#
# Test the cancel command.
#
# Copyright © 2007-2019 by Apple Inc.
# Copyright © 1997-2006 by Easy Software Products, all rights reserved.
#
# Licensed under Apache License v2.0.  See the file "LICENSE" for more
# information.
#

echo "Cancel Destination Test"
echo ""
echo "    lp -d Test1 -o job-hold-until=indefinite testfile.jpg"
$runcups $VALGRIND ../systemv/lp -d Test1 -o job-hold-until=indefinite ../examples/testfile.jpg 2>&1
echo "    cancel Test1"
$runcups $VALGRIND ../systemv/cancel Test1 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""

echo "Cancel All Test"
echo ""
echo "    cancel -a"
$runcups $VALGRIND ../systemv/cancel -a 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""

echo "Purge All Test"
echo ""
echo "    cancel -a -x"
$runcups $VALGRIND ../systemv/cancel -a -x 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""


code:
#!/bin/sh
#
# Test the lpinfo command.
#
# Copyright © 2007-2019 by Apple Inc.
# Copyright © 1997-2005 by Easy Software Products, all rights reserved.
#
# Licensed under Apache License v2.0.  See the file "LICENSE" for more
# information.
#

echo "LPINFO Devices Test"
echo ""
echo "    lpinfo -v"
$runcups $VALGRIND ../systemv/lpinfo -v 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""

echo "LPINFO Drivers Test"
echo ""
echo "    lpinfo -m"
$runcups $VALGRIND ../systemv/lpinfo -m 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""

echo "LPINFO Drivers Test"
echo ""
echo "    lpinfo -m | grep -q sample.drv"
$runcups $VALGRIND ../systemv/lpinfo -m | grep -q sample.drv 2>&1
if test $? != 0; then
	echo "    FAILED"
	exit 1
else
	echo "    PASSED"
fi
echo ""


repo_name: apple/swift-lldb

license: NOASSERTION

code:
#! /usr/bin/env python

import argparse
import itertools
import os
import re
import sys
from collections import defaultdict

from use_lldb_suite import lldb_root

parser = argparse.ArgumentParser(
    description='Analyze LLDB project #include dependencies.')
parser.add_argument('--show-counts', default=False, action='store_true',
    help='When true, show the number of dependencies from each subproject')
parser.add_argument('--discover-cycles', default=False, action='store_true',
    help='When true, find and display all project dependency cycles.  Note,'
         'this option is very slow')

args = parser.parse_args()

src_dir = os.path.join(lldb_root, "source")
inc_dir = os.path.join(lldb_root, "include")

src_map = {}

include_regex = re.compile('#include \"((lldb|Plugins|clang)(.*/)+).*\"')

def is_sublist(small, big):
    it = iter(big)
    return all(c in it for c in small)

def normalize_host(str):
    if str.startswith("lldb/Host"):
        return "lldb/Host"
    if str.startswith("Plugins"):
        return "lldb/" + str
    if str.startswith("lldb/../../source"):
        return str.replace("lldb/../../source", "lldb")
    return str

def scan_deps(this_dir, file):
    global src_map
    deps = {}
    this_dir = normalize_host(this_dir)
    if this_dir in src_map:
        deps = src_map[this_dir]

    with open(file) as f:
        for line in list(f):
            m = include_regex.match(line)
            if m is None:
                continue
            relative = m.groups()[0].rstrip("/")
            if relative == this_dir:
                continue
            relative = normalize_host(relative)
            if relative in deps:
                deps[relative] += 1
            elif relative != this_dir:
                deps[relative] = 1
    if this_dir not in src_map and len(deps) > 0:
        src_map[this_dir] = deps

for (base, dirs, files) in os.walk(inc_dir):
    dir = os.path.basename(base)
    relative = os.path.relpath(base, inc_dir)
    inc_files = [x for x in files if os.path.splitext(x)[1] in [".h"]]
    relative = relative.replace("\\", "/")
    for inc in inc_files:
        inc_path = os.path.join(base, inc)
        scan_deps(relative, inc_path)

for (base, dirs, files) in os.walk(src_dir):
    dir = os.path.basename(base)
    relative = os.path.relpath(base, src_dir)
    src_files = [x for x in files if os.path.splitext(x)[1] in [".cpp", ".h", ".mm"]]
    norm_base_path = os.path.normpath(os.path.join("lldb", relative))
    norm_base_path = norm_base_path.replace("\\", "/")
    for src in src_files:
        src_path = os.path.join(base, src)
        scan_deps(norm_base_path, src_path)
    pass

def is_existing_cycle(path, cycles):
    # If we have a cycle like # A -> B -> C (with an implicit -> A at the end)
    # then we don't just want to check for an occurrence of A -> B -> C in the
    # list of known cycles, but every possible rotation of A -> B -> C.  For
    # example, if we previously encountered B -> C -> A (with an implicit -> B
    # at the end), then A -> B -> C is also a cycle.  This is an important
    # optimization which reduces the search space by multiple orders of
    # magnitude.
    for i in range(0,len(path)):
        if any(is_sublist(x, path) for x in cycles):
            return True
        path = [path[-1]] + path[0:-1]
    return False

def expand(path_queue, path_lengths, cycles, src_map):
    # We do a breadth first search, to make sure we visit all paths in order
    # of ascending length.  This is an important optimization to make sure that
    # short cycles are discovered first, which will allow us to discard longer
    # cycles which grow the search space exponentially the longer they get.
    while len(path_queue) > 0:
        cur_path = path_queue.pop(0)
        if is_existing_cycle(cur_path, cycles):
            continue

        next_len = path_lengths.pop(0) + 1
        last_component = cur_path[-1]

        for item in src_map[last_component]:
            if item.startswith("clang"):
                continue

            if item in cur_path:
                # This is a cycle.  Minimize it and then check if the result is
                # already in the list of cycles.  Insert it (or not) and then
                # exit.
                new_index = cur_path.index(item)
                cycle = cur_path[new_index:]
                if not is_existing_cycle(cycle, cycles):
                    cycles.append(cycle)
                continue

            path_lengths.append(next_len)
            path_queue.append(cur_path + [item])
    pass

cycles = []

path_queue = [[x] for x in iter(src_map)]
path_lens = [1] * len(path_queue)

items = list(src_map.items())
items.sort(key = lambda A : A[0])

for (path, deps) in items:
    print(path + ":")
    sorted_deps = list(deps.items())
    if args.show_counts:
        sorted_deps.sort(key = lambda A: (A[1], A[0]))
        for dep in sorted_deps:
            print("\t{} [{}]".format(dep[0], dep[1]))
    else:
        sorted_deps.sort(key = lambda A: A[0])
        for dep in sorted_deps:
            print("\t{}".format(dep[0]))

def iter_cycles(cycles):
    global src_map
    for cycle in cycles:
        cycle.append(cycle[0])
        zipper = list(zip(cycle[0:-1], cycle[1:]))
        result = [(x, src_map[x][y], y) for (x,y) in zipper]
        total = 0
        smallest = result[0][1]
        for (first, value, last) in result:
            total += value
            smallest = min(smallest, value)
        yield (total, smallest, result)

if args.discover_cycles:
    print("Analyzing cycles...")

    expand(path_queue, path_lens, cycles, src_map)

    average = sum([len(x)+1 for x in cycles]) / len(cycles)

    print("Found {} cycles.  Average cycle length = {}.".format(len(cycles), average))
    counted = list(iter_cycles(cycles))
    if args.show_counts:
        counted.sort(key = lambda A: A[0])
        for (total, smallest, cycle) in counted:
            sys.stdout.write("{} deps to break: ".format(total))
            sys.stdout.write(cycle[0][0])
            for (first, count, last) in cycle:
                sys.stdout.write(" [{}->] {}".format(count, last))
            sys.stdout.write("\n")
    else:
        for cycle in cycles:
            cycle.append(cycle[0])
            print(" -> ".join(cycle))

    print("Analyzing islands...")
    islands = []
    outgoing_counts = defaultdict(int)
    incoming_counts = defaultdict(int)
    for (total, smallest, cycle) in counted:
        for (first, count, last) in cycle:
            outgoing_counts[first] += count
            incoming_counts[last] += count
    for cycle in cycles:
        this_cycle = set(cycle)
        disjoints = [x for x in islands if this_cycle.isdisjoint(x)]
        overlaps = [x for x in islands if not this_cycle.isdisjoint(x)]
        islands = disjoints + [set.union(this_cycle, *overlaps)]
    print("Found {} disjoint cycle islands...".format(len(islands)))
    for island in islands:
        print("Island ({} elements)".format(len(island)))
        sorted = []
        for node in island:
            sorted.append((node, incoming_counts[node], outgoing_counts[node]))
        sorted.sort(key = lambda x: x[1]+x[2])
        for (node, inc, outg) in sorted:
            print("  {} [{} in, {} out]".format(node, inc, outg))
    sys.stdout.flush()
pass


code:
# -*- Python -*-

import os
import platform
import re
import shutil
import site
import sys

import lit.formats
from lit.llvm import llvm_config
from lit.llvm.subst import FindTool
from lit.llvm.subst import ToolSubst

site.addsitedir(os.path.dirname(__file__))
from helper import toolchain

# name: The name of this test suite.
config.name = 'LLDB'

# testFormat: The test format to use to interpret tests.
config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)

# suffixes: A list of file extensions to treat as test files. This is overriden
# by individual lit.local.cfg files in the test subdirectories.
config.suffixes = ['.test', '.cpp', '.s']

# excludes: A list of directories to exclude from the testsuite. The 'Inputs'
# subdirectories contain auxiliary inputs for various tests in their parent
# directories.
config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']

# test_source_root: The root path where tests are located.
config.test_source_root = os.path.dirname(__file__)

# test_exec_root: The root path where tests should be run.
config.test_exec_root = os.path.join(config.lldb_obj_root, 'lit')

# Begin Swift mod.
# Swift's libReflection builds without ASAN, which causes a known
# false positive in std::vector. If sanitizers are off, this is just
# a no-op
config.environment['ASAN_OPTIONS'] = 'detect_container_overflow=0'
# End Swift mod.

llvm_config.use_default_substitutions()

toolchain.use_lldb_substitutions(config)

toolchain.use_support_substitutions(config)

if re.match(r'^arm(hf.*-linux)|(.*-linux-gnuabihf)', config.target_triple):
    config.available_features.add("armhf-linux")

def calculate_arch_features(arch_string):
    # This will add a feature such as x86, arm, mips, etc for each built
    # target
    features = []
    for arch in arch_string.split():
        features.append(arch.lower())
    return features

# Run llvm-config and add automatically add features for whether we have
# assertions enabled, whether we are in debug mode, and what targets we
# are built for.
llvm_config.feature_config(
    [('--assertion-mode', {'ON': 'asserts'}),
     ('--build-mode', {'DEBUG': 'debug'}),
     ('--targets-built', calculate_arch_features)
     ])

# Clean the module caches in the test build directory. This is necessary in an
# incremental build whenever clang changes underneath, so doing it once per
# lit.py invocation is close enough.
for cachedir in [config.clang_module_cache, config.lldb_module_cache]:
    if os.path.isdir(cachedir):
        print("Deleting module cache at %s."%cachedir)
        shutil.rmtree(cachedir)

# Set a default per-test timeout of 10 minutes. Setting a timeout per test
# requires that killProcessAndChildren() is supported on the platform and
# lit complains if the value is set but it is not supported.
supported, errormsg = lit_config.maxIndividualTestTimeIsSupported
if supported:
    lit_config.maxIndividualTestTime = 900
else:
    lit_config.warning("Could not set a default per-test timeout. " + errormsg)

# If running tests natively, check for CPU features needed for some tests.

if 'native' in config.available_features:
    cpuid_exe = lit.util.which('lit-cpuid', config.lldb_tools_dir)
    if cpuid_exe is None:
        lit_config.warning("lit-cpuid not found, tests requiring CPU extensions will be skipped")
    else:
        out, err, exitcode = lit.util.executeCommand([cpuid_exe])
        if exitcode == 0:
            for x in out.split():
                config.available_features.add('native-cpu-%s' % x)
        else:
            lit_config.warning("lit-cpuid failed: %s" % err)

if not config.lldb_disable_python:
    config.available_features.add('python')


code:
#!/usr/bin/env python

# install-lldb-swift.py
#
# This source file is part of the Swift.org open source project
#
# Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
# Licensed under Apache License v2.0 with Runtime Library Exception
#
# See https://swift.org/LICENSE.txt for license information
# See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
#
# ------------------------------------------------------------------------------

# This script will install the files from an LLDB build into Xcode.

import argparse
import os
import shutil
import sys

parser = argparse.ArgumentParser(
    description="Installs the files from an LLDB build into Xcode.  Without options, tries to do the right thing.")
parser.add_argument("-l", "--lldb", help="Path to build/Configuration.")
parser.add_argument(
    "-s",
    "--swift",
    help="Path to llvm-build/LLVMConfig/arch/LLVMConfig.")
parser.add_argument("-x", "--xcode", help="Path to Xcode.app.")
parser.add_argument(
    "-d",
    "--dry",
    help="Dry run: log what would happen but don't do it.",
    action="store_true")

args = parser.parse_args()

def checkCandidates(candidates, checker):
    for candidate in candidates:
        if checker(candidate):
            return candidate
    return None

# Checker helpers

def checkDirOrLink(path):
    return (os.path.isdir(path) or os.path.islink(path))

def checkFileOrLink(path):
    return (os.path.isfile(path) or os.path.islink(path))

# Find an LLDB build

def checkLLDB(path):
    if not checkFileOrLink(path + "/lldb"):
        return False
    if not checkDirOrLink(path + "/LLDB.framework"):
        return False
    return True

def findLLDB():
    lldb_candidates = [
        "build/DebugClang",
        "build/Debug",
        "build/Release"
    ]
    return checkCandidates(lldb_candidates, checkLLDB)

# Find a Swift build

def checkSwift(path):
    if not checkFileOrLink(path + "/bin/swift"):
        return False
    if not checkDirOrLink(path + "/lib/swift"):
        return False
    return True

def findSwift():
    swift_candidates = [
        "llvm-build/Debug+Asserts/x86_64",
        "llvm-build/Debug/x86_64",
        "llvm-build/Release+Debug/x86_64",
        "llvm-build/Release+Asserts/x86_64",
        "llvm-build/Release/x86_64"
    ]
    return checkCandidates(swift_candidates, checkSwift)

# Find an Xcode installation

def checkXcode(path):
    if not checkFileOrLink(
            path +
            "/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swift"):
        return False
    if not checkDirOrLink(
            path +
            "/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift"):
        return False
    return True

def findXcode():
    xcode_candidates = [
        "/Applications/Xcode.app"
    ]
    return checkCandidates(xcode_candidates, checkXcode)

# Check input arguments

def getPaths():
    lldb = None

    if args.lldb:
        lldb = args.lldb
    else:
        lldb = findLLDB()

    swift = None

    if args.swift:
        swift = args.swift
    else:
        swift = findSwift()

    xcode = None

    if args.xcode:
        xcode = args.xcode
    else:
        xcode = findXcode()

    if not lldb:
        print "Couldn't find LLDB automatically.  Please use --lldb."
        return None
    if not checkLLDB(lldb):
        print "The path passed to --lldb is not a valid LLDB build."
        return None

    if not swift:
        print "Couldn't find Swift automatically.  Please use --swift."
        return None
    if not checkSwift(swift):
        print "The path passed to --swift is not a valid Swift build."
        return None

    if not xcode:
        print "Couldn't find Xcode automatically.  Please use --xcode."
        return None
    if not checkXcode(xcode):
        print "The path passed to --xcode is not a valid Xcode installation."
        return None

    return (lldb, swift, xcode)

# Work unit classes

class WorkUnit:

    def __init__(self, from_path, to_path):
        self.from_path = from_path
        self.to_path = to_path
        self.backup_path = to_path + ".backup"

    # basic operations

    def remove(self, path):
        if os.path.islink(path):
            print "Remove alias " + self.to_path
        elif os.path.isdir(path):
            print "Remove (recursive) " + self.to_path
        else:
            print "Remove " + self.to_path
        if not args.dry:
            if os.path.islink(path):
                os.remove(path)
            elif os.path.isdir(path):
                shutil.rmtree(path)
            else:
                os.remove(path)

    def removeBackup(self):
        self.remove(self.backup_path)

    def backupUnchecked(self):
        print "Move " + self.to_path + " to " + self.backup_path
        if not args.dry:
            os.rename(self.to_path, self.backup_path)

    def removeTo(self):
        self.remove(self.to_path)

    def linkFromTo(self):
        abs_from_path = os.path.abspath(self.from_path)
        print "Link " + abs_from_path + " to " + self.to_path
        if not args.dry:
            os.symlink(abs_from_path, self.to_path)

    # high-level operations

    def checkAndBackup(self):
        if os.path.islink(self.to_path):
            self.removeTo()  # no backup necessary
        else:
            if os.path.exists(self.backup_path):
                self.removeBackup()
            self.backupUnchecked()

    def install(self):
        self.linkFromTo()

# Make path dictionary

def makeWorkUnits(lldb, swift, xcode):
    toolchain = xcode + "/Contents/Developer/Toolchains/XcodeDefault.xctoolchain"
    toolchain_usr_bin = toolchain + "/usr/bin"
    toolchain_usr_lib = toolchain + "/usr/lib"

    work_units = [
        WorkUnit(
            swift +
            "/bin/swift",
            toolchain_usr_bin +
            "/swift"),
        WorkUnit(
            swift +
            "/lib/swift",
            toolchain_usr_lib +
            "/swift"),
        WorkUnit(
            lldb +
            "/LLDB.framework",
            xcode +
            "/Contents/SharedFrameworks/LLDB.framework")]

    # if we've built sourcekitd, install that too

#  ## commented out because a built sourcekit doesn't work
#
#  if os.path.isdir(swift + "/lib/sourcekitd.framework"):
#    work_units.append(WorkUnit(swift + "/lib/sourcekitd.framework", toolchain_usr_lib + "/sourcekitd.framework"))

    return work_units

# Prepare Xcode installation, backing up data as necessary

def prepareAndBackup(work_units):
    for work_unit in work_units:
        work_unit.checkAndBackup()

# Install

def install(work_units):
    for work_unit in work_units:
        work_unit.install()

# Main

validated_paths = getPaths()

if not validated_paths:
    sys.exit(0)

(lldb, swift, xcode) = validated_paths

print "Installing LLDB from " + lldb + " and Swift from " + swift + " into Xcode at " + xcode

work_units = makeWorkUnits(lldb, swift, xcode)

prepareAndBackup(work_units)
install(work_units)


code:
#!/bin/bash

CERT="lldb_codesign"

function error() {
    echo error: "$@"
    exit 1
}

function cleanup {
    # Remove generated files
    rm -f "$TMPDIR/$CERT.tmpl" "$TMPDIR/$CERT.cer" "$TMPDIR/$CERT.key" > /dev/null 2>&1
}

trap cleanup EXIT

# Check if the certificate is already present in the system keychain
security find-certificate -Z -p -c "$CERT" /Library/Keychains/System.keychain > /dev/null 2>&1
if [ $? -eq 0 ]; then
    echo Certificate has already been generated and installed
    exit 0
fi

# Create the certificate template
cat <<EOF >$TMPDIR/$CERT.tmpl
[ req ]
default_bits       = 2048        # RSA key size
encrypt_key        = no          # Protect private key
default_md         = sha512      # MD to use
prompt             = no          # Prompt for DN
distinguished_name = codesign_dn # DN template
[ codesign_dn ]
commonName         = "$CERT"
[ codesign_reqext ]
keyUsage           = critical,digitalSignature
extendedKeyUsage   = critical,codeSigning
EOF

echo Generating and installing lldb_codesign certificate

# Generate a new certificate
openssl req -new -newkey rsa:2048 -x509 -days 3650 -nodes -config "$TMPDIR/$CERT.tmpl" -extensions codesign_reqext -batch -out "$TMPDIR/$CERT.cer" -keyout "$TMPDIR/$CERT.key" > /dev/null 2>&1
[ $? -eq 0 ] || error Something went wrong when generating the certificate

# Install the certificate in the system keychain
sudo security add-trusted-cert -d -r trustRoot -p codeSign -k /Library/Keychains/System.keychain "$TMPDIR/$CERT.cer" > /dev/null 2>&1
[ $? -eq 0 ] || error Something went wrong when installing the certificate

# Install the key for the certificate in the system keychain
sudo security import "$TMPDIR/$CERT.key" -A -k /Library/Keychains/System.keychain > /dev/null 2>&1
[ $? -eq 0 ] || error Something went wrong when installing the key

# Kill task_for_pid access control daemon
sudo pkill -f /usr/libexec/taskgated > /dev/null 2>&1

# Exit indicating the certificate is now generated and installed
exit 0


code:
#!/usr/bin/env python

"""
SWIG generation top-level script.  Supports both local and remote generation
of SWIG bindings for multiple languages.
"""

# Python modules
import argparse
import logging
import sys
import traceback

# LLDB modules
import use_lldb_suite

# swig_bot modules
from swig_bot_lib import client
from swig_bot_lib import server

def process_args(args):
    parser = argparse.ArgumentParser(
        description='Run swig-bot client or server.')

    # Create and populate subparser arguments for when swig_bot is
    # run in client or server mode
    subparsers = parser.add_subparsers(
        help="Pass --help to a sub-command to print detailed usage")
    client_parser = subparsers.add_parser("client",
                                          help="Run SWIG generation client")
    client.add_subparser_args(client_parser)
    client_parser.set_defaults(func=run_client)

    server_parser = subparsers.add_parser("server",
                                          help="Run SWIG generation server")
    server.add_subparser_args(server_parser)
    server_parser.set_defaults(func=run_server)

    # Arguments to control logging verbosity.
    parser.add_argument(
        "--verbose", "-v",
        action="store_true",
        default=False,
        help="Increase logging verbosity level.")

    options = parser.parse_args(args)
    # Set logging level.
    if options.verbose:
        log_level = logging.DEBUG
    else:
        log_level = logging.NOTSET
    logging.basicConfig(level=log_level)
    logging.info("logging is using level: %d", log_level)

    return options

def run_client(options):
    logging.info("Running swig_bot in client mode")
    client.finalize_subparser_options(options)
    client.run(options)

def run_server(options):
    logging.info("Running swig_bot in server mode")
    server.finalize_subparser_options(options)
    server.run(options)

if __name__ == "__main__":
    options = process_args(sys.argv[1:])
    try:
        if options.func is None:
            logging.error(
                "Unknown mode specified.  Expected client or server.")
            sys.exit(-1)
        else:
            options.func(options)
    except KeyboardInterrupt as e:
        logging.info("Ctrl+C received.  Shutting down...")
        sys.exit(-1)
    except Exception as e:
        error = traceback.format_exc()
        logging.error("An error occurred running swig-bot.")
        logging.error(error)


code:
""" Utility module to determine the OS Python running on

    --------------------------------------------------------------------------
    File:         utilsOsType.py

    Overview:       Python module to supply functions and an enumeration to
                    help determine the platform type, bit size and OS currently
                    being used.
    --------------------------------------------------------------------------

"""

# Python modules:
import sys      # Provide system information

# Third party modules:

# In-house modules:

# Instantiations:

# Enumerations:
#-----------------------------------------------------------------------------
# Details:  Class to implement a 'C' style enumeration type.
# Gotchas:  None.
# Authors:  Illya Rudkin 28/11/2013.
# Changes:  None.
#--
if sys.version_info.major >= 3:
    from enum import Enum

    class EnumOsType(Enum):
        Unknown = 0
        Darwin = 1
        FreeBSD = 2
        Linux = 3
        NetBSD = 4
        OpenBSD = 5
        Windows = 6
        kFreeBSD = 7
else:
    class EnumOsType(object):
        values = ["Unknown",
                  "Darwin",
                  "FreeBSD",
                  "Linux",
                  "NetBSD",
                  "OpenBSD",
                  "Windows",
                  "kFreeBSD"]

        class __metaclass__(type):
            #++----------------------------------------------------------------
            # Details:  Fn acts as an enumeration.
            # Args:     vName - (R) Enumeration to match.
            # Returns:  Int - Matching enumeration/index.
            # Throws:   None.
            #--

            def __getattr__(cls, vName):
                return cls.values.index(vName)

#++---------------------------------------------------------------------------
# Details:  Reverse fast lookup of the values list.
# Args:     vI - (R) Index / enumeration.
# Returns:  Str - text description matching enumeration.
# Throws:   None.
#--
            def name_of(cls, vI):
                return EnumOsType.values[vI]

#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------

#++---------------------------------------------------------------------------
# Details:  Determine what operating system is currently running on.
# Args:     None.
# Returns:  EnumOsType - The OS type being used ATM.
# Throws:   None.
#--

def determine_os_type():
    eOSType = EnumOsType.Unknown

    strOS = sys.platform
    if strOS == "darwin":
        eOSType = EnumOsType.Darwin
    elif strOS.startswith("freebsd"):
        eOSType = EnumOsType.FreeBSD
    elif strOS.startswith("linux"):
        eOSType = EnumOsType.Linux
    elif strOS.startswith("netbsd"):
        eOSType = EnumOsType.NetBSD
    elif strOS.startswith("openbsd"):
        eOSType = EnumOsType.OpenBSD
    elif strOS == "win32":
        eOSType = EnumOsType.Windows
    elif strOS.startswith("gnukfreebsd"):
        eOSType = EnumOsType.kFreeBSD

    return eOSType


code:
//===-- lldb.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/lldb-private.h"
#include "llvm/ADT/StringExtras.h"

using namespace lldb;
using namespace lldb_private;

#include "clang/Basic/Version.h"
#include "swift/Basic/Version.h"

#ifdef HAVE_VCS_VERSION_INC
#include "VCSVersion.inc"
#endif

static const char *GetLLDBRevision() {
#ifdef LLDB_REVISION
  return LLDB_REVISION;
#else
  return nullptr;
#endif
}

static const char *GetLLDBRepository() {
#ifdef LLDB_REPOSITORY
  return LLDB_REPOSITORY;
#else
  return NULL;
#endif
}

#if LLDB_IS_BUILDBOT_BUILD
static std::string GetBuildDate() {
#if defined(LLDB_BUILD_DATE)
  return std::string(LLDB_BUILD_DATE);
#else
  return std::string();
#endif
}
#endif

#define QUOTE(str) #str
#define EXPAND_AND_QUOTE(str) QUOTE(str)

const char *lldb_private::GetVersion() {
  // On platforms other than Darwin, report a version number in the same style
  // as the clang tool.
  static std::string g_version_str;
  if (g_version_str.empty()) {
    g_version_str += "lldb version ";
    g_version_str += CLANG_VERSION_STRING;

    const char *lldb_repo = GetLLDBRepository();
    const char *lldb_rev = GetLLDBRevision();
    if (lldb_repo || lldb_rev) {
      g_version_str += " (";
      if (lldb_repo)
        g_version_str += lldb_repo;
      if (lldb_rev) {
        g_version_str += " revision ";
        g_version_str += lldb_rev;
      }
      g_version_str += ")";
    }

#if LLDB_IS_BUILDBOT_BUILD
    std::string build_date = GetBuildDate();
    if(!build_date.empty())
      g_version_str += " (buildbot " + build_date + ")";
#endif

    auto const swift_version = swift::version::getSwiftFullVersion();
    g_version_str += "\n" + swift_version;

    // getSwiftFullVersion() also prints clang and llvm versions, no
    // need to print them again. We keep this code here to not diverge
    // too much from upstream.
#undef LLDB_UPSTREAM
#ifdef LLDB_UPSTREAM
    std::string clang_rev(clang::getClangRevision());
    if (clang_rev.length() > 0) {
      g_version_str += "\n  clang revision ";
      g_version_str += clang_rev;
    }
    std::string llvm_rev(clang::getLLVMRevision());
    if (llvm_rev.length() > 0) {
      g_version_str += "\n  llvm revision ";
      g_version_str += llvm_rev;
    }
#endif // LLDB_UPSTREAM
  }
  return g_version_str.c_str();
}