aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorCem Keylan <cem@ckyln.com>2021-04-15 10:51:15 +0300
committerCem Keylan <cem@ckyln.com>2021-04-15 10:51:41 +0300
commitc8b701c2f509d3bcad10f69cb662de2e2517f884 (patch)
treef61b27061ce58423d6eea7b6541fcc6ef9cfe358
parentaab5cc17af437489b72a605919bd8038d0db6663 (diff)
downloaddocs-c8b701c2f509d3bcad10f69cb662de2e2517f884.tar.gz
Remove redo files
-rw-r--r--clean.do7
-rw-r--r--config.rc19
-rw-r--r--default.do73
-rw-r--r--install.html.do23
-rw-r--r--install.txt.do13
-rw-r--r--lib.rc84
-rwxr-xr-xtools/do446
7 files changed, 0 insertions, 665 deletions
diff --git a/clean.do b/clean.do
deleted file mode 100644
index d71b034..0000000
--- a/clean.do
+++ /dev/null
@@ -1,7 +0,0 @@
-. ./config.rc
-
-rm -f carbslinux.info carbslinux.html
-rm -rf carbslinux
-rm -f -- ./*.tar.*
-redo_clean
-PHONY
diff --git a/config.rc b/config.rc
deleted file mode 100644
index 3cba001..0000000
--- a/config.rc
+++ /dev/null
@@ -1,19 +0,0 @@
-# -*- mode: redo; -*-
-# Source the helper library
-. ./lib.rc
-
-setv PREFIX = /usr/local
-setv SHAREDIR = ${PREFIX}/share
-setv INFODIR = ${SHAREDIR}/info
-setv DOCDIR = ${SHAREDIR}/doc
-setv TARBALL = "carbs-docs-$(date +%Y%m%d)"
-setv HTMLDIR = ./carbslinux
-setv ORG = carbslinux.org
-setv TEXI = carbslinux.texi
-
-setv EMACS = emacs --batch
-setv MAKEINFO = makeinfo
-
-setv INSTALLSH = ./tools/install.sh
-
-PHONY all dist htmldocs install clean
diff --git a/default.do b/default.do
deleted file mode 100644
index e72e62c..0000000
--- a/default.do
+++ /dev/null
@@ -1,73 +0,0 @@
-exec >&2
-. ./config.rc
-
-fn=${1%.*}
-
-date=$(date +%Y%m%d)
-export date
-
-case "$1" in
- *.txt|*.texi)
- [ -f "$fn.org" ] || {
- printf '%s\n' "Don't know how to build $1"
- exit 1
- }
- redo-ifchange "$fn.org" fdl.org
- trap 'rm -f $3.org' EXIT INT
- cp "$fn.org" "$3.org"
-esac
-
-case "$1" in
- all) redo-ifchange carbslinux.info install.txt carbslinux.txt ;;
- allclean)
- rm -f carbslinux.texi install.txt carbslinux.txt
- redo clean
- PHONY
- ;;
- htmldocs)
- redo-ifchange carbslinux.org carbslinux.texi install.txt install.html
- mkdir -p "${HTMLDIR:?}"
- rm -rf "$HTMLDIR/carbslinux" \
- "$HTMLDIR/carbslinux.html" \
- "$HTMLDIR/install.html.in" \
- "$HTMLDIR/install.txt"
- makeinfo --html -o "$HTMLDIR/carbslinux" "$TEXI"
- makeinfo --html --no-split -o "$HTMLDIR/carbslinux.html" "$TEXI"
- cp install.txt "$HTMLDIR/install.txt"
- cp install.html "$HTMLDIR/install.html.in"
- PHONY
- ;;
- *.txt)
- ${EMACS} "$3.org" -f org-ascii-export-to-ascii
- mv "$3.txt" "$3"
- ;;
- *.texi)
- ${EMACS} "$3.org" -f org-texinfo-export-to-texinfo
- mv "$3.texi" "$3"
- ;;
- *.info)
- redo-ifchange "$fn.texi"
- ${MAKEINFO} "$fn.texi" -o "$3"
- ;;
- "carbs-docs-$date.tar.xz")
- target=$1 dest=$3
- set -- README.md ./*.do ./*.org config.rc lib.rc carbslinux.info \
- install.txt carbslinux.txt
- redo-ifchange "$@"
- trap 'rm -rf carbs-docs-$date carbs-docs-$date.tar' EXIT INT
- mkdir -p "carbs-docs-$date"
- cp README.md ./*.do ./*.org config.rc lib.rc \
- carbslinux.info install.txt carbslinux.txt "carbs-docs-$date"
- tar cf "carbs-docs-$date.tar" "carbs-docs-$date"
- xz -cz "carbs-docs-$date.tar" > "$dest"
- ;;
- install)
- redo-ifchange carbslinux.info carbslinux.txt
- "$INSTALLSH" -Dm644 carbslinux.info "${DESTDIR}${INFODIR}/carbslinux.info"
- "$INSTALLSH" -Dm644 carbslinux.txt "${DESTDIR}${DOCDIR}/carbslinux.txt"
- ;;
- dist)
- redo-ifchange "carbs-docs-$date.tar.xz"
- ;;
- *) printf '%s\n' "Unknown operation $1"; exit 1
-esac
diff --git a/install.html.do b/install.html.do
deleted file mode 100644
index 838e3d6..0000000
--- a/install.html.do
+++ /dev/null
@@ -1,23 +0,0 @@
-exec >&2
-. ./config.rc
-redo-ifchange "$ORG" htmlize/htmlize.el flatui/flatui-theme.el
-
-cp "$ORG" "$3.org"
-trap 'rm -f $3.html $3.org' EXIT INT
-
-# Org HTML export is a bit of a mess from the command line. I have added flatui
-# and htmlize repositories as a submodule so that we don't rely on packages.
-${EMACS} "$3.org" --eval \
-'(progn
-(load-file "flatui/flatui-theme.el")
-(add-to-list '"'"'custom-theme-load-path (concat default-directory "flatui/"))
-(load-theme '"'"'flatui t)
-(load-file "htmlize/htmlize.el") (org-mode)
-(replace-regexp "^* Installation" "* Carbs Linux Installation Guide")
-(setq org-export-with-toc nil)
-(org-html-export-to-html nil t nil t)
-(revert-buffer nil t)
-)'
-
-printf '%s\n' "<h1>Carbs Linux Installation Guide</h1>" > "$3"
-cat "$3.html" >> "$3"
diff --git a/install.txt.do b/install.txt.do
deleted file mode 100644
index bb6f727..0000000
--- a/install.txt.do
+++ /dev/null
@@ -1,13 +0,0 @@
-exec >&2
-. ./config.rc
-redo-ifchange "$ORG"
-
-cp "$ORG" "$3.org"
-trap 'rm -f $3.org' EXIT INT
-
-${EMACS} "$3.org" --eval \
- '(progn (replace-regexp "^* Installation" "* Carbs Linux Installation Guide")
- (setq org-export-with-toc nil)
- (org-ascii-export-to-ascii nil t))'
-
-mv "$3.txt" "$3"
diff --git a/lib.rc b/lib.rc
deleted file mode 100644
index 3c713e2..0000000
--- a/lib.rc
+++ /dev/null
@@ -1,84 +0,0 @@
-# Various helper functions for redo
-# URL: https://github.com/cemkeylan/redo-lib
-# LICENSE: CC0 (Public Domain)
-
-# 'basename' is not used by the functions here, but it doesn't mean that it
-# cannot be used at all.
-# shellcheck disable=2034
-target=$1 basename=$2 dest=$3
-
-# Add dependency to these files as well.
-redo-ifchange lib.rc config.rc
-
-setv() {
- # Usage: setv [variable = [key...]]
- #
- # Variable setting function that somewhat imitates the Makefile syntax.
- # - Using == sets the variable.
- # - Using = sets the variable if it is unset.
- # - Using += increments to a variable.
- [ "$3" ] || {
- printf '%s\n' "Faulty variable syntax" >&2
- exit 1
- }
- var=$1 sym=$2; shift 2
- case "$sym" in
- ==) export "$var=$*" ;;
- =) eval "[ \"\$$var\" ]" || export "$var=$*" ;;
- +=) eval export "$var=\$$var $*"
- esac
-}
-
-targcheck() {
- # Usage: targcheck [target...]
- #
- # Check if current target is one of the given arguments of this function.
- # Returns 0 if target is one of the arguments, returns 1 if not.
- for arg; do
- [ "$arg" = "$target" ] && return 0
- done; return 1
-}
-
-PHONY() {
- # Usage: PHONY [target...]
- #
- # Function that resembles the .PHONY: target on the classic 'make' system.
- # You can either use it without an argument on a single target, or specify
- # multiple targets.
- if [ -z "$1" ] || targcheck "$@"; then
- # There is no guarantee that the value of dest will not be modified
- # during the operation, we want to evaluate the value of $dest as soon
- # as possible
- # shellcheck disable=2064
- trap "rm -f $dest" EXIT INT
- fi
-}
-
-expsuf() {
- # Usage: expsuf [suffix [item...]]
- #
- # Expand suffix for the given list.
- suffix=$1 buf=; shift
- for i; do buf="$buf $i$suffix "; done; printf %s "$buf"
-}
-
-repsuf() {
- # Usage: repsuf [old-suffix new-suffix [item...]]
- #
- # Replace old-suffix with new-suffix on list.
- oldsuffix=$1 newsuffix=$2 buf=; shift 2
- for i; do buf="$buf ${i%$oldsuffix}$newsuffix "; done; printf %s "$buf"
-}
-
-redo_clean() {
- # Clean function for various redo implementations
- [ -r .do_built ] && {
- while read -r file; do
- [ -d "$file" ] || rm -f "$file"
- done < .do_built
- }
- find . -type f \( -name '*.tmp' -o -name '*.did' -o -name '.dep*' -o -name '.target*' \) \
- -exec rm -f -- {} +
- [ "$DO_BUILT" ] || find . -name '.do_built*' -exec rm -rf -- {} +
- [ "$REDO_BASE" ] || rm -rf -- .redo
-}
diff --git a/tools/do b/tools/do
deleted file mode 100755
index f38a2a7..0000000
--- a/tools/do
+++ /dev/null
@@ -1,446 +0,0 @@
-#!/bin/sh
-#
-# A minimal alternative to djb redo that doesn't support incremental builds.
-# For the full version, visit http://github.com/apenwarr/redo
-#
-# The author disclaims copyright to this source file and hereby places it in
-# the public domain. (2010 12 14; updated 2019 02 24)
-#
-USAGE="
-usage: do [-d] [-x] [-v] [-c] <targets...>
- -d print extra debug messages (mostly about dependency checks)
- -v run .do files with 'set -v'
- -x run .do files with 'set -x'
- -c clean up all old targets before starting
-
- Note: do is an implementation of redo that does *not* check dependencies.
- It will never rebuild a target it has already built, unless you use -c.
-"
-
-# CDPATH apparently causes unexpected 'cd' output on some platforms.
-unset CDPATH
-
-# By default, no output coloring.
-green=""
-bold=""
-plain=""
-
-if [ -n "$TERM" -a "$TERM" != "dumb" ] && tty <&2 >/dev/null 2>&1; then
- green="$(printf '\033[32m')"
- bold="$(printf '\033[1m')"
- plain="$(printf '\033[m')"
-fi
-
-# The 'seq' command is not available on all platforms.
-_seq() {
- local x=0 max="$1"
- while [ "$x" -lt "$max" ]; do
- x=$((x + 1))
- echo "$x"
- done
-}
-
-# Split $1 into a dir part ($_dirsplit_dir) and base filename ($_dirsplit_base)
-_dirsplit() {
- _dirsplit_base=${1##*/}
- _dirsplit_dir=${1%$_dirsplit_base}
-}
-
-# Like /usr/bin/dirname, but avoids a fork and uses _dirsplit semantics.
-qdirname() (
- _dirsplit "$1"
- dir=${_dirsplit_dir%/}
- echo "${dir:-.}"
-)
-
-_dirsplit "$0"
-REDO=$(cd "$(pwd -P)" &&
- cd "${_dirsplit_dir:-.}" &&
- echo "$PWD/$_dirsplit_base")
-export REDO
-_cmd=$_dirsplit_base
-
-DO_TOP=
-if [ -z "$DO_BUILT" ]; then
- export _do_opt_debug=
- export _do_opt_exec=
- export _do_opt_verbose=
- export _do_opt_clean=
-fi
-while getopts 'dxvcj:h?' _opt; do
- case $_opt in
- d) _do_opt_debug=1 ;;
- x) _do_opt_exec=x ;;
- v) _do_opt_verbose=v ;;
- c) _do_opt_clean=1 ;;
- j) ;; # silently ignore, for compat with real redo
- \?|h|*) printf "%s" "$USAGE" >&2
- exit 99
- ;;
- esac
-done
-shift "$((OPTIND - 1))"
-_debug() {
- [ -z "$_do_opt_debug" ] || echo "$@" >&2
-}
-
-if [ -z "$DO_BUILT" -a "$_cmd" != "redo-whichdo" ]; then
- DO_TOP=1
- if [ "$#" -eq 0 ] && [ "$_cmd" = "do" -o "$_cmd" = "redo" ]; then
- set all # only toplevel redo has a default target
- fi
- export DO_STARTDIR="$(pwd -P)"
- # If starting /bin/pwd != $PWD, this will fix it.
- # That can happen when $PWD contains symlinks that the shell is
- # trying helpfully (but unsuccessfully) to hide from the user.
- cd "$DO_STARTDIR" || exit 99
- export DO_BUILT="$PWD/.do_built"
- if [ -z "$_do_opt_clean" -a -e "$DO_BUILT" ]; then
- echo "do: Incremental mode. Use -c for clean rebuild." >&2
- fi
- : >>"$DO_BUILT"
- sort -u "$DO_BUILT" >"$DO_BUILT.new"
- while read f; do
- [ -n "$_do_opt_clean" ] && printf "%s\0%s.did\0" "$f" "$f"
- printf "%s.did.tmp\0" "$f"
- done <"$DO_BUILT.new" |
- xargs -0 rm -f 2>/dev/null
- mv "$DO_BUILT.new" "$DO_BUILT"
- export DO_PATH="$DO_BUILT.dir"
- export PATH="$DO_PATH:$PATH"
- rm -rf "$DO_PATH"
- mkdir "$DO_PATH"
- for d in redo redo-ifchange redo-whichdo; do
- ln -s "$REDO" "$DO_PATH/$d"
- done
- for d in redo-ifcreate redo-stamp redo-always redo-ood \
- redo-targets redo-sources; do
- echo "#!/bin/sh" >"$DO_PATH/$d"
- chmod a+rx "$DO_PATH/$d"
- done
-fi
-
-
-# Chop the "file" part off a /path/to/file pathname.
-# Note that if the filename already ends in a /, we just remove the slash.
-_updir()
-{
- local v="${1%/*}"
- [ "$v" != "$1" ] && echo "$v"
- # else "empty" which means we went past the root
-}
-
-
-# Returns true if $1 starts with $2.
-_startswith()
-{
- [ "${1#"$2"}" != "$1" ]
-}
-
-
-# Returns true if $1 ends with $2.
-_endswith()
-{
- [ "${1%"$2"}" != "$1" ]
-}
-
-
-# Prints $1 if it's absolute, or $2/$1 if $1 is not absolute.
-_abspath()
-{
- local here="$2" there="$1"
- if _startswith "$1" "/"; then
- echo "$1"
- else
- echo "$2/$1"
- fi
-}
-
-
-# Prints $1 as a path relative to $PWD (not starting with /).
-# If it already doesn't start with a /, doesn't change the string.
-_relpath()
-{
- local here="$2" there="$1" out= hadslash=
- #echo "RP start '$there' hs='$hadslash'" >&2
- _startswith "$there" "/" || { echo "$there" && return; }
- [ "$there" != "/" ] && _endswith "$there" "/" && hadslash=/
- here=${here%/}/
- while [ -n "$here" ]; do
- #echo "RP out='$out' here='$here' there='$there'" >&2
- [ "${here%/}" = "${there%/}" ] && there= && break;
- [ "${there#$here}" != "$there" ] && break
- out=../$out
- _dirsplit "${here%/}"
- here=$_dirsplit_dir
- done
- there=${there#$here}
- if [ -n "$there" ]; then
- echo "$out${there%/}$hadslash"
- else
- echo "${out%/}$hadslash"
- fi
-}
-
-
-# Prints a "normalized relative" path, with ".." resolved where possible.
-# For example, a/b/../c will be reduced to just a/c.
-_normpath()
-(
- local path="$1" relto="$2" out= isabs=
- #echo "NP start '$path'" >&2
- if _startswith "$path" "/"; then
- isabs=1
- else
- path="${relto%/}/$path"
- fi
- set -f
- IFS=/
- for d in ${path%/}; do
- #echo "NP out='$out' d='$d'" >&2
- if [ "$d" = ".." ]; then
- out=$(_updir "${out%/}")/
- else
- out=$out$d/
- fi
- done
- #echo "NP out='$out' (done)" >&2
- out=${out%/}
- if [ -n "$isabs" ]; then
- echo "${out:-/}"
- else
- _relpath "${out:-/}" "$relto"
- fi
-)
-
-
-# Prints a "real" path, with all symlinks resolved where possible.
-_realpath()
-{
- local path="$1" relto="$2" isabs= rest=
- if _startswith "$path" "/"; then
- isabs=1
- else
- path="${relto%/}/$path"
- fi
- (
- for d in $(_seq 100); do
- #echo "Trying: $PWD--$path" >&2
- if cd -P "$path" 2>/dev/null; then
- # success
- pwd=$(pwd -P)
- #echo " chdir ok: $pwd--$rest" >&2
- np=$(_normpath "${pwd%/}/$rest" "$relto")
- if [ -n "$isabs" ]; then
- echo "$np"
- else
- _relpath "$np" "$relto"
- fi
- break
- fi
- _dirsplit "${path%/}"
- path=$_dirsplit_dir
- rest="$_dirsplit_base/$rest"
- done
- )
-}
-
-
-# List the possible names for default*.do files in dir $1 matching the target
-# pattern in $2. We stop searching when we find the first one that exists.
-_find_dofiles_pwd()
-{
- local dodir="$1" dofile="$2"
- _startswith "$dofile" "default." || dofile=${dofile#*.}
- while :; do
- dofile=default.${dofile#default.*.}
- echo "$dodir$dofile"
- [ -e "$dodir$dofile" ] && return 0
- [ "$dofile" = default.do ] && break
- done
- return 1
-}
-
-
-# List the possible names for default*.do files in $PWD matching the target
-# pattern in $1. We stop searching when we find the first name that works.
-# If there are no matches in $PWD, we'll search in .., and so on, to the root.
-_find_dofiles()
-{
- local target="$1" dodir= dofile= newdir=
- _debug "find_dofile: '$PWD' '$target'"
- dofile="$target.do"
- echo "$dofile"
- [ -e "$dofile" ] && return 0
-
- # Try default.*.do files, walking up the tree
- _dirsplit "$dofile"
- dodir=$_dirsplit_dir
- dofile=$_dirsplit_base
- [ -n "$dodir" ] && dodir=${dodir%/}/
- [ -e "$dodir$dofile" ] && return 0
- for i in $(_seq 100); do
- [ -n "$dodir" ] && dodir=${dodir%/}/
- #echo "_find_dofiles: '$dodir' '$dofile'" >&2
- _find_dofiles_pwd "$dodir" "$dofile" && return 0
- newdir=$(_realpath "${dodir}.." "$PWD")
- [ "$newdir" = "$dodir" ] && break
- dodir=$newdir
- done
- return 1
-}
-
-
-# Print the last .do file returned by _find_dofiles.
-# If that file exists, returns 0, else 1.
-_find_dofile()
-{
- local files="$(_find_dofiles "$1")"
- rv=$?
- #echo "files='$files'" >&2
- [ "$rv" -ne 0 ] && return $rv
- echo "$files" | {
- while read -r linex; do line=$linex; done
- printf "%s\n" "$line"
- }
-}
-
-
-# Actually run the given $dofile with the arguments in $@.
-# Note: you should always run this in a subshell.
-_run_dofile()
-{
- export DO_DEPTH="$DO_DEPTH "
- export REDO_TARGET="$PWD/$target"
- local line1
- set -e
- read line1 <"$PWD/$dofile" || true
- cmd=${line1#"#!/"}
- if [ "$cmd" != "$line1" ]; then
- set -$_do_opt_verbose$_do_opt_exec
- exec /$cmd "$PWD/$dofile" "$@"
- else
- set -$_do_opt_verbose$_do_opt_exec
- # If $dofile is empty, "." might not change $? at
- # all, so we clear it first with ":".
- :; . "$PWD/$dofile"
- fi
-}
-
-
-# Find and run the right .do file, starting in dir $1, for target $2,
-# providing a temporary output file as $3. Renames the temp file to $2 when
-# done.
-_do()
-{
- local dir="$1" target="$1$2" tmp="$1$2.redo.tmp" tdir=
- local dopath= dodir= dofile= ext=
- if [ "$_cmd" = "redo" ] ||
- ( [ ! -e "$target" -o -d "$target" ] &&
- [ ! -e "$target.did" ] ); then
- printf '%sdo %s%s%s%s\n' \
- "$green" "$DO_DEPTH" "$bold" "$target" "$plain" >&2
- dopath=$(_find_dofile "$target")
- if [ ! -e "$dopath" ]; then
- echo "do: $target: no .do file ($PWD)" >&2
- return 1
- fi
- _dirsplit "$dopath"
- dodir=$_dirsplit_dir dofile=$_dirsplit_base
- if _startswith "$dofile" "default."; then
- ext=${dofile#default}
- ext=${ext%.do}
- else
- ext=
- fi
- target=$PWD/$target
- tmp=$PWD/$tmp
- cd "$dodir" || return 99
- target=$(_relpath "$target" "$PWD") || return 98
- tmp=$(_relpath "$tmp" "$PWD") || return 97
- base=${target%$ext}
- tdir=$(qdirname "$target")
- [ ! -e "$DO_BUILT" ] || [ ! -w "$tdir/." ] ||
- : >>"$target.did.tmp"
- # $qtmp is a temporary file used to capture stdout.
- # Since it might be accidentally deleted as a .do file
- # does its work, we create it, then open two fds to it,
- # then immediately delete the name. We use one fd to
- # redirect to stdout, and the other to read from after,
- # because there's no way to fseek(fd, 0) in sh.
- qtmp=$DO_PATH/do.$$.tmp
- (
- rm -f "$qtmp"
- ( _run_dofile "$target" "$base" "$tmp" >&3 3>&- 4<&- )
- rv=$?
- if [ $rv != 0 ]; then
- printf "do: %s%s\n" "$DO_DEPTH" \
- "$target: got exit code $rv" >&2
- rm -f "$tmp.tmp" "$tmp.tmp2" "$target.did"
- return $rv
- fi
- echo "$PWD/$target" >>"$DO_BUILT"
- if [ ! -e "$tmp" ]; then
- # if $3 wasn't created, copy from stdout file
- cat <&4 >$tmp
- # if that's zero length too, forget it
- [ -s "$tmp" ] || rm -f "$tmp"
- fi
- ) 3>$qtmp 4<$qtmp # can't use "|| return" here...
- # ...because "|| return" would mess up "set -e" inside the ()
- # on some shells. Running commands in "||" context, even
- # deep inside, will stop "set -e" from functioning.
- rv=$?
- [ "$rv" = 0 ] || return "$rv"
- mv "$tmp" "$target" 2>/dev/null
- [ -e "$target.did.tmp" ] &&
- mv "$target.did.tmp" "$target.did" ||
- : >>"$target.did"
- else
- _debug "do $DO_DEPTH$target exists." >&2
- fi
-}
-
-
-# Implementation of the "redo" command.
-_redo()
-{
- local i startdir="$PWD" dir base
- set +e
- for i in "$@"; do
- i=$(_abspath "$i" "$startdir")
- (
- cd "$DO_STARTDIR" || return 99
- i=$(_realpath "$(_relpath "$i" "$PWD")" "$PWD")
- _dirsplit "$i"
- dir=$_dirsplit_dir base=$_dirsplit_base
- _do "$dir" "$base"
- )
- [ "$?" = 0 ] || return 1
- done
-}
-
-
-# Implementation of the "redo-whichdo" command.
-_whichdo()
-{
- _find_dofiles "$1"
-}
-
-
-case $_cmd in
- do|redo|redo-ifchange) _redo "$@" ;;
- redo-whichdo) _whichdo "$1" ;;
- do.test) ;;
- *) printf "do: '%s': unexpected redo command" "$_cmd" >&2; exit 99 ;;
-esac
-[ "$?" = 0 ] || exit 1
-
-if [ -n "$DO_TOP" ]; then
- if [ -n "$_do_opt_clean" ]; then
- echo "do: Removing stamp files..." >&2
- [ ! -e "$DO_BUILT" ] ||
- while read f; do printf "%s.did\0" "$f"; done <"$DO_BUILT" |
- xargs -0 rm -f 2>/dev/null
- fi
-fi