cpt: switch back to 'make'

FossilOrigin-Name: 048c099fa4155f31725c51c27b09359d7b04f4c2d7e64f2a2b381ab7dea7803d

12 files changed, 99 insertions, 644 deletions

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..f90bc46
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,43 @@
+# Carbs Packaging Tools
+include config.mk
+
+INSTALL_SH = ./tools/install.sh
+BIN    = `find contrib src -name 'cpt*' ! -name '*.*'`
+LIB        = src/cpt-lib
+LIB_IN     = ${LIB:=.in}
+
+all: src/cpt-lib
+	test "${DOCS}" != yes || ${MAKE} -C docs all
+
+src/cpt-lib: src/cpt-lib.in
+	sed -e "s|@VERSION@|${VERSION}|g" \
+		-e "s|@DOCSTRING@|Call functions from the library|g" < src/cpt-lib.in > $@
+	chmod 755 $@
+
+test: all
+	shellspec
+	cd src; find . ../contrib -name 'cpt*' ! -name '*.*' -exec shellcheck -e 2119 -x -f gcc {} +
+
+dist: docs/cpt.info
+	mkdir "cpt-${VERSION}"
+	cp -r ${DISTFILES} "cpt-${VERSION}"
+	tar cf "cpt-${VERSION}.tar" "cpt-${VERSION}"
+	xz -z "cpt-${VERSION}.tar"
+	rm -rf -- "cpt-${VERSION}"
+
+install:
+	test "${DOCS}" != yes || ${MAKE} -C docs install
+	${INSTALL_SH} -Dm755 -t ${DESTDIR}${BINDIR} ${BIN}
+	${INSTALL_SH} -Dm644 -t ${DESTDIR}${MAN1} man/*.1
+
+uninstall:
+	test "${DOCS}" != yes || ${MAKE} -C docs uninstall
+	for bin in ${BIN}; do \
+		rm -f ${DESTDIR}${BINDIR}/$${bin##*/}; done
+	for man in man/*.1; do rm -f ${DESTDIR}${MAN1}/$${man##*/}; done
+
+clean:
+	test "${DOCS}" != yes || ${MAKE} -C docs clean
+	rm -rf src/cpt-lib "cpt-${VERSION}.tar.xz" coverage report
+
+.PHONY: all dist clean install uninstall
diff --git a/clean.do b/clean.do
deleted file mode 100644
index 57ab99f..0000000
--- a/clean.do
+++ /dev/null
@@ -1,5 +0,0 @@
-. ./config.rc
-redo src/clean
-redo_clean
-rm -f "cpt-$VERSION.tar.xz"
-find docs -name '*.info' -exec rm -f -- {} +
diff --git a/config.mk b/config.mk
new file mode 100644
index 0000000..482cf25
--- /dev/null
+++ b/config.mk
@@ -0,0 +1,23 @@
+# Carbs Packaging Tools
+VERSION = 6.0.0
+
+# Installation paths
+PREFIX    = /usr/local
+BINDIR    = ${PREFIX}/bin
+SHAREDIR  = ${PREFIX}/share
+INFODIR   = ${SHAREDIR}/info
+DOCDIR    = ${SHAREDIR}/doc
+CPTDOC    = ${DOCDIR}/cpt
+MANPREFIX = ${SHAREDIR}/man
+MAN1      = ${MANPREFIX}/man1
+
+EMACS     = emacs
+MAKEINFO  = makeinfo
+
+# Comment or change if you don't want to build/install the documentation
+DOCS = yes
+
+# Files to be added into the distribution tarball
+DISTFILES = contrib docs man spec src tests tools \
+            .dir-locals.el CHANGELOG.md INSTALL LICENSE \
+            Makefile README config.mk cpt-base
diff --git a/config.rc b/config.rc
deleted file mode 100644
index 963e71e..0000000
--- a/config.rc
+++ /dev/null
@@ -1,22 +0,0 @@
-# -*- mode: redo -*-
-# See LICENSE for copyright information
-
-# This loads some functions that are shared between redo files.
-# shellcheck source=./lib.rc
-. "${SRC_ROOT:=.}/lib.rc"
-
-setv VERSION = 5.1.1
-
-# Paths
-setv PREFIX    = /usr/local
-setv BINDIR    = "${PREFIX}/bin"
-setv SHAREDIR  = "${PREFIX}/share"
-setv DOCDIR    = "${SHAREDIR}/doc"
-setv CPTDOC    = "${DOCDIR}/cpt"
-setv INFODIR   = "${SHAREDIR}/info"
-setv MANPREFIX = "${SHAREDIR}/man"
-setv MAN1      = "${MANPREFIX}/man1"
-
-# Documentation tools
-setv EMACS    = emacs
-setv MAKEINFO = makeinfo
diff --git a/default.do b/default.do
deleted file mode 100644
index 23cedf8..0000000
--- a/default.do
+++ /dev/null
@@ -1,40 +0,0 @@
-. ./config.rc
-
-case "$1" in
-    all) redo-ifchange src/cpt-lib docs/all ;;
-    dist)
-        redo clean
-        redo "cpt-$VERSION.tar.xz"
-        ;;
-    src/cpt-lib)
-        redo-ifchange "$1.in"
-        sed -e "s|@VERSION@|$VERSION|g" \
-            -e "s|@DOCSTRING@|Call functions from the library|g" < "$1.in" > "$3"
-        chmod +x "$3"
-        ;;
-    "cpt-$VERSION.tar.xz")
-        redo docs/cpt.info
-        rm -rf -- "cpt-$VERSION"
-        mkdir -p "cpt-$VERSION"
-        { git ls-tree -r HEAD --name-only && echo docs/cpt.info ;} |
-            while read -r file; do
-                [ "${file##*/*}" ] ||
-                    mkdir -p "cpt-$VERSION/${file%/*}"
-                cp "$file" "cpt-$VERSION/$file"
-            done
-        tar cf "cpt-$VERSION.tar" "cpt-$VERSION"
-        xz -z "cpt-$VERSION.tar"
-        rm -rf -- "cpt-$VERSION"
-        mv "$1" "$3"
-        ;;
-    test)
-        redo src/test
-        ;;
-    src/clean)
-        rm -f src/cpt-lib
-        PHONY
-        ;;
-    *)
-        echo "Unknown target $1"
-        exit 99
-esac
diff --git a/docs/Makefile b/docs/Makefile
new file mode 100644
index 0000000..92b2c76
--- /dev/null
+++ b/docs/Makefile
@@ -0,0 +1,33 @@
+# Carbs Packaging Tools Documentation
+include ../config.mk
+INSTALL_SH = ../tools/install.sh
+
+all: cpt.txt cpt.texi cpt.info
+
+.SUFFIXES: .info .texi .org .txt
+.org.texi:
+	rm -f $@
+	${EMACS} $< --batch --eval "(require 'vc)" -f org-texinfo-export-to-texinfo
+
+.texi.info:
+	${MAKEINFO} $< -o $@
+
+.org.txt:
+	rm -f $@
+	${EMACS} $< --batch --eval "(require 'vc)" -f org-ascii-export-to-ascii
+
+clean:
+	rm -f cpt.info
+
+all-clean: clean
+	rm -f cpt.texi cpt.txt
+
+install: all
+	${INSTALL_SH} -Dm644 cpt.txt ${DESTDIR}${CPTDOC}/cpt.txt
+	${INSTALL_SH} -Dm644 cpt.info ${DESTDIR}${INFODIR}/cpt.info
+
+uninstall:
+	rm -rf ${DESTDIR}${CPTDOC}
+	rm -f  ${DESTDIR}${INFODIR}/cpt.info
+
+.PHONY: all clean all-clean install uninstall
diff --git a/docs/default.do b/docs/default.do
deleted file mode 100644
index fcf8802..0000000
--- a/docs/default.do
+++ /dev/null
@@ -1,33 +0,0 @@
-SRC_ROOT=..
-. ../config.rc
-
-# Extensionless name of file
-fn="${1%.*}"
-
-case "$1" in
-    all)  redo info ;;
-    allclean) redo ../clean; rm -f cpt.texi ;;
-    info) redo-ifchange cpt.info cpt.texi cpt.org ;;
-    *.info)
-        # Don't bother if makeinfo doesn't exist on the system, exit with success.
-        if ! command -v $MAKEINFO >/dev/null; then
-            PHONY
-            exit 0
-        fi
-        redo-ifchange "$fn.texi"
-        $MAKEINFO "$fn.texi" -o "$3"
-        ;;
-    *.texi)
-        [ -f "$fn.org" ] || exit 0
-        redo-ifchange "$fn.org"
-        cp "$fn.org" "$3.org"
-        $EMACS "$3.org" --batch -f org-texinfo-export-to-texinfo
-        rm -f "$3.org"
-        mv "$3.texi" "$3"
-        ;;
-    *)
-        echo "Unknown target $1"
-        exit 99
-esac
-
-PHONY all info html
diff --git a/install.do b/install.do
deleted file mode 100644
index dcab154..0000000
--- a/install.do
+++ /dev/null
@@ -1,17 +0,0 @@
-. ./config.rc
-redo all
-PHONY
-
-INSTALLSH=./tools/install.sh
-
-# Install executables.
-"$INSTALLSH" -Dm755 -t "$DESTDIR$BINDIR" $(getbin)
-
-# Install manual pages.
-"$INSTALLSH" -Dm644 -t "$DESTDIR$MAN1" man/*.1
-
-# Install the documentation info page.
-# We don't want to bother if the info page wasn't created, just exit without an
-# error.
-[ -f docs/cpt.info ] || exit 0
-"$INSTALLSH" -Dm644 docs/cpt.info "$DESTDIR$INFODIR/cpt.info"
diff --git a/lib.rc b/lib.rc
deleted file mode 100644
index 92dc216..0000000
--- a/lib.rc
+++ /dev/null
@@ -1,60 +0,0 @@
-# -*- mode: redo -*-
-# Helper functions
-target=$1 basename=$2 dest=$3
-
-# Make all targets dependent on the library and the config file
-redo-ifchange "$SRC_ROOT/lib.rc" "$SRC_ROOT/config.rc"
-
-setv() {
-    # Set variables if unset. Works similar to the Makefile syntax.
-    [ "$3" ] || {
-        printf '%s\n' "Faulty variable syntax" >&2
-        exit 1
-    }
-    var=$1; sym=$2; shift 2
-    case "$sym" in
-        \?=|=) eval "[ \"\$$var\" ]" || export "$var=$*" ;;
-        +=)    eval "export \"$var=\$$var $*\""
-    esac
-}
-
-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" ] || find . -name .redo -type d -exec rm -rf -- {} +
-}
-
-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.
-    case " $* " in *" $target "*) return 0; esac; 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
-        # shellcheck disable=2064
-        trap "rm -f $dest" EXIT INT
-    fi
-}
-
-getbin() {
-    # Function to get all executables
-    find src contrib \( -name cpt -o -name 'cpt-*' \) ! -name '*.in' ! -name '*.did'
-}
-
-# Phony targets
-PHONY all dist clean install uninstall test
diff --git a/src/test.do b/src/test.do
deleted file mode 100644
index 159cece..0000000
--- a/src/test.do
+++ /dev/null
@@ -1,7 +0,0 @@
-SRC_ROOT=..
-. ${SRC_ROOT}/config.rc
-
-redo-ifchange cpt-lib
-exec >&2
-find . ../contrib -name 'cpt-*' ! -name '*.*' -exec shellcheck -e 2119 -x -f gcc {} +
-PHONY
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
diff --git a/uninstall.do b/uninstall.do
deleted file mode 100644
index 3347874..0000000
--- a/uninstall.do
+++ /dev/null
@@ -1,14 +0,0 @@
-. ./config.rc
-
-# Remove executables.
-getbin | while read -r file; do
-    rm -f "${DESTDIR}${BINDIR}/${file##*/}"
-done
-
-# Remove manual pages.
-for man in man/*.1; do
-    rm -f "${DESTDIR}${MAN1}/${man##*/}"
-done
-
-# Remove the info page.
-rm -f "${DESTDIR}${INFODIR}/cpt.info"