diff options
Diffstat (limited to 'scripts')
| -rwxr-xr-x | scripts/deplist | 179 | ||||
| -rwxr-xr-x | scripts/depsort | 3 | ||||
| -rwxr-xr-x | scripts/dotty | 19 | ||||
| -rwxr-xr-x | scripts/setup | 61 | ||||
| -rw-r--r-- | scripts/sgrep.c | 370 | ||||
| -rw-r--r-- | scripts/tsort.c | 491 |
6 files changed, 1123 insertions, 0 deletions
diff --git a/scripts/deplist b/scripts/deplist new file mode 100755 index 000000000..5eb51c95b --- /dev/null +++ b/scripts/deplist @@ -0,0 +1,179 @@ +#!/bin/sh -e + +## e.g. +# +# $ ./scripts/setup +# $ ./scripts/deplist system | ./scripts/depsort +# + +HERE="$(dirname $(readlink -f ${0}))"; +BASE="${HERE}/.."; + +## +# Usage +# +if test ${#} = 0; then + cat <<EOF +Usage: ${0} REPO [REPO ...] +EOF +fi + +## +# Sanity check. The specified repositories exist. +# +for repo in ${@}; do + if ! test -d "${BASE}/${repo}"; then + printf "E: '%s' is not a valid repository!\n" "${repo}" 1>&2; + exit 1; + fi +done + +## +# Find a package by name or find the parent package of a subpackage. +# Note that the index is padded by a space on either side for easy grep. +# +# Usage: parent PACKAGE +# +parent () +{ + a=$("${HERE}"/sgrep " ${1} " "${HERE}"/.index | cut -d' ' -f2 | xargs); + if test -n "${a}"; then + r=${a}; + else + b=$(grep " ${1} " "${HERE}"/.index | cut -d' ' -f2 | xargs); + r=${b}; + fi + printf "%s" "${r}"; +} + +## +# Do everything at once. +# +for repo in ${@}; do + find "${BASE}/${repo}" -mindepth 1 -maxdepth 1 -type d | while read k; do + ( + ## + # Source APKBUILD in a subshell to avoid contamination. + # + . "${k}/APKBUILD"; + + ## + # Special-case some options. For example, '!check' means + # that the 'checkdepends=' variable is not used. Ignore. + # + for m in ${options}; do + case ${m} in + !check) checkdepends=; ;; + esac + done + + ## + # Aggregate all possible depends. Obviously if something + # is not specified, it will be empty anyway. + # + # FIXME: Clean this up somehow. + # + cats=$(tr ' ' '\n' <<EOF | sort | uniq +${checkdepends} +${depends} +${depends_dev} +${makedepends} +${makedepends_build} +${makedepends_host} +${_core_depends} +EOF +); + + ## + # Construct canonical repository/package name. + # + p="${repo}/${k##*/}"; + + ## + # Column 1 output. + # + printf "%s " "${p}"; + test -z "${cats}" && printf "\n" && continue; # skip when empty; we are done + + for d in ${cats}; do + + ## + # Trim out most of the qualifiers. + # + _d=${d}; # formatting + + _d=${_d%=*}; # remove =version + _d=${_d%>*}; # remove >version + _d=${_d%<*}; # remove <version + _d=${_d%~*}; # remove ~version + + ## + # Handle cases where a dependency is provided by another package. + # + case "${_d}" in + !*) continue; ;; + + # override: system + /bin/sh) _d=dash; ;; + /sbin/init) _d=s6-linux-init; ;; + cmd:sendmail) _d=ssmtp; ;; + cmd:which) _d=debianutils; ;; + libc-utils) _d=musl; ;; + + # override: user (FIXME: incomplete) + cmd:byacc) _d=$(parent ${d#cmd:*}); ;; + cmd:cpio) _d=$(parent libarchive-tools); ;; + cmd:gzip) _d=$(parent ${d#cmd:*}); ;; + cmd:yacc) _d=bison; ;; + cmd:lex) _d=flex; ;; + cmd:mcookie) _d=$(parent ${d#cmd:*}); ;; + cmd:unix2dos) _d=dos2unix; ;; + cargo-*) _d=rust; ;; + guile-dev) _d=guile; ;; + llvm-dev) _d=$(parent llvm13-dev); ;; + llvm-static) _d=$(parent llvm13-static); ;; + llvm-test-*) _d=$(parent llvm13-test-utils); ;; + py3-libxml2) _d=$(parent py-libxml2); ;; + + # automatic search + *) _d=$(parent $_d); ;; + esac + + ## + # Determine relative path to dependency. It might be + # in the wrong repository, in which case must fix. + # + # TODO: Clean up to accommodate any number of repos + # and their policies. For example, 'kernel' if we do + # end up creating that someday. + # + case "${repo}" in + system) # nothing in system may depend on anything outside of system + if ! test -f "${BASE}/${repo}/${_d}/APKBUILD"; then + printf "E: dependency '%s' not found or excepted\n" "${_d}" 1>&2; + exit 1; + fi + path="${repo}/${_d}"; + ;; + user) # packages in user might depend on something in system + if ! test -f "${BASE}/${repo}/${_d}/APKBUILD"; then + if test -f "${BASE}/system/${_d}/APKBUILD"; then + path="system/${_d}"; + else + printf "E: dependency '%s' not found or excepted\n" "${_d}" 1>&2; + exit 1; + fi + else + path="${repo}/${_d}"; + fi + ;; + esac + + ## + # Print remaining columns of output if not parent. + # + printf " %s" "${path}"; + done | tr ' ' '\n' | sed -e "\@${p}\$@d" | sort -u | xargs; # sort and remove duplicates + ) + done | sort; # sort only within a repo +done diff --git a/scripts/depsort b/scripts/depsort new file mode 100755 index 000000000..953260238 --- /dev/null +++ b/scripts/depsort @@ -0,0 +1,3 @@ +#!/bin/sh -e + +awk '{ for (f=1;f<=NF;f++) { print $(f),$1 } }' | "$(dirname $(readlink -f ${0}))"/tsort diff --git a/scripts/dotty b/scripts/dotty new file mode 100755 index 000000000..45bbd8d1d --- /dev/null +++ b/scripts/dotty @@ -0,0 +1,19 @@ +#!/bin/sh -e + +## +# CLOSE THIS FILE! DO NOT LOOK BELOW! +# + + +# ./scripts/deplist system | ./scripts/dotty + +printf "digraph G {\n"; +while read k; do + a=$(printf "%s " "${k}" | cut -d' ' -f1); + printf " \"%s\n" "${a}"; + for b in $(seq 2 $(_() { printf "%s" "${#}"; }; _ ${k})); do + printf " \"%s\" -> \"" "${a}"; + printf "%s " "${k}" | cut -d' ' -f${b}; + done +done | sed -e 's/$/";/g' +printf "}\n"; diff --git a/scripts/setup b/scripts/setup new file mode 100755 index 000000000..5577c7244 --- /dev/null +++ b/scripts/setup @@ -0,0 +1,61 @@ +#!/bin/sh -e + +## +# This script prepares the 'packages.git' repository for use by +# the included scripts. It is not needed to build packages, but +# is useful for maintainers. The 'autobuilder' does require it. +# +# Re-run any time you pull from upstream or switch branches. +# + +HERE="$(dirname $(readlink -f ${0}))"; +BASE="${HERE}/.."; + +## +# Compile 'tsort' utility. Used to compute topological sort for +# building the world. Assumes GCC, yes, easy enough to change. +# +gcc -o "${HERE}"/tsort "${HERE}"/tsort.c -O3; + +## +# Compile 'sgrep' utility. Used to traverse the index generated +# below. +# +gcc -o "${HERE}"/sgrep "${HERE}"/sgrep.c -O3; + +## +# Build subpackage index. Used for resolving dependencies when +# a subpackage is used instead of its parent. +# +# MAINTAINERS: If repos renamed/added/removed, must update below. +# +for repo in system user legacy; do + find "${BASE}/${repo}" -mindepth 1 -maxdepth 1 -type d | sort | while read k; do + ( + ## + # Source APKBUILD in a subshell to avoid contamination. + # + . "${k}/APKBUILD"; + + ## + # Print the package name, whether it has subdeps or not. + # + printf " %s " "${k##*/}"; + + ## + # Trim non-name bits from any declared subpackage(s). + # + for s in ${subpackages} ${provides} ${pkgname}; do + case ${s} in + *::*) t=${s%%:*}; ;; + *:*) t=${s%%:*}; ;; + *=*) t=${s%%=*}; ;; + *) t=${s}; ;; + esac + printf " %s" "${t}"; + done | tr ' ' '\n' | sort | uniq | xargs | sed -e 's/$/ /'; + ) + done +#done | awk -v X=1 'NF>X' +# (uncomment this ^ to exclude packages with no subpackages +done > "${HERE}"/.index diff --git a/scripts/sgrep.c b/scripts/sgrep.c new file mode 100644 index 000000000..d4f7d4544 --- /dev/null +++ b/scripts/sgrep.c @@ -0,0 +1,370 @@ +/* + * sgrep version 1.0 + * + * Copyright 2009 Stephen C. Losen. Distributed under the terms + * of the GNU General Public License (GPL) + * + * Sgrep (sorted grep) is a much faster alternative to traditional Unix + * grep, but with significant restrictions. 1) All input files must + * be sorted regular files. 2) The sort key must start at the beginning + * of the line. 3) The search key matches only at the beginning of + * the line. 4) No regular expression support. + * + * Sgrep uses a binary search algorithm, which is very fast, but + * requires sorted input. Each iteration of the search eliminates + * half of the remaining input. In other words, doubling the size + * of the file adds just one iteration. + * + * Sgrep seeks to the center of the file and then reads characters + * until it encounters a newline, which places the file pointer at + * the start of the next line. Sgrep compares the search key with the + * beginning of the line. If the key is greater than the line, then + * the process repeats with the second half of the file. If less than, + * then the process repeats with the first half of the file. If equal, + * then the line matches, but it may not be the earliest match, so the + * process repeats with the first half of the file. Eventually all + * of the input is eliminated and sgrep finds either no matching line + * or the first matching line. Sgrep outputs matching lines until it + * encounters a non matching line. + * + * Usage: sgrep [ -i | -n ] [ -c ] [ -b ] [ -r ] key [ sorted_file ... ] + * + * If no input file is specified, then sgrep uses stdin. + * + * The -i flag uses case insensitive byte comparison. The file must + * be sorted with "sort -f". + * + * The -n flag uses numeric comparison. The file must be sorted + * with "sort -n". + * + * The -b flag causes sgrep to ignore white space at the beginning + * of lines and at the beginning of the search key. The file must + * be sorted with "sort -b" + * + * The -c flag outputs the number of matching lines instead of the + * lines themselves. + * + * The -r flag specifies that the file is sorted in reverse + * (descending) order using "sort -r". + * + * Author: Stephen C. Losen University of Virginia + */ + +/* large file support */ + +#ifdef _AIX +#define _LARGE_FILES +#else +#define _FILE_OFFSET_BITS 64 +#endif + +#include <sys/stat.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <ctype.h> +#include <stdio.h> + +/* We need different comparison functions for different sort orderings */ + +/* exact comparison */ + +static int +cmp_exact(const char *key, FILE *fp) { + const unsigned char *k = (unsigned char *) key; + int c; + + while (*k != 0 && (c = getc(fp)) == *k) { + k++; + } + return + *k == 0 ? 0 : + c == '\n' ? 1 : + c == EOF ? -1 : *k - c; +} + +/* case insensitive comparison */ + +static int +cmp_case(const char *key, FILE *fp) { + const unsigned char *k = (unsigned char *) key; + int c; + + while (*k != 0 && tolower(c = getc(fp)) == tolower(*k)) { + k++; + } + return + *k == 0 ? 0 : + c == '\n' ? 1 : + c == EOF ? -1 : + tolower(*k) - tolower(c); +} + +/* exact comparison ignoring leading white space */ + +static int +cmp_exact_white(const char *key, FILE *fp) { + const unsigned char *k = (unsigned char *) key; + int c; + + while (isspace(*k)) { + k++; + } + while ((c = getc(fp)) != '\n' && isspace(c)) + ; + while (*k != 0 && c == *k) { + k++; + c = getc(fp); + } + return + *k == 0 ? 0 : + c == '\n' ? 1 : + c == EOF ? -1 : *k - c; +} + +/* case insensitive comparison ignoring leading white space */ + +static int +cmp_case_white(const char *key, FILE *fp) { + const unsigned char *k = (unsigned char *) key; + int c; + + while (isspace(*k)) { + k++; + } + while ((c = getc(fp)) != '\n' && isspace(c)) + ; + while (*k != 0 && tolower(c) == tolower(*k)) { + k++; + c = getc(fp); + } + return + *k == 0 ? 0 : + c == '\n' ? 1 : + c == EOF ? -1 : + tolower(*k) - tolower(c); +} + +/* numeric comparison */ + +static int +cmp_num(const char *key, FILE *fp) { + int c, i = 0; + char buf[128], *cp = 0; + double low, high, x; + + /* read numeric string into buf */ + + while((c = getc(fp)) != '\n' && c != EOF) { + if (i == 0 && isspace(c)) { + continue; + } + if (i + 1 >= sizeof(buf) || + (c != '-' && c != '.' && !isdigit(c))) + { + break; + } + buf[i++] = c; + } + buf[i] = 0; + if (c == EOF && i == 0) { + return -1; + } + + /* convert to double and use numeric comparison */ + + x = strtod(buf, 0); + low = high = strtod(key, &cp); + if (*cp == ':') { + high = strtod(cp + 1, 0); + } + return + high < x ? -1 : + low > x ? 1 : 0; +} + +static int (*compare)(const char *key, FILE *fp); + +/* + * Use binary search to find the first matching line and return + * its byte position. + */ + +static off_t +binsrch(const char *key, FILE *fp, int reverse) { + off_t low, med, high, start, prev = -1, ret = -1; + int cmp, c; + struct stat st; + + fstat(fileno(fp), &st); + high = st.st_size - 1; + low = 0; + while (low <= high) { + med = (high + low) / 2; + fseeko(fp, med, SEEK_SET); + + /* scan to start of next line if not at beginning of file */ + + if ((start = med) != 0) { + do { + start++; + } while ((c = getc(fp)) != '\n' && c != EOF); + } + + /* compare key with current line */ + + if (start != prev) { /* avoid unnecessary compares */ + cmp = compare(key, fp); + if (reverse != 0) { + cmp = -cmp; + } + prev = start; + } + + /* eliminate half of input */ + + if (cmp < 0) { + high = med - 1; + } + else if (cmp > 0) { + low = start + 1; + } + else { /* success, look for earlier match */ + ret = start; + high = med - 1; + } + } + return ret; +} + +/* print all lines that match the key or else just the number of matches */ + +static void +printmatch(const char *key, FILE *fp, off_t start, + const char *fname, int cflag) +{ + int c, count; + + if (start >= 0) { + fseeko(fp, start, SEEK_SET); + } + for (count = 0; start >= 0 && compare(key, fp) == 0; count++) { + fseeko(fp, start, SEEK_SET); + if (cflag == 0 && fname != 0) { + fputs(fname, stdout); + fputc(':', stdout); + } + while ((c = getc(fp)) != EOF) { + start++; + if (cflag == 0) { + fputc(c, stdout); + } + if (c == '\n') { + break; + } + } + if (c == EOF) { + break; + } + } + if (cflag != 0) { + if (fname != 0) { + fputs(fname, stdout); + fputc(':', stdout); + } + printf("%d\n", count); + } +} + +int +main(int argc, char **argv) { + FILE *fp; + const char *key = 0; + int i, numfile, status; + int bflag = 0, cflag = 0, iflag = 0, nflag = 0, rflag = 0; + off_t where; + struct stat st; + extern int optind, opterr; + + /* parse command line options */ + + opterr = 0; + while ((i = getopt(argc, argv, "bcfinr")) > 0 && i != '?') { + switch(i) { + case 'b': + bflag++; + break; + case 'c': + cflag++; + break; + case 'f': + case 'i': + iflag++; + nflag = 0; + break; + case 'n': + nflag++; + iflag = 0; + break; + case 'r': + rflag++; + break; + } + } + if (i == '?' || optind >= argc) { + fputs ("Usage: sgrep [ -i | -n ] [ -c ] [ -b ] [ -r ] key " + "[ sorted_file ... ]\n", stderr); + exit(2); + } + i = optind; + key = argv[i++]; + + /* select the comparison function */ + + if (iflag != 0) { + compare = bflag == 0 ? cmp_case : cmp_case_white; + } + else if (nflag != 0) { + compare = cmp_num; + } + else { + compare = bflag == 0 ? cmp_exact : cmp_exact_white; + } + + /* if no input files, then search stdin */ + + if ((numfile = argc - i) == 0) { + fstat(fileno(stdin), &st); + if ((st.st_mode & S_IFREG) == 0) { + fputs("sgrep: STDIN is not a regular file\n", stderr); + exit(2); + } + where = binsrch(key, stdin, rflag); + printmatch(key, stdin, where, 0, cflag); + exit(where < 0); + } + + /* search each input file */ + + for (status = 1; i < argc; i++) { + if ((fp = fopen(argv[i], "r")) == 0) { + fprintf(stderr, "sgrep: could not open %s\n", argv[i]); + status = 2; + continue; + } + fstat(fileno(fp), &st); + if ((st.st_mode & S_IFREG) == 0) { + fprintf(stderr, "sgrep: %s is not a regular file\n", argv[i]); + status = 2; + fclose(fp); + continue; + } + where = binsrch(key, fp, rflag); + printmatch(key, fp, where, numfile == 1 ? 0 : argv[i], cflag); + if (status == 1 && where >= 0) { + status = 0; + } + fclose(fp); + } + exit(status); +} diff --git a/scripts/tsort.c b/scripts/tsort.c new file mode 100644 index 000000000..e307268da --- /dev/null +++ b/scripts/tsort.c @@ -0,0 +1,491 @@ +/*- + * SPDX-License-Identifier: BSD-3-Clause + * + * Copyright (c) 1989, 1993, 1994 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Michael Rendell of Memorial University of Newfoundland. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef lint +static const char copyright[] = +"@(#) Copyright (c) 1989, 1993, 1994\n\ + The Regents of the University of California. All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static const char sccsid[] = "@(#)tsort.c 8.3 (Berkeley) 5/4/95"; +#endif /* not lint */ + +#include <sys/cdefs.h> + +#include <sys/types.h> + +#include <ctype.h> +#include <err.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +/* + * Topological sort. Input is a list of pairs of strings separated by + * white space (spaces, tabs, and/or newlines); strings are written to + * standard output in sorted order, one per line. + * + * usage: + * tsort [-dlq] [inputfile] + * If no input file is specified, standard input is read. + * + * Should be compatible with AT&T tsort HOWEVER the output is not identical + * (i.e. for most graphs there is more than one sorted order, and this tsort + * usually generates a different one then the AT&T tsort). Also, cycle + * reporting seems to be more accurate in this version (the AT&T tsort + * sometimes says a node is in a cycle when it isn't). + * + * Michael Rendell, michael@stretch.cs.mun.ca - Feb 26, '90 + */ + +#define NF_MARK 0x1 /* marker for cycle detection */ +#define NF_ACYCLIC 0x2 /* this node is cycle free */ +#define NF_NODEST 0x4 /* Unreachable */ + + +typedef struct node_str NODE; + +struct node_str { + NODE **n_prevp; /* pointer to previous node's n_next */ + NODE *n_next; /* next node in graph */ + NODE **n_arcs; /* array of arcs to other nodes */ + int n_narcs; /* number of arcs in n_arcs[] */ + int n_arcsize; /* size of n_arcs[] array */ + int n_refcnt; /* # of arcs pointing to this node */ + int n_flags; /* NF_* */ + char n_name[1]; /* name of this node */ +}; + +typedef struct _buf { + char *b_buf; + int b_bsize; +} BUF; + +#define HASH_CHUNK_SIZE 64 +#define HASH_BUCKET_COUNT 1024 + +struct hash_elem { + NODE *elem; + struct hash_elem *next; +}; + +struct hash_chunk { + struct hash_elem elems[HASH_CHUNK_SIZE]; + struct hash_chunk *next; +}; + +struct hash { + struct hash_elem **elems; + struct hash_chunk *chunks; + struct hash_elem *top; +}; + +static void hash_init(struct hash *h) { + h->chunks = NULL; + h->top = NULL; + h->elems = calloc(1024, sizeof(struct hash_elem *)); +} + +static void hash_destroy(struct hash *h) { + for (size_t i = 0; i < HASH_BUCKET_COUNT; ++i) { + struct hash_elem *e = h->elems[i]; + while (e) { + free(e->elem->n_arcs); + free(e->elem); + e = e->next; + } + } + free(h->elems); + while (h->chunks) { + struct hash_chunk *c = h->chunks; + h->chunks = h->chunks->next; + free(c); + } +} + +static size_t hash_key(char *key) { + size_t h = 5381; + for (size_t i = 0, k; (k = key[i]); ++i) + h = ((h << 5) + h) ^ k; + return h; +} + +static NODE *hash_find(struct hash *h, char *key) { + size_t hash = hash_key(key) & (HASH_BUCKET_COUNT - 1); + for (struct hash_elem *c = h->elems[hash]; c; c = c->next) { + if (!strcmp(key, c->elem->n_name)) + return c->elem; + } + return NULL; +} + +static struct hash_elem *hash_insert(struct hash *h, char *key) { + size_t hash = hash_key(key) & (HASH_BUCKET_COUNT - 1); + if (!h->top) { + struct hash_chunk *c = calloc(1, sizeof(struct hash_chunk)); + c->next = h->chunks; + h->chunks = c; + for (size_t i = 0; i < (HASH_CHUNK_SIZE - 1); ++i) + c->elems[i].next = &c->elems[i + 1]; + c->elems[HASH_CHUNK_SIZE - 1].next = h->top; + h->top = c->elems; + } + struct hash_elem *hc = h->top; + h->top = h->top->next; + hc->next = h->elems[hash]; + h->elems[hash] = hc; + return hc; +} + +static struct hash db; +static NODE *graph, **cycle_buf, **longest_cycle; +static int debug, longest, quiet; + +static void add_arc(char *, char *); +static int find_cycle(NODE *, NODE *, int, int); +static NODE *get_node(char *); +static void *grow_buf(void *, size_t); +static void remove_node(NODE *); +static void clear_cycle(void); +static void tsort(void); +static void usage(void); + +int +main(int argc, char *argv[]) +{ + BUF *b; + int c, n; + FILE *fp; + int bsize, ch, nused; + BUF bufs[2]; + + fp = NULL; + while ((ch = getopt(argc, argv, "dlq")) != -1) + switch (ch) { + case 'd': + debug = 1; + break; + case 'l': + longest = 1; + break; + case 'q': + quiet = 1; + break; + case '?': + default: + usage(); + } + argc -= optind; + argv += optind; + + switch (argc) { + case 0: + fp = stdin; + break; + case 1: + if ((fp = fopen(*argv, "r")) == NULL) + err(1, "%s", *argv); + break; + default: + usage(); + } + + for (b = bufs, n = 2; --n >= 0; b++) + b->b_buf = grow_buf(NULL, b->b_bsize = 1024); + + hash_init(&db); + + /* parse input and build the graph */ + for (n = 0, c = getc(fp);;) { + while (c != EOF && isspace(c)) + c = getc(fp); + if (c == EOF) + break; + + nused = 0; + b = &bufs[n]; + bsize = b->b_bsize; + do { + b->b_buf[nused++] = c; + if (nused == bsize) + b->b_buf = grow_buf(b->b_buf, bsize *= 2); + c = getc(fp); + } while (c != EOF && !isspace(c)); + + b->b_buf[nused] = '\0'; + b->b_bsize = bsize; + if (n) + add_arc(bufs[0].b_buf, bufs[1].b_buf); + n = !n; + } + (void)fclose(fp); + if (n) + errx(1, "odd data count"); + + /* do the sort */ + tsort(); + hash_destroy(&db); + exit(0); +} + +/* double the size of oldbuf and return a pointer to the new buffer. */ +static void * +grow_buf(void *bp, size_t size) +{ + if ((bp = realloc(bp, size)) == NULL) + err(1, NULL); + return (bp); +} + +/* + * add an arc from node s1 to node s2 in the graph. If s1 or s2 are not in + * the graph, then add them. + */ +static void +add_arc(char *s1, char *s2) +{ + NODE *n1; + NODE *n2; + int bsize, i; + + n1 = get_node(s1); + + if (!strcmp(s1, s2)) + return; + + n2 = get_node(s2); + + /* + * Check if this arc is already here. + */ + for (i = 0; i < n1->n_narcs; i++) + if (n1->n_arcs[i] == n2) + return; + /* + * Add it. + */ + if (n1->n_narcs == n1->n_arcsize) { + if (!n1->n_arcsize) + n1->n_arcsize = 10; + bsize = n1->n_arcsize * sizeof(*n1->n_arcs) * 2; + n1->n_arcs = grow_buf(n1->n_arcs, bsize); + n1->n_arcsize = bsize / sizeof(*n1->n_arcs); + } + n1->n_arcs[n1->n_narcs++] = n2; + ++n2->n_refcnt; +} + +/* Find a node in the graph (insert if not found) and return a pointer to it. */ +static NODE * +get_node(char *name) +{ + NODE *n = hash_find(&db, name); + size_t nlen; + + if (n) + return n; + + nlen = strlen(name) + 1; + + if ((n = malloc(sizeof(NODE) + nlen)) == NULL) + err(1, NULL); + + n->n_narcs = 0; + n->n_arcsize = 0; + n->n_arcs = NULL; + n->n_refcnt = 0; + n->n_flags = 0; + bcopy(name, n->n_name, nlen); + + /* Add to linked list. */ + if ((n->n_next = graph) != NULL) + graph->n_prevp = &n->n_next; + n->n_prevp = &graph; + graph = n; + + /* Add to hash table. */ + hash_insert(&db, name)->elem = n; + return (n); +} + + +/* + * Clear the NODEST flag from all nodes. + */ +static void +clear_cycle(void) +{ + NODE *n; + + for (n = graph; n != NULL; n = n->n_next) + n->n_flags &= ~NF_NODEST; +} + +/* do topological sort on graph */ +static void +tsort(void) +{ + NODE *n, *next; + int cnt, i; + + while (graph != NULL) { + /* + * Keep getting rid of simple cases until there are none left, + * if there are any nodes still in the graph, then there is + * a cycle in it. + */ + do { + for (cnt = 0, n = graph; n != NULL; n = next) { + next = n->n_next; + if (n->n_refcnt == 0) { + remove_node(n); + ++cnt; + } + } + } while (graph != NULL && cnt); + + if (graph == NULL) + break; + + if (!cycle_buf) { + /* + * Allocate space for two cycle logs - one to be used + * as scratch space, the other to save the longest + * cycle. + */ + for (cnt = 0, n = graph; n != NULL; n = n->n_next) + ++cnt; + cycle_buf = malloc(sizeof(NODE *) * cnt); + longest_cycle = malloc(sizeof(NODE *) * cnt); + if (cycle_buf == NULL || longest_cycle == NULL) + err(1, NULL); + } + for (n = graph; n != NULL; n = n->n_next) + if (!(n->n_flags & NF_ACYCLIC)) { + if ((cnt = find_cycle(n, n, 0, 0))) { + if (!quiet) { + warnx("cycle in data"); + for (i = 0; i < cnt; i++) + warnx("%s", + longest_cycle[i]->n_name); + } + remove_node(n); + clear_cycle(); + break; + } else { + /* to avoid further checks */ + n->n_flags |= NF_ACYCLIC; + clear_cycle(); + } + } + + if (n == NULL) + errx(1, "internal error -- could not find cycle"); + } +} + +/* print node and remove from graph (does not actually free node) */ +static void +remove_node(NODE *n) +{ + NODE **np; + int i; + + (void)printf("%s\n", n->n_name); + for (np = n->n_arcs, i = n->n_narcs; --i >= 0; np++) + --(*np)->n_refcnt; + n->n_narcs = 0; + *n->n_prevp = n->n_next; + if (n->n_next) + n->n_next->n_prevp = n->n_prevp; +} + + +/* look for the longest? cycle from node from to node to. */ +static int +find_cycle(NODE *from, NODE *to, int longest_len, int depth) +{ + NODE **np; + int i, len; + + /* + * avoid infinite loops and ignore portions of the graph known + * to be acyclic + */ + if (from->n_flags & (NF_NODEST|NF_MARK|NF_ACYCLIC)) + return (0); + from->n_flags |= NF_MARK; + + for (np = from->n_arcs, i = from->n_narcs; --i >= 0; np++) { + cycle_buf[depth] = *np; + if (*np == to) { + if (depth + 1 > longest_len) { + longest_len = depth + 1; + (void)memcpy((char *)longest_cycle, + (char *)cycle_buf, + longest_len * sizeof(NODE *)); + } + } else { + if ((*np)->n_flags & (NF_MARK|NF_ACYCLIC|NF_NODEST)) + continue; + len = find_cycle(*np, to, longest_len, depth + 1); + + if (debug) + (void)printf("%*s %s->%s %d\n", depth, "", + from->n_name, to->n_name, len); + + if (len == 0) + (*np)->n_flags |= NF_NODEST; + + if (len > longest_len) + longest_len = len; + + if (len > 0 && !longest) + break; + } + } + from->n_flags &= ~NF_MARK; + return (longest_len); +} + +static void +usage(void) +{ + (void)fprintf(stderr, "usage: tsort [-dlq] [file]\n"); + exit(1); +} |