Datasets:
repo_name
stringclasses 2
values | file_path
stringlengths 14
31
| language
stringclasses 3
values | quality_score
int64 80
95
| num_tokens
int64 179
2.36k
| num_lines
int64 22
283
| license
stringclasses 2
values | date_scraped
stringlengths 27
27
| last_modified
stringclasses 9
values | code
stringlengths 415
7.35k
|
|---|---|---|---|---|---|---|---|---|---|
apple/cups | test/5.3-lpq.sh | Shell | 80 | 179 | 22 | Apache-2.0 | 2025-02-25T00:20:28.878501Z | 2018-10-02T22:21:25+00:00Z | #!/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 ""
|
apple/cups | test/5.1-lpadmin.sh | Shell | 80 | 630 | 63 | Apache-2.0 | 2025-02-25T00:20:51.660213Z | 2018-10-02T22:21:25+00:00Z | #!/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 ""
|
apple/cups | test/5.4-lpstat.sh | Shell | 80 | 415 | 49 | Apache-2.0 | 2025-02-25T00:20:52.642297Z | 2019-04-26T21:40:54+00:00Z | #!/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 ""
|
apple/cups | test/5.8-cancel.sh | Shell | 80 | 408 | 48 | Apache-2.0 | 2025-02-25T00:20:58.086178Z | 2019-04-26T21:40:54+00:00Z | #!/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 ""
|
apple/cups | test/5.9-lpinfo.sh | Shell | 80 | 370 | 46 | Apache-2.0 | 2025-02-25T00:20:59.067376Z | 2019-04-26T21:40:54+00:00Z | #!/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 ""
|
apple/swift-lldb | scripts/analyze-project-deps.py | Python | 80 | 2,361 | 208 | NOASSERTION | 2025-02-25T00:32:28.338543Z | 2019-03-21T07:19:09+00:00Z | #! /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
|
apple/swift-lldb | lit/lit.cfg.py | Python | 80 | 1,156 | 106 | NOASSERTION | 2025-02-25T00:32:30.631002Z | 2019-09-18T19:20:58+00:00Z | # -*- 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')
|
apple/swift-lldb | scripts/install-lldb-swift.py | Python | 95 | 2,280 | 283 | NOASSERTION | 2025-02-25T00:34:35.867688Z | 2016-12-02T09:32:43+00:00Z | #!/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)
|
apple/swift-lldb | scripts/macos-setup-codesign.sh | Shell | 80 | 666 | 57 | NOASSERTION | 2025-02-25T00:34:37.834753Z | 2018-06-14T18:04:13+00:00Z | #!/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
|
apple/swift-lldb | scripts/swig_bot.py | Python | 80 | 714 | 85 | NOASSERTION | 2025-02-25T00:35:03.526736Z | 2016-09-06T20:57:50+00:00Z | #!/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)
|
apple/swift-lldb | scripts/utilsOsType.py | Python | 80 | 866 | 103 | NOASSERTION | 2025-02-25T00:35:13.281154Z | 2018-10-04T20:34:58+00:00Z | """ 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
|
apple/swift-lldb | source/lldb.cpp | C++ | 90 | 972 | 99 | NOASSERTION | 2025-02-25T00:35:18.326737Z | 2019-04-17T18:39:30+00:00Z | //===-- 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();
}
|
FineCode: A High-Quality Code Dataset
Disclaimer: No big files uploaded...yet The one upload is simply an example format and doesn't contain all the highest quality code or the final version.
Overview
FineCode is a meticulously curated dataset aimed at providing high-quality code for training and benchmarking code generation models. While many code datasets exist on Hugging Face, the quality of code varies significantly. FineCode seeks to address this by rigorously filtering and scoring code to ensure only well-structured, optimized, and readable examples are included.
Dataset Details
- Total Size: 100B tokens
- Languages Covered: Top 15 programming languages, with an emphasis on the top 5
- Source: Scraped from top-ranked GitHub repositories of well-known organizations and highly rated open-source projects
- Filtering Criteria:
- Code is evaluated using Llama3.2-3B, which assigns a quality score (0-100) based on factors like readability, optimization, and best practices
- Only code with a score of 75 or higher is included in the dataset
- Additional filtering techniques are applied to remove low-quality or redundant content
Availability
The dataset will be released soon on Hugging Face, along with the code used for data collection and filtering, allowing full transparency and reproducibility.
Stay tuned for updates!
- Downloads last month
- 60